From 4a23aacf967b0770a2288cce6cd83a7530d184f5 Mon Sep 17 00:00:00 2001 From: Valeri Sitnikov Date: Sun, 20 Sep 2026 22:38:17 +0100 Subject: [PATCH] baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json) Co-Authored-By: Claude Opus 5 --- .gitignore | 4 + NEXT_PAPER_logarithmic.md | 78 ++++ README.md | 82 ++++ anc/__init__.py | 0 anc/bench.py | 190 +++++++++ anc/rules.py | 204 +++++++++ article/sim_numerics.md | 296 +++++++++++++ article/sim_numerics.pdf | Bin 0 -> 358414 bytes article/sim_numerics.tex | 618 ++++++++++++++++++++++++++++ audit_algorithm.py | 342 +++++++++++++++ bench_full.py | 201 +++++++++ odestep/__init__.py | 0 odestep/controllers.py | 157 +++++++ odestep/driver.py | 114 +++++ relax/__init__.py | 0 relax/sor.py | 238 +++++++++++ report_sweep.py | 165 ++++++++ simroot/__init__.py | 6 + simroot/baselines.py | 489 ++++++++++++++++++++++ simroot/pure.py | 593 ++++++++++++++++++++++++++ simroot/sim.py | 237 +++++++++++ stage0_principle.py | 157 +++++++ stage0b_pure_similarity.py | 158 +++++++ stage0c_why_pure_fails.py | 95 +++++ stage0d_derived_similarity.py | 142 +++++++ stage0e_guard_cost.py | 57 +++ stage10_claim_checks.py | 157 +++++++ stage11_crosscheck.py | 137 ++++++ stage12_validation.py | 254 ++++++++++++ stage13_verdict.py | 267 ++++++++++++ stage14_is_anything_reusable.py | 186 +++++++++ stage15_ode.py | 189 +++++++++ stage16_blend.py | 277 +++++++++++++ stage17_anc.py | 81 ++++ stage18_bulletproof.py | 228 ++++++++++ stage19_modern.py | 241 +++++++++++ stage1_sim_variants.py | 70 ++++ stage20_prediction.py | 204 +++++++++ stage21_cosine_vs_oracle.py | 131 ++++++ stage22_untuned.py | 99 +++++ stage23_relaxation.py | 145 +++++++ stage2_guard_modes.py | 71 ++++ stage2b_itp_fairness.py | 141 +++++++ stage3_bound_check.py | 66 +++ stage4_why.py | 388 +++++++++++++++++ stage5_three_point.py | 112 +++++ stage6_projection.py | 88 ++++ stage6b_invariant.py | 131 ++++++ stage7_regimes.py | 275 +++++++++++++ stage8_phase_detector.py | 126 ++++++ stage9_timing.py | 333 +++++++++++++++ summary_table.py | 196 +++++++++ sweep_full.json | 1 + sweep_full.py | 241 +++++++++++ sweep_smoke.json | 1 + tests/test_analysis.py | 150 +++++++ tests/test_anc.py | 91 ++++ tests/test_article_numbers.py | 89 ++++ tests/test_blend.py | 90 ++++ tests/test_bulletproof.py | 161 ++++++++ tests/test_credit_guard.py | 246 +++++++++++ tests/test_modern_repairs.py | 111 +++++ tests/test_ode_controllers.py | 102 +++++ tests/test_phase_detector.py | 144 +++++++ tests/test_projection.py | 142 +++++++ tests/test_pure.py | 177 ++++++++ tests/test_regimes.py | 107 +++++ tests/test_registered_prediction.py | 77 ++++ tests/test_relaxation.py | 95 +++++ tests/test_reusability.py | 82 ++++ tests/test_revision_points.py | 177 ++++++++ tests/test_similarity_family_anc.py | 105 +++++ tests/test_simroot.py | 234 +++++++++++ tests/test_three_point.py | 124 ++++++ verify_article.py | 212 ++++++++++ 75 files changed, 12175 insertions(+) create mode 100644 .gitignore create mode 100644 NEXT_PAPER_logarithmic.md create mode 100644 README.md create mode 100644 anc/__init__.py create mode 100644 anc/bench.py create mode 100644 anc/rules.py create mode 100644 article/sim_numerics.md create mode 100644 article/sim_numerics.pdf create mode 100644 article/sim_numerics.tex create mode 100644 audit_algorithm.py create mode 100644 bench_full.py create mode 100644 odestep/__init__.py create mode 100644 odestep/controllers.py create mode 100644 odestep/driver.py create mode 100644 relax/__init__.py create mode 100644 relax/sor.py create mode 100644 report_sweep.py create mode 100644 simroot/__init__.py create mode 100644 simroot/baselines.py create mode 100644 simroot/pure.py create mode 100644 simroot/sim.py create mode 100644 stage0_principle.py create mode 100644 stage0b_pure_similarity.py create mode 100644 stage0c_why_pure_fails.py create mode 100644 stage0d_derived_similarity.py create mode 100644 stage0e_guard_cost.py create mode 100644 stage10_claim_checks.py create mode 100644 stage11_crosscheck.py create mode 100644 stage12_validation.py create mode 100644 stage13_verdict.py create mode 100644 stage14_is_anything_reusable.py create mode 100644 stage15_ode.py create mode 100644 stage16_blend.py create mode 100644 stage17_anc.py create mode 100644 stage18_bulletproof.py create mode 100644 stage19_modern.py create mode 100644 stage1_sim_variants.py create mode 100644 stage20_prediction.py create mode 100644 stage21_cosine_vs_oracle.py create mode 100644 stage22_untuned.py create mode 100644 stage23_relaxation.py create mode 100644 stage2_guard_modes.py create mode 100644 stage2b_itp_fairness.py create mode 100644 stage3_bound_check.py create mode 100644 stage4_why.py create mode 100644 stage5_three_point.py create mode 100644 stage6_projection.py create mode 100644 stage6b_invariant.py create mode 100644 stage7_regimes.py create mode 100644 stage8_phase_detector.py create mode 100644 stage9_timing.py create mode 100644 summary_table.py create mode 100644 sweep_full.json create mode 100644 sweep_full.py create mode 100644 sweep_smoke.json create mode 100644 tests/test_analysis.py create mode 100644 tests/test_anc.py create mode 100644 tests/test_article_numbers.py create mode 100644 tests/test_blend.py create mode 100644 tests/test_bulletproof.py create mode 100644 tests/test_credit_guard.py create mode 100644 tests/test_modern_repairs.py create mode 100644 tests/test_ode_controllers.py create mode 100644 tests/test_phase_detector.py create mode 100644 tests/test_projection.py create mode 100644 tests/test_pure.py create mode 100644 tests/test_regimes.py create mode 100644 tests/test_registered_prediction.py create mode 100644 tests/test_relaxation.py create mode 100644 tests/test_reusability.py create mode 100644 tests/test_revision_points.py create mode 100644 tests/test_similarity_family_anc.py create mode 100644 tests/test_simroot.py create mode 100644 tests/test_three_point.py create mode 100644 verify_article.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..673d98f --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +__pycache__/ +*.pyc +*.log +.pytest_cache/ diff --git a/NEXT_PAPER_logarithmic.md b/NEXT_PAPER_logarithmic.md new file mode 100644 index 0000000..fa04535 --- /dev/null +++ b/NEXT_PAPER_logarithmic.md @@ -0,0 +1,78 @@ +# Next paper: the logarithmic change of variable for wide brackets + +Not part of the current paper. Recorded here so the reasoning that leads to it +is not reconstructed from scratch. + +## Why this is a separate paper and not a fix + +The current paper's method is *additive*: every step moves the iterate by an +absolute amount, `|f|/|f'|`. On the Chandrupatla families `fun3.*`, `fun4.*`, +`fun5.*` the bracket is up to 10^12 wide while the root sits at |x| ≤ 3, so +the search must cross **twelve orders of magnitude**. An additive step cannot +do that efficiently: it is sized by the local slope, which says nothing about +how many decades remain. + +That is exactly what stage 7 measured. The cube-root similarity beats the +proposed rule on all five members of `fun4` — 32/32/40/47/59 against +89/93/113/125/153, a factor of 2.6 — and it does so because its step is +`(|f|/σ)^(1/3)·D` rather than `(|f|/σ)·D`, i.e. a fixed *fraction* of the +bracket rather than an absolute distance. It marches geometrically. + +So the regime is not "a different similarity function". It is **multiplicative +versus additive movement**, and that is a change of the space the method works +in, not of a coefficient inside it. + +## What was already tried and must not be repeated + +All of this is measured, in the repository, and pinned by tests. + +1. **Use `cbrt` where it wins.** A switch chosen per benchmark set is *worse* + than not switching: 6905 evaluations against 6026. `cbrt` wins the `fun` + families and loses the rest of Chandrupatla (4099 against 3220 over that + set). The regime is narrower than the set. +2. **Detect the regime from the value ratio.** `rho = 1 − |f_n|/|f_{n−1}|` + destroys the order (2.000 → 0.904) and doubles the cost on the standard + problems (84 → 161). Near the root both values are negligible and their + ratio is noise. +3. **Detect it from the local order of `f`.** Dropping the linearity + assumption from the contraction law *does* produce the march exponent, + `p = L/(L − ln m)` with `L = ln(e/D)`, and it collapses to the multiplier + `m = 1/(1 − θ)`, `θ = f·f''/(f')²`. The derivation is sound and the order + survives (2.001), but the estimator is not sharp enough: on + Alefeld–Potra–Shi, where almost every root is simple and the truth is + `m = 1`, it reports `m > 1` on **27.9%** of steps with excursions to + `m = 34.8`; on the flat families it fires on **35.8%**. 27.9 against 35.8 + is not a separation, and the false positives cost 273 evaluations. +4. **Separate the regimes by anything the method can see before it commits.** + Bracket width does not do it: the winners overlap completely, the proposed + scale winning on widths from 10^0 to 10^12. + +## The proposal + +Work in `u = sign(x − c)·log(1 + |x − c|/s)` rather than in `x`, with the +origin `c` and the unit `s` read from the bracket rather than chosen. An +additive step in `u` is a multiplicative step in `x`, so the same similarity +rule, the same derived scale and the same projection safeguard become a +geometric march without any new coefficient — and the march exponent, which +`cbrt` fixed at 1/3 by accident, disappears as a free quantity. + +Two things must be established before this is a paper: + +- **The transform must be parameter-free.** `c` and `s` have to come from the + bracket ends and the sign change, not from a choice. If they cannot, the + line closes the same way the phase detector did. +- **It must not cost anything on ordinary problems.** The transform has to be + the identity, to within rounding, when the bracket is narrow — otherwise it + buys the wide-bracket families at the price of the canonical set, which is + exactly the trade every attempt so far has failed. + +## What would settle it + +The same protocol as the current paper: the 154 Alefeld–Potra–Shi problems and +the 45 Chandrupatla problems, evaluations of `f` as the cost, failures charged +the full budget, the worst-case bound checked on every solved run, and the +configuration fixed by the derivation before the ranking is consulted. + +Target to beat: **6026** evaluations over the two sets, 193 of 199 solved, +with the `2⌈log₂(w/xtol)⌉ + 3` guarantee intact. On the Chandrupatla set alone +the target is ITP's **2857**, which the current method does not reach (3220). diff --git a/README.md b/README.md new file mode 100644 index 0000000..ab52f6f --- /dev/null +++ b/README.md @@ -0,0 +1,82 @@ +# sim-numerics — similarity as a step rule for root finding + +Artifact for the paper `article/sim_numerics.tex`. Every claim in the paper is +produced by one of the scripts below; nothing in the text is transcribed by +hand, and `verify_article.py` checks all 72 stated numbers against the run +data as part of the test suite. + +## Reproducing + +``` +python -m pytest tests/ -q # 490 tests +python sweep_full.py # the full grid, writes sweep_full.json +python verify_article.py # every paper number vs the data +``` + +Heavy runs go to a Linux machine (Python 3.12, run detached with a log, +`setsid nohup ... > sweep.log 2>&1`). **Use one platform for all numbers**: the +test functions call `libm`, whose last digit differs between Windows and Linux, +and the same SciPy version scores 2819 for TOMS 748 on Windows against 2820 on +Linux for the same set. The paper's numbers are the Linux ones. + +## Where each claim comes from + +| Paper | Claim | Script | +|---|---|---| +| Prop. 1 | the two-point similarity step **is** regula falsi | `tests/test_simroot.py::test_the_pure_two_point_similarity_step_is_regula_falsi_exactly` | +| Prop. 2, Table 1 | contraction law, predicted 0.1716 vs measured 0.1716 | `stage0c_why_pure_fails.py` | +| Cor. 1 | a chosen similarity fails on 5–8 of 8 problems | `stage0b_pure_similarity.py` | +| Cor. 2 | faster similarity is not better (`sqrt`, `cbrt`) | `stage0d_derived_similarity.py` | +| Cor. 3 | derived scale ⇒ the step is \|f\|/\|f'\| ⇒ superlinear | `stage0d_derived_similarity.py`, `stage0e_guard_cost.py` | +| §3 safeguards | bracket vs step vs both, and what each costs | `stage2_guard_modes.py`, `stage3_bound_check.py` | +| §3 order | 1.584 (2-point) vs 1.944 (3-point) | `stage5_three_point.py` | +| §3.1 | project vs replace; the guarantee costs nothing | `stage6_projection.py` | +| §3.1 | the projection invariant, instrumented per step | `stage6b_invariant.py` | +| §4 fairness | ITP is not handicapped; κ₁ and n₀ sweeps | `stage2b_itp_fairness.py` | +| Tables 2, 3 | the 154-configuration ranking on both sets | `sweep_full.py` → `report_sweep.py` | +| Table 4 | the law across the whole grid | `sweep_full.py` → `report_sweep.py` | +| §6 | approach vs endgame, order, boldness, step quality | `stage4_why.py` | +| §7.1 | the prototype-aggregation form loses 0/6/147 | `bench_full.py` (`SIM.pair2d.*`) | +| §7.2 | the 2× bound and high order are incompatible | `stage5_three_point.py`, `tests/test_three_point.py` | +| §7.4 | the symmetric ratio similarity degenerates | `simroot/pure.py` (`PURE_SIMS["ratio"]` docstring), `stage0d` | + +## Layout + +``` +simroot/pure.py the method: one similarity, one step rule, three guards +simroot/baselines.py bisection, 4 false-position variants, Ridders, Brent, + TOMS 748 (SciPy), ITP (own, validated against its theorem) +simroot/sim.py the prototype-aggregation form — a NEGATIVE result, kept + because the paper reports it +stage0*..stage5* the derivation, in the order it was actually established +bench_full.py 17 methods on both sets +sweep_full.py 9 similarities x 4 scales x 4 guards + 10 baselines +report_sweep.py reads sweep_full.json, produces the paper's tables +verify_article.py asserts the paper against the data (72 checks) +tests/ 490 tests; every bug found in audit is pinned here +``` + +## Negative results, so they are not reopened + +1. Similarity normalised by the two bracket ends **is** regula falsi, identically. +2. A faster-changing similarity is not better; what matters is the slope of + `1 - S` at zero matching the problem, and only the data supplies it. +3. Prototype-pair aggregation with softmax over the whole memory loses to the + simplest form: 0 wins / 6 ties / 147 losses against Brent on APS. +4. "Our safeguard fires less often" — refuted: Brent discards 53% of its + interpolations on the set it wins, 34% on the set it loses. +5. "Our steps are bolder" — refuted: on Chandrupatla Brent is bolder (56.3% + against 41.8%) and still loses. The mechanism is step *quality*: median + bracket removed 0.275 against 0.058. +6. Every safeguard that REPLACES the computed step with a midpoint destroys the + order: with the three-point scale, order falls from 1.94 to 1.00 and the APS + total from 2806 to 7260. **Resolved** by projecting the step onto the + admissible interval instead (`guard="project"`), which costs nothing on APS + (2806 either way) and gains on Chandrupatla (40/45 at 3220 against 35/45 at + 4104 unguarded). +7. Zero slack in the projection is degenerate: a worst case of exactly bisection + demands a halving at every step, leaving the projection no freedom. +8. Writing the projection as a radius around the midpoint instead of a clamp + loses the invariant to cancellation — a relative 8.9e-5 overshoot on eleven + Chandrupatla problems. +``` diff --git a/anc/__init__.py b/anc/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/anc/bench.py b/anc/bench.py new file mode 100644 index 0000000..22a3723 --- /dev/null +++ b/anc/bench.py @@ -0,0 +1,190 @@ +"""Active noise control: the step size of an adaptive filter. + +The third domain, and the one where the object we have is most exactly the +object the field argues about. + +In NLMS the coefficient update is + + w <- w + mu * e * x / (||x||^2 + eps) + +and mu = 1 is not an arbitrary scale: it is the step that drives the a +posteriori error at the current sample exactly to zero. Every practical +system uses mu < 1, because zeroing the current sample fits the measurement +noise as well as the signal. So mu is precisely a SAFETY FACTOR on an exact +step - the same object as the safety factor in ODE step control, and the same +object as the projection budget in the root-finding safeguard. + +The whole variable-step-size LMS literature exists because mu is hard to +choose, and it answers with more constants: Kwong and Johnston's rule has +four. What this file asks is whether the quantity mu is guessing can be +measured instead. + + predicted a posteriori error (1 - mu) * e if the model were exact + observed a posteriori error d - w_new . x after the update + +Their ratio says how much of e was signal the filter could actually remove +and how much was noise it could not. That is the safety factor, measured. + +The acoustic paths and the noise regimes are taken verbatim from our earlier +ANC benchmark (branch feature/sem-anc-benchmark of the SEM repository), so +the environment is the established one and not built to suit the result. +""" +from __future__ import annotations + +import math + +import numpy as np + +FS = 8000 +PRIMARY_PATH_LEN = 64 +SECONDARY_PATH_LEN = 32 +FILTER_LEN = 64 + + +# ---------------------------------------------------------------- paths --- +def make_primary_path(rng): + h = np.zeros(PRIMARY_PATH_LEN) + delay = rng.integers(5, 10) + h[delay] = 0.8 + 0.2 * rng.standard_normal() + for k in range(3): + idx = delay + rng.integers(3, 15) + if idx < PRIMARY_PATH_LEN: + h[idx] = (0.3 - 0.1 * k) * rng.standard_normal() + for i in range(delay + 5, PRIMARY_PATH_LEN): + h[i] += 0.05 * math.exp(-0.1 * (i - delay)) * rng.standard_normal() + return h + + +def make_secondary_path(rng): + h = np.zeros(SECONDARY_PATH_LEN) + delay = rng.integers(2, 5) + h[delay] = 0.9 + 0.1 * rng.standard_normal() + for k in range(2): + idx = delay + rng.integers(2, 8) + if idx < SECONDARY_PATH_LEN: + h[idx] = (0.2 - 0.05 * k) * rng.standard_normal() + for i in range(delay + 3, SECONDARY_PATH_LEN): + h[i] += 0.03 * math.exp(-0.15 * (i - delay)) * rng.standard_normal() + return h + + +# ------------------------------------------------------------- regimes --- +def gen_tonal(n, rng, f0=200.0): + t = np.arange(n) / FS + return np.sin(2 * math.pi * f0 * t + rng.uniform(0, 2 * math.pi)) + + +def gen_broadband(n, rng): + pink = np.zeros(n) + rows = np.zeros(5) + for i in range(n): + for j in range(5): + if i % (2 ** j) == 0: + rows[j] = rng.standard_normal() + pink[i] = np.sum(rows) + return pink / (np.std(pink) + 1e-12) + + +def gen_multitonal(n, rng, f0=100.0): + t = np.arange(n) / FS + ph = rng.uniform(0, 2 * math.pi, 3) + sig = (np.sin(2 * math.pi * f0 * t + ph[0]) + + 0.5 * np.sin(2 * math.pi * 2 * f0 * t + ph[1]) + + 0.25 * np.sin(2 * math.pi * 3 * f0 * t + ph[2])) + return sig / (np.max(np.abs(sig)) + 1e-12) + + +def gen_silence(n, rng): + return rng.standard_normal(n) * 0.01 + + +def gen_impulse_train(n, rng): + sig = np.zeros(n) + for _ in range(rng.integers(5, 12)): + pos = rng.integers(0, n) + width = rng.integers(10, 40) + amp = rng.uniform(1.0, 3.0) * rng.choice([-1, 1]) + end = min(pos + width, n) + sig[pos:end] = amp * np.exp(-5.0 * np.arange(end - pos) / width) + return sig + + +def scen_stable(n, rng): + seg = n // 4 + return np.concatenate([gen_tonal(seg, rng), gen_broadband(seg, rng), + gen_multitonal(seg, rng), + gen_silence(n - 3 * seg, rng)]) + + +def scen_gradual(n, rng): + a = np.linspace(0, 1, n) + return (1 - a) * gen_tonal(n, rng) + a * gen_broadband(n, rng) + + +def scen_abrupt(n, rng): + out = np.zeros(n) + gens = [gen_tonal, gen_broadband, gen_multitonal] + pos = 0 + while pos < n: + seg = min(int(rng.integers(n // 20, n // 8)), n - pos) + out[pos:pos + seg] = gens[rng.integers(0, 3)](seg, rng) + pos += seg + return out + + +def scen_cabin(n, rng): + engine = gen_multitonal(n, rng, f0=80.0) + road = 0.6 * gen_broadband(n, rng) + imp = 0.4 * gen_impulse_train(n, rng) + s = engine + road + imp + return s / (np.max(np.abs(s)) + 1e-12) + + +def scen_impulsive(n, rng): + return gen_impulse_train(n, rng) + 0.2 * gen_broadband(n, rng) + + +SCENARIOS = [("stable regimes", scen_stable), ("gradual transition", scen_gradual), + ("abrupt switching", scen_abrupt), ("car cabin", scen_cabin), + ("impulsive", scen_impulsive)] + + +# --------------------------------------------------------- the filter --- +def run_nlms(noise, prim, sec, rule, snr_db=30.0, seed=0): + """One NLMS/FxLMS run. Everything is fixed except `rule`, which returns + the step size for the current sample.""" + rng = np.random.default_rng(seed) + n = len(noise) + d = np.convolve(noise, prim)[:n] # what reaches the ear + xf = np.convolve(noise, sec)[:n] # filtered reference + p = float(np.mean(d * d)) + d = d + rng.standard_normal(n) * math.sqrt(p / (10 ** (snr_db / 10.0))) + + w = np.zeros(FILTER_LEN) + buf = np.zeros(FILTER_LEN) + err = np.zeros(n) + rule.reset() + for i in range(n): + buf[1:] = buf[:-1] + buf[0] = xf[i] + y = float(np.dot(w, buf)) + e = d[i] - y + err[i] = e + nrm = float(np.dot(buf, buf)) + 1e-6 + mu = rule.step(e, buf, nrm) + if mu != 0.0: + w += mu * e * buf / nrm + # the a posteriori error, which is what the rule needs to learn + # how much of e it was able to remove + rule.observe(e, d[i] - float(np.dot(w, buf)), mu) + else: + rule.observe(e, e, 0.0) + # noise reduction: power of the residual against the power of what would + # have reached the ear untreated, measured on the second half so the + # transient is not counted + half = n // 2 + p_in = float(np.mean(d[half:] ** 2)) + p_out = float(np.mean(err[half:] ** 2)) + if p_out <= 0.0 or not math.isfinite(p_out): + return float("nan") + return 10.0 * math.log10(p_in / p_out) diff --git a/anc/rules.py b/anc/rules.py new file mode 100644 index 0000000..67f66d6 --- /dev/null +++ b/anc/rules.py @@ -0,0 +1,204 @@ +"""Step-size rules for NLMS. Everything else in the filter is shared. + + mu = 1 drives the a posteriori error of the current sample to zero + mu < 1 hedges, because that sample carries measurement noise too + +So mu is a safety factor on an exact step, exactly as in ODE step control. +The variable-step-size literature answers the difficulty of choosing it with +more constants; the rule at the bottom measures it instead. +""" +from __future__ import annotations + +import math + + +class Rule: + name = "?" + constants = 0 + + def reset(self): + pass + + def step(self, e, x, nrm): + raise NotImplementedError + + def observe(self, e_pre, e_post, mu): + pass + + +class Fixed(Rule): + def __init__(self, mu): + self.mu = mu + self.name = f"fixed mu={mu:g}" + self.constants = 1 + + def step(self, e, x, nrm): + return self.mu + + +class KwongJohnston(Rule): + """The classical variable step size: mu(n+1) = a*mu(n) + g*e(n)^2, clamped. + + Four constants, and the paper that introduced it spends its length on how + to pick them.""" + + name = "Kwong-Johnston VSS" + constants = 4 + A, G, MU_MIN, MU_MAX = 0.97, 0.02, 0.001, 1.0 + + def reset(self): + self.mu = 0.5 + + def step(self, e, x, nrm): + return self.mu + + def observe(self, e_pre, e_post, mu): + self.mu = self.A * self.mu + self.G * e_pre * e_pre + self.mu = min(self.MU_MAX, max(self.MU_MIN, self.mu)) + + +class InSampleMeasured(Rule): + """REFUTED - kept so the mistake is reproducible. + + The first attempt measured the A POSTERIORI error of the sample the update + had just been fitted to. That observable is uninformative by + construction: NLMS with mu = 1 drives it to exactly zero, so the rule + reads "the model was perfect", proposes mu = 1 again, and is locked there. + Measured, it scores 18.50 dB against fixed mu = 1's 18.49 - the same rule + wearing a different name. + + It is the same error as the rho detector in the root-finding work: + measuring a quantity in the one place where it is identically zero.""" + + name = "in-sample (refuted)" + constants = 0 + + def reset(self): + self.rho = 1.0 + + def step(self, e, x, nrm): + return min(1.0, 1.0 / self.rho) if self.rho > 0.0 else 1.0 + + def observe(self, e_pre, e_post, mu): + if mu <= 0.0 or e_pre == 0.0: + return + predicted = abs((1.0 - mu) * e_pre) + observed = abs(e_post) + if predicted <= 0.0: + self.rho = 1.0 + observed / (abs(e_pre) + 1e-300) + else: + r = observed / predicted + if math.isfinite(r) and r > 0.0: + self.rho = math.sqrt(self.rho * max(r, 1e-6)) + + +class Measured(Rule): + """The safety factor measured out of sample. + + What mu is hedging against is the part of the error the filter cannot + cancel - the measurement noise. NLMS theory gives the step that minimises + the mean square deviation as the SIGNAL FRACTION of the error, + + mu = 1 - p_noise / p_error, + + and both quantities are observable. p_error is the running power of e. + p_noise is what e cannot be driven below, so it is estimated as the + smallest error power the run has sustained - the floor the filter keeps + hitting. + + Nothing here is chosen. The two smoothing weights are 1/2, an average of + the current observation with the accumulated one, not a tuned forgetting + factor; and the first samples, having no floor to compare against, take + the exact step - the licence the root-finding safeguard grants. + """ + + name = "measured (no constants)" + constants = 0 + + def reset(self): + self.p_err = None # running error power + self.floor = None # the smallest sustained error power seen + + def step(self, e, x, nrm): + if self.p_err is None or self.floor is None or self.p_err <= 0.0: + return 1.0 + frac = 1.0 - self.floor / self.p_err + return min(1.0, max(0.0, frac)) + + def observe(self, e_pre, e_post, mu): + p = e_pre * e_pre + self.p_err = p if self.p_err is None else 0.5 * (self.p_err + p) + if self.floor is None: + self.floor = self.p_err + elif self.p_err < self.floor: + self.floor = self.p_err + else: + # the floor may rise when the environment changes; let it drift up + # by the same averaging, so a regime change is not remembered for + # ever as a floor that no longer exists + self.floor = 0.5 * (self.floor + min(self.p_err, self.floor * 2.0)) + + +class CosineSimilarity(Rule): + """mu as a SIMILARITY, which is what this project was supposed to be about. + + The two rules above estimate mu from variances - a noise floor, a model + discrepancy. Neither is a similarity; both are statistics of the error. + The similarity formulation asks a different question: + + how much does the error RESEMBLE something the filter can remove? + + The filter can only remove what is correlated with its input. So the + quantity is the cosine similarity between the error and the filtered + reference, + + mu = || / (||e|| ||x||) in [0, 1], + + which is the cosine of the original paper, applied to the two signals the + filter actually has. It equals 1 when the error is entirely explainable + by the reference - the exact step is then right - and 0 when the error is + orthogonal to it, which is measurement noise the update can only fit. + + The three running means use the weight 1/2, an average of the current + observation with the accumulated one, and the first sample takes the exact + step for want of anything to compare. No constant is chosen. + """ + + name = "cosine similarity (no constants)" + constants = 0 + S = None # None means the identity: mu = |cos| directly + + def reset(self): + self.ex = None # running + self.ee = None # running + self.xx = None # running + + def step(self, e, x, nrm): + # decide from what has been accumulated SO FAR, then fold in the + # current sample - so the step never uses the observation it is about + # to be judged on + if self.ex is None: + mu = 1.0 + else: + den = math.sqrt(self.ee * self.xx) + if den <= 0.0 or not math.isfinite(den): + mu = 1.0 + else: + cos = min(1.0, abs(self.ex) / den) + if self.S is None: + mu = cos + else: + # the general family: mu = S(d) with d = 1 - |cos| the + # dissimilarity between the error and what the filter can + # remove. d = 0 means fully removable, so S(0) = 1 and the + # exact step is taken; the identity above is S(d) = 1 - d. + mu = max(0.0, min(1.0, self.S(1.0 - cos))) + xv = float(x[0]) + self.ex = e * xv if self.ex is None else 0.5 * (self.ex + e * xv) + self.ee = e * e if self.ee is None else 0.5 * (self.ee + e * e) + self.xx = xv * xv if self.xx is None else 0.5 * (self.xx + xv * xv) + return mu + + +ALL = [Fixed(0.1), Fixed(0.5), Fixed(1.0), KwongJohnston(), + InSampleMeasured(), Measured(), CosineSimilarity()] diff --git a/article/sim_numerics.md b/article/sim_numerics.md new file mode 100644 index 0000000..2bf8862 --- /dev/null +++ b/article/sim_numerics.md @@ -0,0 +1,296 @@ +# Similarity as a Step Rule: Parameter-Free Root Finding Derived from a Similarity Function + +V. Sitnikov + +--- + +## Abstract + +Bisection places the next iterate at the midpoint because it uses no information about the function's value. We replace that rule with a *similarity* rule: the step is proportional to how *dissimilar* the current outcome $f(x)$ is to the expectation $0$, measured by a similarity function $S:\mathbb{R}\to[0,1]$ with $S(0)=1$. We derive the contraction factor of the resulting iteration in closed form; it predicts a linear rate to four digits when $1-S$ has a non-zero slope at the origin, and a sublinear $e_n\sim C/n$ with a predicted $C$ when it does not, both confirmed. Three consequences follow. First, with the *ratio* similarity scaled by the far end — and with that combination only, of the five tested — the rule reproduces the false-position formula identically; so does the truncated linear similarity scaled by a divided difference over the *bracket ends*, which shows that the boundary of novelty runs through which points the difference is taken over. Second, any similarity fixed in advance with the scale also fixed yields at best linear convergence at a rate that is a property of the problem rather than of the method; on the eight standard problems of §2.2, five to eight of them fail. Third, the rate vanishes exactly when the scale equals the local scale of the value axis; reading that scale off the data — a divided difference, not a fitted coefficient — turns the step into $|f|/|f'|$ and the convergence superlinear. + +The derivation fixes the method completely, before any benchmark is consulted: a similarity whose approach to 1 is linear, the finest available data-derived scale, and a safeguard that projects the step onto the admissible interval rather than replacing it. What results is, explicitly, a Newton step with a three-point divided-difference derivative, clipped to the bracket and projected onto the bisection budget; the similarity function is scaffolding of the derivation and does not appear in the final rule. It carries a proven worst case of twice bisection plus one step and contains no constant calibrated on a problem or on the benchmark. On the 154 problems of Alefeld, Potra and Shi it needs 2806 evaluations of $f$ against 2820 for TOMS 748 — a margin of 0.5%, which is a tie — and 2890 for Brent, whom it beats on 102 problems to 40 head to head. On the 45 problems of Chandrupatla it beats Brent 30 to 4 and TOMS 748 31 to 8, and loses to ITP. The result is parity with methods built on tuned constants, obtained without any. For every data-derived scale, the ranking of the nine similarity functions matches the derived law without exception. + +--- + +## 1. Introduction + +A bracketing root finder must decide, at every step, where inside the bracket to evaluate next. Bisection answers "in the middle", which is the correct answer when nothing is known. Every improvement since has answered "where a local model of $f$ says the root is": a secant in false position, an inverse quadratic in Brent [2], a cubic in TOMS 748 [1], an interpolate–truncate–project cycle in ITP [4]. Each of those answers carries constants: Illinois halves the stale ordinate, Brent accepts an interpolation subject to three empirical inequalities, ITP is governed by $\kappa_1,\kappa_2,n_0$. + +This paper asks a different question. Suppose the only thing available is a *similarity function* — a map $S$ from an outcome to $[0,1]$, where 1 means "identical to what was wanted" and 0 means "not similar at all", in the sense used for parameter-free control in [6]. Can a root finder be built out of $S$ alone, and how does it compare with methods built out of polynomial models and tuned constants? + +The answer is sharp in both directions, and the negative half is as informative as the positive half. + +--- + +## 2. The similarity step rule + +**Definition 1 (Similarity step).** Let $[a,b]$ bracket a root, $x$ be the current iterate and $x_\mathrm{far}$ the opposite end. Let $S:\mathbb{R}\to[0,1]$ with $S(0)=1$ be a similarity function and $\sigma>0$ a scale. The next iterate is + +$$x' \;=\; x \;+\; \bigl(1 - S(f(x)/\sigma)\bigr)\,(x_\mathrm{far} - x). \tag{1}$$ + +The rule is exactly the informal statement "step further when the outcome is dissimilar to the expectation, and less far when it is similar". Bisection is the degenerate member $S\equiv\tfrac12$: a similarity function that carries no information about $f$. + +### 2.1 The two-point normalisation is false position + +The most obvious way to make (1) scale-free is to normalise the similarity by the two ends of the bracket, $S(a)=|f(b)|/(|f(a)|+|f(b)|)$ and $S(b)=1-S(a)$, and to place the next iterate at the similarity-weighted average of the ends. + +**Proposition 1.** For the ratio similarity $S(z)=1/(1+|z|)$ with $\sigma=|f(x_\mathrm{far})|$, equivalently for the endpoint weights above, +$$S(a)\,a + S(b)\,b \;=\; \frac{a f(b) - b f(a)}{f(b)-f(a)}.$$ + +That is the false-position formula. Two things must be said about how far it reaches, because the obvious generalisation is false. + +It is specific to that similarity. On $f=x^2-2$ over $[1,4]$, where false position gives 1.200000, the same construction gives 1.206812 for $e^{-|z|}$, 1.015228 for $1/(1+z^2)$, 1.007624 for $1/\sqrt{1+z^2}$ and 1.214286 for the truncated linear form: one of five reproduces it. So "a similarity rule scaled by the bracket is not a new method" would be too broad a conclusion, and this paper's own Table 3 refutes it — bracket-scaled configurations take first and third place on Chandrupatla and one of them solves 41 of 45, where false position solves 6. + +**Proposition 1'.** It is, however, specific to the *bracket ends* rather than to the ratio form. Take the truncated linear similarity $S(z)=\max(0,1-|z|)$ and the divided difference over the two ends, $\sigma=|f[a,b]|\cdot|b-a|=|f(b)-f(a)|=|f(a)|+|f(b)|$. Then $1-S=|f(a)|/(|f(a)|+|f(b)|)$, which is false position again, and the agreement is exact to the last bit. + +Together the two say where the boundary of novelty runs, and it is not where one would guess: it runs through the words *most recent* in the definition of $\hat f'$ in §3. A divided difference over the bracket ends is three centuries old; the same difference over the most recent iterates is the secant. In our measurements plain false position solves 127 of the 154 Alefeld–Potra–Shi problems, against 153 for bisection. + +### 2.2 The contraction law + +Write $e_n = x_n - r$ for the error, $D = x_\mathrm{far} - r$, and let $c$ be the slope of $1-S$ at the origin, $1-S(z) = c\,z + O(z^2)$. + +**Proposition 2 (Contraction law).** For a simple root and $e_n$ small, rule (1) satisfies + +$$e_{n+1} \;=\; e_n\left(1 - \frac{c\,|f'(r)|\,D}{\sigma}\right) + O(e_n^2), \qquad \text{rate} = \left|1 - \frac{c\,|f'(r)|\,D}{\sigma}\right|. \tag{2}$$ + +*Derivation.* $|f(x_n)| = |f'(r)|\,|e_n| + O(e_n^2)$, hence $1-S(f(x_n)/\sigma) = c\,|f'(r)|\,|e_n|/\sigma + O(e_n^2)$, and $x_\mathrm{far}-x_n = D - e_n$. Substituting into (1) and discarding second-order terms gives (2). $\square$ + +Table 1 checks (2) against measurement on $f(x)=x^2-2$ over $[0,2]$ with $\sigma=|f(0)|$, for which $|f'(r)|=2\sqrt2$, $D=2-\sqrt2$ and $\sigma=2$. + +**Table 1.** The contraction law against measurement, all rows at the *chosen* scale $\sigma=|f(x_0)|$. $c$ is the slope of $1-S$ at the origin and $c_2$ the coefficient of $z^2$ when $c=0$. + +A similarity with $c=0$ does not converge at a rate at all. Expanding $1-S=c_2z^2+O(z^4)$ in the same way as (2) gives $e_{n+1}=e_n-c_2|f'(r)|^2|D|e_n^2/\sigma^2+O(e_n^3)$, hence + +$$e_n \;\simeq\; \frac{\sigma^2}{c_2\,|f'(r)|^2\,|D|}\cdot\frac1n, \tag{2a}$$ + +sublinear rather than stagnant. Reporting a "measured rate" for these rows would report the value of $e_{n+1}/e_n$ at whatever $n$ the window happened to end — it creeps to 1 monotonically (0.925 at $n=10$, 0.991 at $n=100$, 0.9998 at $n=4000$) — so the prediction tested is the coefficient in (2a) instead. + +| $S(z)$ | $c$ | predicted | measured | +|---|---|---|---| +| $1/(1+\lvert z\rvert)$ | 1 | rate 0.1716 | 0.1716 | +| $e^{-\lvert z\rvert}$ | 1 | rate 0.1716 | 0.1716 | +| $1/(1+z^2)$ | 0, $c_2=1$ | $n\,e_n\to0.8536$ | 0.8503 | +| $e^{-z^2}$ | 0, $c_2=1$ | $n\,e_n\to0.8536$ | 0.8498 | +| $1/\sqrt{1+z^2}$ | 0, $c_2=\tfrac12$ | $n\,e_n\to1.7071$ | 1.6988 | +| $\max(0,1-\lvert z\rvert)$ | 1 | rate 0.1716 | captured, see below | + +The last row is not a slow rate but an immediate failure, and it matters because that similarity is the one this paper goes on to propose. At $x_0=0$ the residual is $z=-1$, so $S=\max(0,1-1)=0$, the step is the whole bracket, the iterate lands exactly on $x_\mathrm{far}$ and never leaves: the error is 0.5858 after one step and after two hundred. **The failure is a property of the chosen scale, not of the similarity.** Under the derived scale of §3 the residual $|f|/\sigma$ stays below 1 — on this problem the clip does not engage on a single one of the seven steps the method takes — the truncation never fires, and the same function is the best of the nine (Table 4). This is the paper's own thesis, that the content sits in the scale and not in the shape of $S$, showing up as a discontinuity in the behaviour of one function. + +**Corollary 1 (A chosen similarity is not enough).** For fixed $S$ and fixed $\sigma$ the rate in (2) depends on $|f'(r)|$, $D$ and $\sigma$, none of which is under the method's control. Convergence is at best linear and occurs only when the product lands in $(0,2)$. + +Empirically, with $\sigma$ taken as $|f|$ at the starting point, five to eight of the eight standard problems fail outright for the six similarity functions tested. Those eight, used throughout as a quick set and never as evidence on their own, are: $x^2-2$ on $[0,2]$; $\cos x-x$ on $[0,1]$; $e^x-2$ on $[0,2]$; $x^3-x-2$ on $[1,2]$; $\sin x-\tfrac12$ on $[0,1.5]$; $x^{10}-1$ on $[0,1.3]$, which stalls false position; $e^{-x}(x-1)$ on $[-1,40]$, whose right end is flat to $10^{-16}$; and $\arctan x$ on $[-1,3]$. + +**Corollary 2 (Missing the calibration in either direction costs).** The rate degrades as the product $c\,|f'(r)|\,|D|/\sigma$ departs from 1, upwards or downwards. We claim no symmetry between the two directions, and the measurements do not support one: similarities with unbounded slope — $1-\sqrt{|z|}$ has $c\approx3.2\cdot10^{3}$ at the resolution used, $1-|z|^{1/3}$ has $c\approx4.6\cdot10^{4}$ — fail on five and six of the eight problems with a chosen scale, yet over the full benchmark they finish at 10497 and 11941, ahead of all three $c=0$ similarities at 14314, 15102 and 16394, and one of them heads Table 3. Overshooting is the milder failure. + +**Corollary 3 (The scale must come from the data).** The rate is zero exactly when $c\,|f'(r)|\,D/\sigma = 1$, i.e. $\sigma = c\,|f'(r)|\,D$. Substituting this $\sigma$ back into (1) with $c=1$ gives $x' - x = |f(x)|/|f'|$, the Newton step. The similarity rule is therefore superlinear precisely when its scale is the *local scale of the value axis*, and that scale is not available a priori: it must be read off the evaluations. + +--- + +## 3. The method + +Corollaries 1–3 fix every choice in the method before any benchmark is consulted. We record them here as a prediction, and Section 5.2 tests it against the full grid. + +**Similarity: any with $c\neq0$.** The law makes the shape of $S$ almost irrelevant and its slope at the origin decisive. We take the plainest member, the **truncated linear** or tent form $S(z)=\max(0,1-|z|)$. It is not the ratio form $1/(1+|z|)$, which is a separate row of every table here; the two are distinguished throughout because Proposition 1 applies to the ratio form and Table 1's last row to the tent. + +**Scale: the finest data-derived one.** We set $\sigma = |\hat f'|\cdot|x_\mathrm{far}-x|$ with $\hat f'$ a divided difference of the **most recent evaluations** — not of the bracket ends, which by Proposition 1' would give false position. A divided difference is a computation, not a fitted coefficient: nothing is chosen, regressed or tuned. The two-point difference has slope error $O(h)$ and gives the secant order $\varphi\approx1.618$; the three-point difference — the derivative at $x_n$ of the parabola through the last three evaluations, $\hat f' = f[x_{n-1},x_n] + f[x_{n-2},x_{n-1},x_n](x_n-x_{n-1})$ — has error $O(h^2)$. A Newton step whose derivative carries an $O(h^2)$ error satisfies $e' = e-f/\hat f' = e-(e-ce^2+\dots)(1+O(e^2)) = ce^2+O(e^3)$, so the predicted order is **2** — not Muller's 1.84, which belongs to a method using the parabola's *root* rather than its *derivative*. Measured medians are 1.584 for the two-point scale and 2.000 for the three-point, against 1.809 for Brent and 2.654 for TOMS 748. + +**What the rule reduces to.** With $S(z)=\max(0,1-|z|)$ one has $1-S=\min(1,|z|)$, and (1) becomes + +$$x' \;=\; x + \operatorname{sign}(x_\mathrm{far}-x)\cdot\min\!\Bigl(\frac{|f(x)|}{|\hat f'|},\;|x_\mathrm{far}-x|\Bigr), \tag{4}$$ + +a Newton step with a three-point divided-difference derivative, clipped to the bracket and then projected as in §3.1. The similarity function does not appear in (4): it is scaffolding of the derivation, not machinery of the algorithm. + +We state this ourselves rather than leave it to be discovered, because it locates the contribution precisely. It is not a new family of methods. It is (i) a derivation that fixes every choice — which similarity, which scale, which safeguard — before any benchmark is consulted, and then predicts the ranking of all nine similarity functions correctly; (ii) a safeguard of ITP's projection type with ITP's truncation stage, and hence all three of its constants, removed; (iii) the negative results of §7; (iv) the measurements. + +**Algorithm.** Given $[a,b]$ with $f(a)f(b)<0$ and tolerance $\varepsilon_x$: + +``` +evaluate fa = f(a), fb = f(b) +A, B <- a, b the proven bracket +x <- the endpoint with the smaller |f|; xp <- the other; xp2 <- none +n_max <- 2 * ceil(log2(|b-a| / xtol)); allow <- 2^n_max * xtol/2 +while |B - A| > xtol: + far <- the end of [A,B] further from x + f' <- derivative at x of the parabola through (x,xp,xp2) + (two-point difference while xp2 does not yet exist) + sigma <- |f'| * |far - x| + if sigma is 0 or not finite: xn <- midpoint(A,B) + else: + xn <- x + min(1, |f(x)|/sigma) * (far - x) # the step, eq (4) + xn <- clamp(xn, hi - allow, lo + allow) # projection, eq (3) + if xn outside (A,B) or already evaluated: xn <- midpoint(A,B) + evaluate fn = f(xn); allow <- allow / 2 + xp2, xp, x <- xp, x, xn + update the bracket: whichever of A,B keeps the sign change +return midpoint(A,B) +``` + +Every quantity in it is either an evaluation of $f$, a divided difference of evaluations, or the halving that defines bisection. There is no line in which a value was chosen. + +### 3.1 The safeguard: project, do not replace + +An interpolation-only rule has no worst-case bound. The obvious safeguards *replace* the computed step with a midpoint whenever some progress test fails, and all of them are ruinous here, for a reason specific to a fast method: a step that collapses the *error* need not halve the *bracket*, so a bracket-based test fires on exactly the steps that were best. With the three-point scale, replacing on that test drops the observed order from 1.94 to 1.00 and the Alefeld–Potra–Shi total from 2806 to 7260 — worse than bisection. + +The remedy is to keep as much of the computed step as the budget allows. Let $n_\max=2\lceil\log_2(w_0/\varepsilon_x)\rceil$ be twice the bisection step count for the initial width $w_0$ and $x$-tolerance $\varepsilon_x$, and let $\epsilon=\varepsilon_x/2$. At step $j$, with the bracket $[\ell,h]$, define the allowance and the projection + +$$\alpha_j = 2^{\,n_\max-j}\epsilon, \qquad x \;=\; \operatorname{clamp}\bigl(x_\mathrm{sim},\; h-\alpha_j,\; \ell+\alpha_j\bigr). \tag{3}$$ + +The next bracket is at most $\max(x-\ell,\,h-x)$, so (3) gives $w_{j+1}\le\alpha_j$ directly, and induction bounds the run by $n_\max$ steps in exact arithmetic. In floating point the bracket can land exactly on the boundary, and the termination test then asks for one more; the guarantee stated and verified is therefore $2\lceil\log_2(w_0/\varepsilon_x)\rceil+3$ evaluations. + +Three remarks on why this introduces nothing. + +- **The doubling is not a tuning constant.** It is the factor already claimed in the bound. Zero slack — $n_\max=\lceil\log_2(w_0/\varepsilon_x)\rceil$, a worst case of exactly bisection — is degenerate and was measured as such: a worst case of exactly bisection demands a halving at *every* step, so the projection has no freedom, the radius on a unit bracket is 0.05 from the first step, and the guard behaves as bisection. +- **This is ITP's projection stage without ITP's truncation stage.** All three of ITP's constants live in the truncation, whose purpose is to repair regula falsi; the similarity step needs no repair, so the truncation and every constant with it are dropped. +- **Writing the clamp in the form (3) rather than as a radius $\alpha_j-w_j/2$ about the midpoint is not cosmetic.** That radius is a difference of two nearly equal numbers; the cancellation made the computed radius too large by a relative $8.9\cdot10^{-5}$, which broke the invariant on eleven Chandrupatla problems. + +--- + +## 4. Experimental protocol + +**Problem sets.** The 154 problems of Alefeld, Potra and Shi [1] and the 45 of Chandrupatla [3], taken programmatically from SciPy's `scipy.optimize._tstutils` so that no bracket or root is transcribed by hand. + +**Cost model.** Evaluations of $f$. A run counts as solved when it reports convergence and lands within $10^{-6}$ of the published root; $x$-tolerance $10^{-12}$; budget 200 evaluations. *Failures are charged the full budget*, so no method can buy a low total by giving up early, and totals are reported over all problems rather than over the subset a method happened to solve. Rankings are by failures first, then by total. + +**Fairness to the competitors.** Three deliberate concessions. + +1. ITP is natively written against a half-width $\epsilon$ and terminates on $b-a\le2\epsilon$; feeding the common tolerance in as $\epsilon$ would let it stop at twice its competitors' bracket width, so $\epsilon=\varepsilon_x/2$ is used. +2. ITP is reported both at the authors' recommended constants and as a *per-problem oracle*, the best of a $(\kappa_1,n_0)$ grid chosen separately for every problem — not an achievable method, included so that the state of the art cannot be said to have been handicapped. +3. Our implementation of ITP is validated against the method's own theorem, that it never needs more than $n_{1/2}+n_0$ iterations, on all 154 problems for $n_0\in\{0,1,2,5\}$. + +4. Where SciPy ships the method, the competitor is run at **the better of SciPy's implementation and ours, problem by problem**. This is not a formality. Our implementations turned out to be slightly *cheaper* than the library's — 6991 evaluations against `brentq`'s 7004, and 5209 against `_chandrupatla`'s 5228 — so quoting the library figure alone would have flattered us by a fifth of a percent, which on a 0.5% margin is not nothing. The two agree on 191 of 199 problems for Brent and 179 of 199 for Chandrupatla, the differences being one or two evaluations from the relative-tolerance term in the stopping rules. ITP has no library implementation, which is why it is checked against its own theorem instead; bisection and the false-position family are not in SciPy either and are ours. + +**Reproducibility.** All numbers come from a single Linux run. The test functions call `libm`, whose last digit differs between platforms; the same SciPy version scores 2819 for TOMS 748 on Windows and 2820 on Linux for the same set. Every number stated in this paper is checked against the run data by a script that is part of the test suite. + +--- + +## 5. Results + +The grid is nine similarity functions × four scales × six safeguards = 216 configurations, plus ten baselines. The configuration proposed in Section 3 — ratio similarity, three-point scale, projection safeguard — is one entry of that grid, fixed by the theory rather than chosen from the ranking. + +**Table 2.** Alefeld–Potra–Shi, 154 problems, out of 226 configurations. + +| # | configuration | tuned | solved | total evals | $>2\times$ | +|---|---|---|---|---|---| +| **1** | **proposed: tent, 3-point, projection** | **no** | 153/154 | **2806** | 0 | +| 2 | the same rule with no safeguard at all | no | 153/154 | 2806 | 0 | +| 3 | TOMS 748 | yes | 153/154 | 2820 | 0 | +| 4 | Brent | yes | 153/154 | 2890 | 0 | +| 11 | ITP, per-problem oracle | yes | 153/154 | 3260 | 0 | +| 18 | Ridders | no | 153/154 | 3313 | 0 | +| 31 | ITP, recommended constants | yes | 153/154 | 3957 | 0 | +| 61 | Illinois | yes | 153/154 | 7045 | 0 | +| 65 | bisection | no | 153/154 | 7530 | 0 | +| 206 | false position | no | 127/154 | 10560 | — | + +On the problems both solve, the proposed configuration beats Brent 102/11/40 (wins/ties/losses), TOMS 748 86/16/51, ITP at its recommended constants 132/3/18, the per-problem ITP oracle 121/4/28, and bisection 152/1/0. + +**Table 3.** Chandrupatla, 45 problems, brackets up to $10^{12}$ wide. + +| # | configuration | tuned | solved | total evals | +|---|---|---|---|---| +| 1 | similarity, $1-\sqrt{\lvert z\rvert}$, bracket scale, projection | no | **41/45** | 4516 | +| 2 | ITP, per-problem oracle | yes | 40/45 | 2611 | +| 3 | similarity, $e^{-\lvert z\rvert}$, bracket scale, both guards | no | 40/45 | 2733 | +| 5 | ITP, recommended constants | yes | 40/45 | 2857 | +| 6 | bisection | no | 40/45 | 3090 | +| **10** | **proposed: tent, 3-point, projection** | **no** | 40/45 | **3220** | +| 127 | TOMS 748 | yes | 40/45 | 4000 | +| 189 | Brent | yes | 38/45 | 4101 | + +The set's nominal winner is a similarity configuration that solves one problem more than anything else, 41 of 45, at a worse total; ranking by failures first puts it on top, and we report it as such rather than by the total that would flatter our proposal. The proposed configuration is tenth by total and beats Brent 30/4/4 and TOMS 748 31/1/8, while losing to ITP 17/0/23 and to the ITP oracle 16/0/24. + +### 5.1 What the guarantee costs + +Nothing on one set, and less than nothing on the other. Against the identical rule with no safeguard at all: + +| | solved | total evals | runs over the $2\times$ bound | +|---|---|---|---| +| APS, no safeguard | 153/154 | 2806 | 0 | +| APS, projection | 153/154 | 2806 | 0 | +| Chandrupatla, no safeguard | 35/45 | 4104 | 10 | +| Chandrupatla, projection | **40/45** | **3220** | **0** | + +On the canonical set the projection never binds and the totals are identical to the last evaluation. On the wide-bracket set it solves five more problems for 21% fewer evaluations. This is the opposite of the usual trade, and it is the point of projecting rather than replacing: the two safeguards that replace cost 7260 and 7239 on Alefeld–Potra–Shi, against 2806. + +### 5.2 Wall-clock time, and why it is not the cost model + +Evaluations of $f$ are the cost model because in any real problem $f$ is the expensive part. Wall-clock time measures something narrower — the method's own arithmetic per step — and it is implementation- and language-bound. We report it because a reader will ask, and because what it shows is instructive. + +On the 199 problems as they stand, every $f$ being a formula of a few operations, the proposed rule is the **slowest** of the pure-Python methods compared, at 32.8 ms against 18.4 for Brent, 21.1 for ITP, 14.2 for Ridders and 22.9 for bisection — while using the fewest evaluations of all of them, 4991 against 5932, 5675, 6421 and 9474. Bisection, needing nearly twice the evaluations, finishes in two thirds of our time. + +Those evaluation counts are *raw*: they are what the timing loop actually spent, and a failed run contributes only the evaluations it made before the budget ran out. They are therefore not the totals of §5, where a failure is charged the full 200-evaluation budget so that no method can buy a low score by giving up — 4991 raw against 6026 charged for the proposed rule, 5932 against 6991 for Brent, 9474 against 10620 for bisection. Wall-clock time can only be compared against what was really executed, so the raw counts are the right companions to the milliseconds; every comparison in §5 uses the charged ones. Both are stated to avoid the appearance of two incompatible sets of numbers for the same methods. + +That inversion is the point. Making $f$ progressively more expensive by a controlled amount of arithmetic and timing the sweep directly — nothing subtracted, nothing modelled — the proposed rule overtakes ITP once one call to $f$ costs about 9 µs and Brent at about 20 µs, which on this machine is of the order of a hundred arithmetic operations. Below that the ranking is decided by per-step overhead; above it, by evaluations. + +Three caveats, all of them limitations of the measurement rather than of the methods. Timings vary by tens of percent between runs even on an idle machine. An attempt to separate our per-step cost into "algorithm" and "Python call overhead", by timing a flattened rewrite of the same rule, produced a variant that diverged from the original on 42 of the 199 problems and was therefore discarded rather than quoted; the question stays open. And an earlier version of this measurement estimated a per-evaluation overhead by subtracting the measured cost of $f$, which returned *negative* overheads for four of six methods — an impossibility that condemned the estimator, and the reason nothing is subtracted here. + +### 5.3 The law across the whole grid + +Corollaries 1–3 predict an ordering of the nine similarity functions and of the four scales. Table 4 reports it. The prediction holds without exception for every data-derived scale: the three similarities with $c=1$ occupy the top three places and the three with $c=0$ the bottom three. For the chosen scale the two groups are indistinguishable (16102 against 15345), which is consistent — with a chosen scale nothing converges well and the ordering carries no information. + +**Table 4.** Mean total evaluations over both sets, step guard, grouped by the slope $c$ of $1-S$ at the origin. + +| scale | $c=1$ (linear approach) | $c=0$ (quadratic approach) | +|---|---|---| +| 3-point derived | **6809** | 22294 | +| 2-point derived | 6906 | 22167 | +| bracket | 10263 | 19137 | +| start (chosen) | 16102 | 15345 | + +Ranked individually and best over scales, the similarities come out $1-|z|$ (6496), $e^{-|z|}$ (6822), $1/(1+|z|)$ (7038), $(1+|z|)^{-2}$ (9502), $1-\sqrt{|z|}$ (10497), $1-|z|^{1/3}$ (11941), $e^{-z^2}$ (14314), $1/(1+z^2)$ (15102), $1/\sqrt{1+z^2}$ (16394); the scales come out 3-point (6496), 2-point (6628), bracket (9081), start (14540). Both orderings are those the law predicts, and both were predicted before the grid was run. + +--- + +## 6. Where the evaluations go + +Splitting each run at the geometric mean of the initial width and the attainable tolerance — the log-midpoint of the journey, at which bisection by construction has spent half its evaluations — separates the *approach* from the *endgame*. On Alefeld–Potra–Shi the two-point rule spends 2235 on the approach and 668 on the endgame against Brent's 2175 and 515: its deficit is almost entirely the endgame, i.e. the order, which is what motivated the three-point scale. On Chandrupatla it spends 1068 and 1161 against Brent's 1343 and 1358, winning both phases. + +Two natural explanations of the Chandrupatla advantage were tested and *refuted*. Brent discards 53.3% of its interpolations to its safeguard on the set it wins and only 34.0% on the set it loses, so safeguard rate is not the mechanism; and on Chandrupatla Brent is the bolder of the two — 56.3% of its probes land in the outer tenths of the bracket against our 41.8% — so step length is not the mechanism either. + +The mechanism is step *quality*. Reconstructing each method's bracket from the signs it observed, the median probe removes 0.500 of the bracket for every method on Alefeld–Potra–Shi, but on Chandrupatla it removes 0.275 for the similarity rule against 0.058 for Brent and 0.068 for TOMS 748 — and that comparison already flatters them, since 69 and 141 of their probes respectively fall outside the proven bracket and are excluded, against none of ours. High-order interpolation is a wager that $f$ is locally polynomial. When the wager pays, order 1.84 or 2.65 wins the endgame; when it fails, the probes are wasted. The similarity rule makes the weakest available assumption — a single local slope — and degrades gracefully. + +--- + +## 7. Negative results + +1. **The prototype-aggregation form of the method loses.** A richer construction — prototypes over *pairs* of evaluated points, softmax weights over the whole memory, similarity on both the value and the abscissa axis — leads on eight hand-picked problems but loses decisively on the real set: 0 wins, 6 ties and 147 losses against Brent. The simplest form of the idea won. + +2. **Every safeguard that replaces the step destroys the order.** Bracket-based and step-based replacement both drop the three-point rule from order 1.94 to 1.00 and cost 7260 and 7239 evaluations on Alefeld–Potra–Shi. Only projection preserves both. We record this because it is the trap the construction naturally falls into. + +3. **Zero slack in the projection is degenerate.** A worst case of exactly bisection demands a halving at every step and leaves the projection no freedom at all. + +4. **Regimes exist, at the level of a function family, and cannot be exploited by a switch.** The cube-root similarity beats the proposed rule on all five members of Chandrupatla's `fun4` — 32/32/40/47/59 against 89/93/113/125/153, a factor of 2.6 — and consistency across a family at different parameters is the signature of structure rather than luck. But the same similarity over the whole Chandrupatla set costs 4099 against 3220, so a switch chosen per benchmark is worse than no switch at all: 6905 against 6026 over both sets. The scale axis offers only 5.3% headroom even to an oracle handed the best scale per problem, two thirds of it inside a single problem family, and the winners are not separated by anything the method can see before it commits — the proposed scale wins on bracket widths from $10^0$ to $10^{12}$. + +5. **The phase detector: derivation sound, estimator not.** Redoing the contraction law without the assumption $|f|\approx|f'(r)|e$ — taking $|f|\approx K e^m$ instead — does produce the march exponent on its own, $p = L/(L-\ln m)$ with $L=\ln(e/D)$, giving $p=1$ at a simple root and dropping to 0.50 and 0.23 as the approach flattens, which is the neighbourhood of the cube root that wins those families. Substituted back it collapses to the multiplier $m$, measurable as $m = 1/(1-\theta)$ with $\theta = f f''/(f')^2$ from three divided differences and no constant. It preserves the order (2.001) and improves the eight standard problems (82 against 84) — and loses on the full benchmark, 6304 against 6026. The estimator is the failure: on Alefeld–Potra–Shi, where almost every root is simple and the truth is $m=1$, it reports $m>1$ on 27.9% of steps with excursions to $m=34.8$, against 35.8% on the flat families. 27.9 against 35.8 is no separation. A cruder variant, correcting by the fraction of its own promise the previous step kept, fails everything: the order collapses to 0.904 and the standard problems double to 161. + +6. **One problem defeats every method**, `aps.13.00`, $f(x)=x e^{-1/x^2}$, all of whose derivatives vanish at the root and which underflows to exactly zero throughout $|x|<0.086$; every method returns a machine zero at distance up to 0.086 from the root. + +7. **The symmetric ratio similarity degenerates.** For $S(x,y)=\min(|x|,|y|)/\max(|x|,|y|)$ with $y$ the target 0, $S\equiv0$; the only usable reading is $1-|f|/\sigma$, which saturates and stagnates (Table 1, last row). + +--- + +## 8. Conclusion + +A root finder can be derived from a similarity function alone, and the derivation shows where the content of such a method actually sits. It is not in the shape of $S$ — nine shapes were tried and their ranking is dictated by a single number, the slope of $1-S$ at the origin. It is not in making the similarity change faster — that overshoots exactly as readily as flatness stagnates. It is in the *scale* against which similarity is judged: chosen, the method is brittle and merely linear; taken from the bracket, it is false position and three centuries old; read off the data, it is superlinear. And the safeguard that makes such a method safe must project the step, not replace it: replacing costs the order, projecting costs nothing on one benchmark and improves the method on the other. + +The resulting rule has no tuning constant and carries a worst case of twice bisection plus one step. On the canonical Alefeld–Potra–Shi set it is level with TOMS 748 — 2806 evaluations against 2820 is a margin of 0.5% and should be read as a tie — and ahead of Brent by 2.9%, which it also beats 102 problems to 40 head to head. The claim the measurements support is parity with methods that carry tuned constants, not superiority over them. + +This is the same movement as in parameter-free similarity control [6], where membership functions are eliminated by normalising the input space from the data rather than by choosing widths. Here the object normalised is the value axis, and the price of choosing it by hand is measured rather than asserted. + +### Future work + +One weakness has a clear diagnosis and no fix inside this framework. On brackets many orders of magnitude wider than the distance to the root, the search must cross those decades, and an *additive* step of $|f|/|f'|$ is sized by the local slope, which knows nothing about how many decades remain. That is why the cube-root similarity, whose step is a fixed *fraction* of the bracket, beats the proposed rule 2.6-fold on those families, and why ITP keeps its lead on the Chandrupatla set. + +The regime is therefore multiplicative versus additive movement, not one similarity function versus another — a change of the space the method works in, not of a coefficient inside it. The natural instrument is a logarithmic change of variable, $u = \operatorname{sign}(x-c)\log(1+|x-c|/s)$, in which an additive step becomes a geometric march and the exponent that the cube root fixes at $1/3$ by accident disappears as a free quantity. Two conditions decide whether that is a method or another refuted idea: the origin $c$ and unit $s$ must be read from the bracket rather than chosen, and the transform must be the identity to within rounding on narrow brackets, so that the wide-bracket families are not bought at the price of the canonical set. Every attempt reported in §7 failed on exactly that second condition. + +--- + +## References + +1. G. E. Alefeld, F. A. Potra and Y. Shi, "Algorithm 748: Enclosing zeros of continuous functions," *ACM Trans. Math. Softw.*, vol. 21, no. 3, pp. 327–344, 1995. +2. R. P. Brent, *Algorithms for Minimization without Derivatives*. Englewood Cliffs, NJ: Prentice-Hall, 1973. +3. T. R. Chandrupatla, "A new hybrid quadratic/bisection algorithm for finding the zero of a nonlinear function without using derivatives," *Adv. Eng. Software*, vol. 28, no. 3, pp. 145–149, 1997. +4. I. F. D. Oliveira and R. H. C. Takahashi, "An enhancement of the bisection method average performance preserving minmax optimality," *ACM Trans. Math. Softw.*, vol. 47, no. 1, pp. 1–24, 2021. +5. C. Ridders, "A new algorithm for computing a single root of a real continuous function," *IEEE Trans. Circuits Syst.*, vol. 26, no. 11, pp. 979–980, 1979. +6. V. Sitnikov, "Parameter-free similarity control," preprint, 2026. +7. M. Dowell and P. Jarratt, "A modified regula falsi method for computing the root of an equation," *BIT*, vol. 11, pp. 168–174, 1971. diff --git a/article/sim_numerics.pdf b/article/sim_numerics.pdf new file mode 100644 index 0000000000000000000000000000000000000000..be66730a948fdc34942bc65298e7f0a161f3abe4 GIT binary patch literal 358414 zcma&NLy#^EtZ3V|cH6dX+ugfu+xXhHZQHhOd$(=dy8nB1XXg%1MwzFQ%376>DT<2I zG10TZkj*cTtiiA|5i%0m8(G2d^1?94n%bEIEC^ZHIXMXb|A1i-x3mG6IuSC6+ZX~& zMNN(EO-y0<`C*&^PNs&oFzy>AS~784?8v>R>eKk>3qW>a#1&~V27kA#&Uw=Opo+yr*6ln7JJ z&u8RI98*$dugpn}yu6%>F5PbJqL?pok~+4p5j?vRs&2itKVJf9egQqdpr@UgI0!y& zT95T+D4LSaYoULw5iDk8x(Iw$56bO#GLFbYfHg}cAsR-hxPdEFc#n6PXn|D(-Wqzg zOA>y)t0v34RK=bklg5*>sB4{4NJ4n&o4(A<6FKRWOYgS78DCrl9?q(@qIXI;#6M+ryUr;KfMX4Jb8u1Sr`V>L=^uF&Iq#rU>BUX@rO$rZCKBO^ zx#?k1MtN-)$7z}f6YXrs;#3O;F_X!dV}+H;GulpaXA4t{a_rBn8X6;8s6k3hWUL%j z<-?6MVS<$*kOA1CZJ!xk2sF+GtLB+xjv0EEUt#dA zQSId*3Uy*UkuBcKta})mleEv=5s&YbzpV|TmB#G~hQnhuMPT&P&68R1*yQYrX~5@Y z@aKc#a%>T=e{K)bE-CTKCYt9{dHcEi8?-6)gd>}lN~3#66wqud64V-`N<9pO8i{l0 zBoidqyds&G-^npFo5MhZS;%-~UEy#L70*5K*YQjsvVZ@$2$8?owX>3R5uceE)1c;W zMD7RCsh1#&jc4@vEWwvMlhctj=j$}quma2Uk#7XMHut@iRQYfXh`+R2=63w4gGuUm z(y9CoB7j5^(o0#`PWUQU#M`>XSWTSTS7eT^jbqS-}26oG-qS@B0BGd`7>4Y(H z2$9<-tp^~6#o!&)=iCAFm)?f=eFzh4$#JcjIq>i+gKv~Z(ge|I<8-@=VJzU>KCT&Q~!*wDaUcBgM&7TPwZsfdht5VHm45P43W zFDmBMV8JyXJrwM(ca`E7J0A^zsDvhD;p}p6IEm_5G4mVO&NR0GtFs2eZlLI;3c%@kG+Q( zx3enZiMLm`)@96My+&CD(ipw7c57WzA-iwxf(T*(QSm=0Ys$?UoOkzU8xj1k49(y@*4REVS@9E~ zlh%yB`O6N@gozRJO%96v)Q_ra4|eQLWtB^Q!yXN zKv0Z6U4!~z8ouXfEr9;07EDEe8Kv@)O{9fbVTyYj z+9_^esEn}Wsm`fUquVH^>`5#>Ywj|gs0L~%x(ycz;$X=|4o1VAY0%X`Z~$Eha3D#~ z{g5dH_JEa%G8YOdh0I6cOf8c?q zC^nnd$6Y1GZXqu_fJ0Uh%Rj;Ka?FC~Uq(|#Xy=a@jmD%AF^8%p>&YMlakl5!pxFe# zQLrCgZ_ijXoTzm^2*)AhQ90!CwTHoC8E-&tKuft`_OFbf$qU8Z)1 zb*hPnryHQ_OB7RsH1(z|*itMr(A}m<6#SY5br{-3kch&_h(4~jK{>M|i3vc04_@rD-2jzK%&*Lm@`o#dShHd9>>8I!-b7>Mz3Pcv~Tt zUj*;6qA6CVrmynQgj+`y=M(t81f^tT)J{*#S|c->cz~4M0zHsx3Fr6+qO4kdy5~(} zqxW96io>e*L-qNYN`9s>1I&Q$ni!Dt7nJfk9)I?SCB<5}2hAFgI~7)-3uA|PN>o~n3%gnN#SKD%uXUFN?2N|UEn%0DeGet)# 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

ui2i>#%iyGQnY>A_SE&(X8twixS85 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�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

FX+Cq1X^+U6AY|pY;X>5Zh=8JU6KfdV| zJ*<;39+z!}oRTcJP>3gfBnP=3XRl4cr|@nAZFOsC=#!$U7g4cXniyA^*dc!z6e(`} z7hal)#Bj{yF|sVEM3nrXH*-iV zFfRUDB+`|tpL=|U_pHei2Q@{DuJY?YjO^{GCB@A#hR%L0bt}!eMEa=>RUPOf#wAXj zspAx3@j2y((KwN43DJf%oYx6u#es>)`3&;`EKV}XYD5xP)b;&BR=s$?9-v(Q zI5?YuH&*&YD2UW`x{>)wsU?Phi}J4X^vjT+or>aXg$lEP0<@hl!Z?#$)Q>^Vz6v&= z3Y#$-RP0x_RqJG&K{K5Qek6|lmI_H$U%j8t>yGL+A!V?;49f?92mL#f6d=7zV`I@# zRpHCW;Tw9x2;Iu=JGg=OA_xUov4I=Hkz}2I`=z0%+Hsl@EYTu=Li2hPa%Ljm*yH<5 z;+sI?{inAj_w3$!HWXIWZxg4IvcR_&C?6w(4}ls@2r|ekkSv0kYv3ihdSJIPT2n+4 zB6S~?eh!@3*Y;8UlO2Ln<`-t~YmcMf+7g3~6Bm2w9e{0n8AxLR%A!CVq0(rZ6qG)c z5JE$6V@FpUnWCYL3WerZOLkK%#o`FTRy9JGUuj4#p{7EW6W=}&K{vxS@dF!t1h;>O zy)*JN1Ip9va-@gx;GTU*{?I}*gk6dWd6%I3n@t{ zBauz?9zEHWrD_HAm^&YdqXmTGLy!PAw@C_`U6GRfH_MaZuIPsl<8_{$o|IKsnt|bL zkn|oxP~4kT2!wJ_*4;Gk!#og`glD>L&#O^||qI^Nk%FkTE6n!A6I^E4JNRFxhm%AJ7z%9CX) zpJ3&+jIJt>e{ zReAvT-u0wdi&RN29q$IUs!paCpWhc?$&z4PRNrbN_XS5c{kuWhvV&X})FU*b}SMmVZ#g}m7yC$ z#s@sko(@7!E+dL9Ivk3gnKt!$4p>LnL$t|LL<%ewj?hWs8R%~&r>2_@RWr_6pY_Kj zMe6m$*#8t1%a=jtgHaZGWTOeHAbK&>K$+igmxcQb!tvFmNWvqCk1q2nmBI3{af6>C zBM^w@?4Mtkz8D*KRW(e}6>L7Fdl~4d&Bi0-1&C~@AH?25Fn3T?_E3E=#~c(4n*Bj) zh*EAGFTVrc(Jx}O5LJwY!e-XM^Db|9SB$H`%85}J>b=oCz@#g9Om^H~(nMq`eVT1~ zTm?ZH-%d$#6}OD}=$Wv$ayYoG#9#G{%nizI@GG9i38CHBh~)0M*8)PiJ;dB&gHI#* z#MemCq>zd4bMW*V(0F&fxShj)D>;>2BME!lS=^L|e4;_HxhEpLj(qmO4141@P_nn^ zIrZOlTrV*OCS9ebnCxX_@?se00VSb+aZY%Pq>@8jMp8;=l{sHAXQM2ds?+gdWBP5^ zB0K1-Cwxzu-NSYFYn~!}x&Csks5v(Q^&wSD*!R2xIcvsV?F%-4d@s4SE=2rBlFC%w z_jru@kU zZx?1>8Y@~-&g@xX6Girv$o)9l4~xF$2NC5_Dn4Is$*s$shE^S}TlgQf4-Af*)hVGe z8r^uHbJ@l-=KLuO)bDutO*-H;w~IC?=VZ=@(XI&A5!5)*_s7gdZp86MzWAawMPey-}~kt1mpb8jJRXbh}+$LWBeLq-GS?QcMRrUH;rOK0DTvv z&QN2a$ukRCxR>WET#OGGi9MrCl$X7us0@_P)(XBh`Qas%`}5BseV*9YSzzn<2}$8- z3fF3PJGap{&lW!yU{xwz32S}gKENE0Ti*(J%W*)I4kU0Oxn8z5>OOLYI^Um(h!A2t z-jn=>P(ILQ?#f4b%(no_Qt8PI4|a(^0^1s1{LiYJj5)b<5Sj)pe7ZFl5q;r%A;GA_ zyS%Qf7GJ0P_M1wK)UTzk~SF=m|jfV&Y^^)2pnZt$qSV#siXSnHRP^pF0@ zZmfxywFN~hlaXeXuTeD~C`rr^Nwl@o1H>@#BfWqQBhF@4BHw%}a3G}414R6jU0d;e zhOl1+>Ch$I203Awa7a@b$MWS4VzeOKK7V|Yg3VR7S8`f4I|UjM66v7~usVSl2XdK; z{49h&{*Fd^999O%(VNngrpM3|xZ-`_@Zl+Hc6Z0gt5T-L zg}Xm{kZB%YtR>)9$6O!p|8VV8&N=H-bXdi*rdFW@114mT!vK0!1{ zm~9msNH_)*Wf3P;)vv42jGgUlC0Tj52XLEOiq3rEgE?sAn+?-4p0fumD#OBn);L6k zboD9~b@qO=oyN5JoKYlTukDYhJ`sK`MD#9xW(2+n7)MFa=@r2l*_1Xsnn+@D4pMoe zjN<&vN+`x&?Y6gIV^3CLeg)IMvu}A8?C4mvdlcyK>DOy5#!{ zYP_GjFL^u(z+KJzp_aiJHRTf(F2K7Mj%kJ3DhbH+X|_npNBhxVm~U7G38Rij+s-dE zr=aqN4$pmkN!1{{iFf&h@?YJ>>kIglR)VgN1h^XcXX zFbV6ic0gQdPyW>+wn$Of1-7(G|85$>TKl@D>hhc{~_B^h`2zMAuEWi{}F8 z6Vmka!x@vV{K#yG*J*%VtH9Cniyx4z^=&*KSTJIgh|xSot-iVGRberjHW2mJJJ4qL zb5&2T+ggHy?{`2!>WKSX46Lu%+d_8{6cG#g-LOlJE+d!vHulY0*DMf-hWsn+RUjcm z+cL|Dt-%$o6RS4X+9j`4DTrtRLnzUdDq`Y_juz1I^uSPvTHtfZ$KrzSn0%D&tIUkz zrpnhDn}W3i39-A}kcYup@$E10xi^URbec>$1IipcHK>v}d{QhNL&_$+z;HqP&%i}77pGDec9{d0QA>}2i-i)Jh z2%fx!TQ^6JwnVb(W2DY?!i@WgN9I@+2&2;X9$SbJPn)oCrV}H)on2fFU(WZqt=@&9=+vv%TnjO$ZmJ@X@ij3Z_N#!C{g>#Av}JfX7!uKq@r^3 zAvVGh!6#3V9-8X1ZUY2R%`Eu1BO<{o2NkSofZiA~x>Gt#`QoVVD!oAIssUV@;m6tr zN5|65M8L7ELjc0e-+^l1WBVeOFa-H&kB-6oBi>-rRWG##j^_SdbeWe&th}KJ{MAKr zMi!b1{bm9bK!7$;!lK(K1BNC3LkYC7MZWzi2v>9^57u1oG9Q;>Y7+~BF;8!Z~?&`9bWxOS;G5EJoWkiL?uk@QTVo19E#_#j1g6E+K4%44e!7Dimwdi%z?OaXM zFx~DX1HXh`nCgLa&FuY+qo7Rh!?5%kWwmY@MM20fDe>X()^Ibm&=ND%kal5h{3vAPWUWL-1(9a!x%}YWre04VzU{lvJjszl*`u$B@|e z)c24L9P?1}W>UGO15D)zEooyD2j}MpE1DXazqeJ1>)-0}At`wsu#`_Pvs-jub9pBl zX*r$~GeRkd#|=GCmF7`Odh8BJ@Bz@iXnFB3FFclpWSZecQQp}6X04Z=m5~h$Oq+uG z4{}-glqehUpKpZ&Us94zeNHLPa_g8^JpNL5T1+9z6At_AY(Wo}-MhPp5sz z@2C}r83O;Tunw&1VnHX}g%CjAZvsJV?RT{4_nG|rqIu%-pPz!6{9ryas=fc{8(#|o zwc7|V#^A8g(|5*9Rrp5(r2Fb$R?IXhnAeYX<&{J%y^b>EN(Juml>SsT!+K36f}=Bv zrJLyp5?L1n{PMm}fd(+`d#GAfaL?e!NcfhO@SrWl;iTM2n9A2q6BZx^pX`=@NJ+_0 z&;SETqB%yORn_G$eC~7N7KsYmQCi59??VP7FjcTS%`eI4ftGJuyo=1`xb#FLXtOMW z^;dBo&K=v^rNP>9tsu$-T79IWxC_oBvH^_P^I47Ap5tC!vIa$U<8F3r$d};j3{l<8T8O-H4Q|?%Wac zHrAVAM&(9y_}bmkMV)#)D!OanC%R#L52ew)bZkaMOp8PRy=8>*8(LFK5S_;q+jnPv z;Bk?t-2M|T!cqP^HG83GNp?8J+F^N(kP;(uN6$5(O~=pec8u5g%L#Mpa2 z3#GC|kC_8O^64@p!l!_x+pC;N#Z#GYk8?PBxIpdIK)~c~#t=~FaIAcjzR z;K56uC=DN86N)(}d?qNt~k zJAPgEfVD2aUnaD1R&Bt4u^4E@OQzt2ftpa?Bjl=-qq)(lQmR~9ODA^NDz0G0=Cr23 zvj1J;m5}#8}t*-YMYR)AX42reK zv9tgUS~^Z>+VI>xD(0e(&bGv2$xhr8_A-)g=&Gn7a=jN`^J-&;ow56-zkfPy zFG5JUAP`a42_b_M;?POdANEGYMU3eg=yR)JOwWl{o-Wu&;-AprfNkqB z?9VcD7cJTMTT;z!-Ca6G@2}rAZ^n9IVuRNKfb^Ax4Tu1j-yfB17+DE5KD=)a3oXX` z-|63SD<-Hw!Ciu#0(Nx;Z2**`^T(Y(`}@ld$yz;pVd-}eKqu;$>cM_-xpowqWpsKQ zArsMEHi$Pu%!*Q&>bA<(1O94zA_eVrl%F^E_htu%YS!EYZ{~A7(Bk?p?jRnZvC~*3 zCHjC~wPAqgA?B>)y*}14qTW|n6tCV0SY3i7SaX0IAn&Z3xhOQ&mw$nH9dE}`?G_Y0 zwl}86I88>PL60g|ANvAdTmbArh&e7M0rdj#6SRwh1-n!e47)`RoO5- zM+3x}?iwC*P_>BO0J#&p`8^DV!u^2v8h%9Nc$ zb12Z7MPu8xZQHhO+fHt5+qP}n$&GE>PTyD6-J_oL?EHeS>eOC)FLbdt*bLr`)6S8{ zw7bA~Si+}iSL7L-JyH>{ZbD7m1}vyiyCGEV7PU~pW4#b znaAGTrsd-ZJ0Mq;e&Kx}%T5E%pA|+M4@=+xHac+{l9JH3ObE@Vf@}!a6;>hd{98j~ zaZT@_H{|WV8$hY)190o(+4C(bY)&K0+lHq!od!N~XUTh47yvOr?-);q?IcgRuy7$Rn_;ge@@%xNkW^&QJY*Fk;{-=PEzKM9g5>+kX1n_` zk4UbVm-kQw0wAl+So8-;YwOhO+1+AoWB2q#n?9`fWd?|ZhCR>Ba+{;9vp)yK(BX7} zmD)=;4t=Jc_P40}`2f4AB{jz|!#X~zU=%aDu8tJD_qGu*q7og!slJ1(0h=dum}aVC zey%E-K%XxYqm@qs->GCJGlPY9N-9Dun2VdIki`1tl7L;>#Y=4WsgQE+qOwoAOvU0eO=)R82(9 z6*|xAXq{qR>^(lD-dd2<{+=cWmaJfOtw}D-Wp;6s-loQt{-7Ht3siurLW26(W)PJJLjBK zdU7sQL#v&Y6=F1AwW{O|IE{H?Lq0_%01gyl48bY;2bOWTuhmgwz`~(0`q=WhHN=y= zhk=$!<-uI8GK03HoZjD3bGNw9_J!MeXX&BdLY~tp=-DX4=E2!a+}>IT8{d)1h&?g6 z6B$4%8KZzol3Dgbv+q+H^!W@0-vo&ViLh0XWjNx!hsU+P3wc7+NC#Cwiw-Ab*gsr5zR2a za+^M}W>E_s*4p~o#18uGG@^Re>sDBaQ&H$Rv*E3McSzjGyVW5ZPO58huVa+azYl<- zF3|QBY8f;d2N2vZ)}#OGn8(xb7B-vP%O|Uf%(N7Rl`TSetaT-d`EluY z#@7N&A7_E@q*-;-D+tdGZiz+va#VpTn?J6ODJKj_3=QTL&C>5;vd$ywzt!y&~W zrVfVu1w!X4GJ!B(iB;=S#ezm%|rN&|cwTHiK4rx@&0T@Hf~3(F{ASY<&P zAd4lG8UpVk8Z>d~L0gQFaJHU}^$mb4$v%Y!(vPV;XkwuPr=S*_6?$C>`>f3++0rQM*X+FU~ti;Met4yURQGEjtv#yA9EILX5Z z>_7F9GmHLy)ogj~?J)@B1=>!m9vA%#it_sMDFxqGYu7NCvf-ZZ8@CXzMD8qMzcDUJl?PrGOWmT`aF{NAb*y97xYnj)LgFh`z(14&>1I}>(6)0UtL zUisq?B`ibK2Ji@^H9r8tg>4TI`(5IC>u-p(q~vkd@<}~Aos~x=lSDsd?LSG5iz45T zRmmL6;D2R0EUwyti7;)tcDuTkn)H#=ia8+SQD8zppE*!0hM5@+`XZtYL%Ew zf>|VFZy(%&8n4D>v&O$kSf+sCr^&y_Q@>25YSOYexI6DjJ)jzyTbsbdh&ew@)mG&* z>lJ$={fb@iAqF1H+i!C>!}k>&AQg)OpNdLA8aP0XKQVgd?fXsVh3!P-%nyJRmI@oF zhFoHuF48C5rauB6paYYN`j0Z;fG^|)s?xFIZ3Yy+$m}3^woP^2&wgXarqpJpxUYw! z?IP+duj<1}q&x5~z(1+6`pYg7kOASO`pyWl~u1mj-m`}LGkW6@OgWJe}#E>qFcKJ%-wwT>QXPlQcDgaoMTRN z*4$8_pn15=&PUQ87S?u_#VCN0OOfq#U0xR+3S&(>mYfJgAn8BflwA4(Pd#in8@OE@ z1BTyr)DH_$Es}cF9^5zB?xDdk*GnefGFDt=um_Ab2$Jg;;msTSu=b=MDw&DlLG0js z6lgPSF6SLblvR)$K|I;Pm(}q)9o*jh+amczar&SC$hhay^^EK1lOclILl6Oizr9pq zPYC^5G>>FHmq)~I-ZVVUtyE32^fq1GjFnh9U(5Sd_ZddppVaW*(H8w^EnS=`tVWvg z5Kt7qUR*Sb!6eX3t#6ESy;(asDLW=2gsa|cSM5uZh)o(#{%>sb3_!IoWw zSY!77yrwC&7&=!|R9i<%h)+bn*4boly9MyNz+9ygnq#0|aZ_({@6`?`MXm)zn-<~B zmnfYWR0hS>{>bLW=_vGwjX`DbeHF(risaiRDgUW9sHX;LC(C5CxJgf_VdUS**NAUp zeqYH%QIH=8v)9vi7UT#-X2$E7>QsCI88*B5h$|3i&@CD}2?-ORok79M3=B{L8{uBg zSHe^Y)KKZ8#8HV*;;EM3n235L%3vbIo}F{pID3F+-d(7HO&*R38>XB+;DQQCu1-`SV*5ygK$JfCWgls=iN?Z44e ziWC{uI($O-BTzVVNEPlEMN0c&PyKm|_DSnJAS+weAEAluDdFl>CV=rCM&T3t*mYz% z%Vbr@T>ci61*Bf8^F>C<5ytjxcOopBF)n(#_?HI zR`YKqTl13`LK*>GQS_Kfd6kTjO=25Wh~XuJA2D-ucVWB_1Vx_POD&TVX(($A<`OWl zp>b3WwA6XN_H=cRU=_d@LZ6)V0m3obQ~S^(sAb#4PqqJ7vISnKiQfZ1cSRco2!B0d z{7wO22E%*oXatJu$cE%=&`kIoGR5!1DEdE89<`RemJLV*H-{K^~ zA7$s-mH9zdt))?M((U*LFna$6eLw3LHxw(msu1F0JKYkv6bZi9TBUu>FUzLkxpMWi zaOH!!##n$WhnfbKxeYMYO0%EoZ!Hu0E-8G0YDKbtnVv^i70FJIZm1L4pMOLSxc~Ho zlr$}uTrg3%){~kVXDXQYMHZ9gth%ro_OWxWf;gAVALrDs{Xt>8NuV`iYeDpW>2G5y zAtkY-i+Gr+1I}=uMnXHm^Ow(S!+dyPhjuX7Hy@w*f`rx@ir?Ah#$7>+i6JuyQQRxt zBUC3i?n!uX!-7+OumB#{Qnz6}Oh`1tTORS|v_bFC0)ZQK1m3L?AVcu^^jr{WRifPt z@jv+lCOPCey;WI>dOes#tnfWwcfZ0Wn$cT+HrC zlJBUe%OeUHFe+kHbo7a5Blb zH4p2-%+uQ7+D&E@peBHf=~)6$oS)@9*?(|E@Ttk`>;SiglyxJm2<=`(eEUVH*j0&< zHQTKOBr)-Rxw}A)uxPV&BtFHxP!CYL7b4woxfFMCjvuhhRF#p`wu*hTK)JSJ$tK4I z83gah;kj9MV=W*$g#vJ;k+-4=bGTU;ZrHb6z34HM`ev{R?fhz?8>d8J{H!^KA<9KvK5UMx*| zwH25 zF+6^u9#Uu%vt4!Yb@|@`HKK@4R3T^3cNAXKSJmPt!6GChjz3)7;2YY-kA;`O;$!oz zVKL6ye9{qVrdbG=+`{FL`w06sG~r{-peQwO@-FW#Mh@Ci&C)ZblwVPc7_Bd%iqGQJ9o_lO`}HRo5AgL>#zm} z5ro2$&EJ_C0{MycHwlwT#w|LsHp=U$uN6k%Cp7_FD47@N~GchMknrpl~4l?toZiMUSzmv%XA%dQ7z zmU+BdBLLQ->733@q_>?^u7#whXAt1LF`iS$MfHjKEWp^B9OPPnkBPOE3)%be<#hYLkYx?- z@u5AYbKYZ0Z|qgH+RKQx&IzIj6}b18;A3_^+?Pk-%sS|?1*;Cb!A;=4=~i?U&KaW< z%~jCoDtdV9a;}%omG=7ORZsAl&j|X|v9L&l z2;>Fg`xTNJ=W$l|xQjA;(@vrf7pR@#* zA@Df{I|xg-X>DuMS8x=z&MCy>7F^&LXIAhhHo(Rp8CUwPIr6p!(Cxq#>e3u|J@_)R zvb;ZxgaD9~hsANcYyWQ9@aSQ6FXn1fj}-(dnaGN(Appj^c52%*FtVynCIoMNb@}un zgdQKULMb4rxrdKug=C!@b${;FAWaf2`-O`rSkHI>)svs8&Gr`WpEQQjC2J-cTF6dI zQD!!u>Nk}K-pN*EslZokRy;n%mS`&905lL~gID-|pHxP%s>~M)?nAdWL`tG4SpqfP zg(mKbgVT6gwABMKG(7N&o{IQJsib5*@=zzRPfA*n_V%G-dpgUw9Vg?`T4C%twvvUp zoq$zb8cxBnEaen9sWOjU11~M2d{}e7us07zi4_N0BQRro$ok=^L`Of@p`DfhS(mEU zRWOA+zQrOhuNj|hb)!%LYtl?b_Q6itJ8`{PGgVUHh1!P|loQ0p1HIZSKTRJ~M7W8t z5UpPo%^-M(IDcz#EYxh(3gk2ElFw(QjD$Ma&$2iZ6)#GxiMqhqX}^-cf1lV#Dse&E zwQ(4=%l^U;Y&DKIV{WTR98@EM`^&v56|Vb1f1-&;lHp@p!U<90pWF9HoVZFr?R|eM|J9eTN>_-O!?!GUZ7wI@U{z=>E~cFc`0rAbuQg zR;)P%ysidx0laBC99}2=<^$9cVfxKPHhNXCtC0fIH2DhKzHp){3kZ8VuR4_l>5aF( z>bA}DbMGvF3VtGblYfLEdv83WPV|c<4f|a4It+xU=D-BXyQcL;n>F~UG)YoO@$wn$ z>VUNL(I33m7aIP%8_k_V&BmoR)*5rmciMgGIrbQ9 zf5orbWEI0|UHj4CUh_|AWM+R_cyMkoDKaK9Hx81d^2MUBTMUZ5QV0; z2KOeGR)D+qjt)IQnymM zP&NQibz*F3up!kG0^NyS-=2ian(os6Pe;#+Vy$Al(nEhW3v0vkF`K5_N zel%VhWaR$g#Whd^6DvDQ@ToicZIbKhE5NJYKe9TwKiD5(@sIpp0Li}=5}^O?z$f|U z@~GJC{0fQyrH%dN-i6TxNPG)BqiZAZm$bJ#`ILYBZz)`rK=FWGM%j3oMy|1d%` z^RGDH=&wNPtWhdnDH&8M-S64;!I9MmzQ*WX}5o~NJ&g?_hrZa&B*5)8=C*SDD{kh92ywDzv#Ng z>g43g+-d$%Kk~G{&%fI;rKNbKqxIHPFQZ$8YUj3wDSm|`&Z_Y&&dgwyEK@T1)PMWx zS`=x*Xk?z?=^SrV9H6%L@6CZ@JlyG8NpH0xU=L;YwB9zaS z^35!L2eNJ!mWbvwgVA&`@B6N5|Ae4}-1h4y8D46msDg3f1Y4uB>1jb)TT^`*UL^ES zukMVEqP=5_^&YD|W3o46l6bgJG(x8|oYS@YFS0JGE()Mh6=e$Tj?cZu!ZXa-1K`dxusFt z>v~OyjyekWdj~oj`>5ikVD&9NSkNi@BL}r}brMr~{!E@XpUq%qt(s-YNKgV#nhuHF zWcNU9!5Iya@Xz01=!w0Nz?fYX7YS2A_9h;~9{q_obeQImh(nyE+X>`Hbll%?8TF+P z4QT3G&akCV5%Q5)OC+r#wVT(DkI`rF4Dr2{8L5U0jNac$vqKd<(82pt%0#<(*nDA7 zd_o8saGP3@+N)T(A0ex^qp!f4JWbnPDddr~+dWpKrv#RC$8D;B>-7M#FQG7Z5X0Ph zdG=EE>M4Z~iVxJz<6diFG-Hv1%;aQU?Na>jhpGxQ$_hRZ;aC}E`|ERUrQsbWp%<45NopCWX z3+FVzg?cKFlp|YDMf2w>739fsb@y`iT}~neN;j8Y(drA#3q69Hl3Fy)KFn?d4%yEL zOs;c4!YzhEQ2<$~H>y?(Or zc%+I0^@a;+DV}i+%BGK8`6|I|gJA2IDZA~3pw+crQFziTa27)QB_iD(t2iYYeeU|^ zFJh1$GLzWGAP{;ZF>c&*qiGbLL!6Z>z8%FR0%D!gI&-;bak&aYL`f z6QQrBSrP7!8{tx%!vGr`&aeQ@i3lPc)24^!5>y#~ST-z8mWNDYm6^;B=zHRbN_ z)FZ1lCe)IieAEKAYzV#QI9 z)E6Y=RPN)g;dDlTmAH(>ekdN6XsrF!UZlyai0i4n5e(Xquf2P9EB(b^NY3&nBiHLB z|N1&Uh+dLE!uBmH&ck=Pu}3DXu~==DkkZ&5L`(RQ)}{XGX&k#w^)au!dXkypDhNFu zU_RHqL?akS(l-Yek+>-BmR~ZhRyk+szs@jVi{4~*@U7^bkwJMmg?`+s%_G$ObD5UZ ztpuwFIY-zC11Kog3`jULE2TG!5rtOpU>4UN#_VCj6&2sX#DM}Z9`{OmzM?ek@(!CK z8r>RiQ%=VlGL%PW;BTTMmLA%~;tB3#QSwm6iWHC|$mUix2Wn2r8C-)GlYq)Cp|=*RxGav+lFGUr zTWb-EDrcS9dVQIB4=RT@y+Zfi5Uc7}aALYXP0U0yLqKoiLfwK;+{Za`k+T~`>W&gc zT5xz`la}2l20v4V`U=7HIl_dM(sg!U`kP6!$Hqvb(4x+4*VKaTA5nVJO)1CqeC4gAH6=?Jn9BJ6h(xe;7kY>Z9493uGb6JkO^6FM{?-bgPO|c;( z=`_HH_n8!+a=|F+Q|}Fx%xO5R(f?{F9?b?W5!Z}~o{T975D@g}uet`G^4n>eopC!K z=WW?JnqZo1&!=||Rj2~5yQtOtEk1TP;A;NJxu5dDdjaC4!5fkg*0~MJ+MV8I7iyD* zS6?>>RYyh}gD4qsvutX(h_6Fv4S%Wjo|fw6hoqIN$lqn9=9Fkd1JnVdzrL~(Za+LH zcuZ$6T({(2f$3d-Y+f?-qep&$&zoXBs)RrX%tkB(ZVk!Ok?O6fEdU(pQ@+M}+hVyKT5 zLh#~Jr`>$>?_t>xZ7-3+Ag`vU^?M`_X`7a6W`|&=hQ5MUfp#Wizg=W4!eKpKk8-xF zKIyf8=T>60D|@qU^3_)dGq_WY;ji(mZDtX$AV*DNROLFuj;dDmb7nVx>uRU#NN86D5|mKvGB`^Qrd-yCaaN1E=H(Ht7(-bY zcYdYSVzuc(Mb2#y90uR*T7qMtdvmiu^ir8SPM%>7WOL!|s#xp(HMm4al_@wFUZ-hG`GG~7a*JJ=-=Qq5?=c`orH zwVsgl)$S%0?k_J<&$3}nUv6Ucj@1Tz1-4qEO%kysxz+cE7%on#V@e;T7$c?LDc?(1 zO(FFoShuC)%;nT)F>0cK9uv-G)g11hfiBhM#f2nB09vAbmlCB!DE0j!Q_<3n#H($$ zsZU`M@j3ClrEJ)0X_NlI&UzzmcZ-L`pVdzX850GxCqK(1d^gS)gt{QM4=`**|J*O4 zlHgG)*@C)N$JV_vw{!{1q#`i~jj)SRkR`}Uxlpn2+5f_u6XA;EhH!bKTX&eAz()B5 zHuWRnL_Aw3*vW+`Te#Q3@SsPyL^rAz=EPOs4d0{47yAVHq}QDJxR9J& ztZK1MlaovfgRJ#TcYj$0o4jp<`KenK{(ce@l=!VBc&1P7crp1I zg>Uidf(s=Z=Fq-4pG#k*OU&A0$^|c@qb33w>XWO2hlfosGB z7CIO&ZN2UiXa%1 z7X8CTbIw%Qxl!hp@9nu^vs)v}=G>1&GIn;$lVE8N9Hba1$X*B-*GfM2WaomoH!D>j z6$A(+6~8y+y_eLUxjXN}fvyn-qqDQ#T=Mg@0bn~F&vYn)O>MD#(76vZ`8C{NGt;Dl zw?gubEK|cwT~*M4W3!s7Ts5ejPgy6iO^#Y|jT?a4F2@xcX1fu}C}np2+9de&hDL@Y z`I1|8MG#i9z?(-%+BHh8;s+YxqSqvvHV<`44EC@9uD)JqOR92yaiQOfopz#{Heb12*G>V_L7^WNTlAAyB$SyMPNoJLm ztdz=vh<(9q+vN}O6^`#h>bDPsPqJlmszlJ>9Vk#Jo}P1bD)n z8uxLo3zpe39C64iGWBADS{@QWtwq%!Pu>Q$8)!@X{@v8DgNx1I8k=y)whBJK|DoWr zr$#V6S}YfofSwoQ?qn=4_fsyh7G$qlEYQ+ngOfTXd8@_vf$VuA_2Sh#BaNEFBiXye z_Z*}b?32%$6cVzAY~*^5%y%BK>ZV18W$ho!oMDWFbOAP!KO==Le7`qL*rnVci6t8) zGvm}cG50pKKpM`Dk@{Cjg29bERz(Pe5+^EJ5~yy`M4r}js5_`i`Eg2j`LEfzbu#SV zn>rnzA?c>p@G}#*EE}3~h+Jf1@4vEVTk4D>FT_~7(yX*p z=y@oEaWHk0JvSd6*Yy0VXslT0y$wKuleaEDllq<0A^Rh7>fUSvk1IUG81s7%aSZ5; zU*{SO!eo}b{@FTmG?5TZ3e)=W-JENtxdDj=#yy|Qr6*5Ov75(%mxl*Xw(~`(TYtr2 zex9@Y{7izZb*`5V-_xJLSO*_{x#TCSNPrZ{e80HV`SE&qdRmUun*@?d$|XQ_MO|wh zHlZirCEmIGbCzz3{oOVR>s94HfJ|&%z#WzSq~9cB$a~%x^c9GQMYC?-(+qM#BQeiV zJA;deo?daj>ur5kOGmpdp^?JIhs{pSBL7N^Bu7hqOGhjiXdo(W{*XyDf9Gh)CNWiW zodeD6y22WZt1;otk1b&tPd5u?!@ zqcpad5=26^$@ zq&<>XQxzaq_IIes7@dJWxKzbWnOE5!Xvi0Xgvn_BhIIsZIi#fVE?<_%T@!8Gx>}{9 zBE*9wfBs1`fm?Et7H=o|O+vih&e_uh9U1h34Q;8%b4u;Exq~3%Yk+jkV(=w~ zjXbHjFy8kJr83!}^>suiJ`uDCwpj39?wk-haM#XJ zh<8TM%SGh3B7TuDd&e&+_ln_%+f7;W9t8oJ3F;z=%1;z4eGyqtBzjcV^FI z%G82IXL#b}X&u{rGEkr^n*Out&%}0tguIh{E1&i=@4V2_J*O;T24O5@n=%wc0O*Js zfCaKOS8%0{EwV_ab45zzmV#yrF$a^Lr8epcxJQ8^XNAxvK02+X#Mw9CjK;qkSY+Ea zO;I$RPu+YNDiunu4bPDxg118V?P2DjVrgC!L@$TZ6IX{F0|k}S+32ILSN&s@GgZv>f%?N3}kUH2CA(N5gpxyHPZOTPXJ=RoQ-h zQ0Jthl`*2Mb!v-r5rfveF;rl_bCm841S2Ydr#`ZHICX$&Eo*L8hN-}l7zDf+#b0kP zDOtD{(!t^-OmjkNu|24RB{>qzncjTOZfH2-?zT1A(SuZ1um$U3wsGc7C2s6R1JdjV zM8r^vi`NdX^JmzFNcXu4l_Uc-))() zp&T?dEuy0PGF;&``Z(FE*Tmq9lN2tqO!8E>*)sg2NrjykhC)|y`o8=RqB(xbdx$ZL z9UdxjqBTS@gE!fh;2FpQZmbJgOhu~$m})BR!nF!Py^(ClOwu9^d8oONx`cI#Ki3s4 z4LZo7XJ0?jGWbPNLWB!Lf@N6`J24oF%oESY$zT<~*W%Jf3YixQNF&Jy7mQ*E!5{i= zcEMcUV_sm$ul{5g@%+pSO=0_t6j{rin$tr%~7GZgt}Q8)m$MQj#N`&fy5#_^gmV09Q4oWAT7n ziN(72VJ1H3@OxL3zkjyYuk2*RoZQjvIN zOo9xaa95HBSPxvpN?sSCUSxK-(1eR;SaDN9$>L^qyUGh%deBd9qBqHuVR=zIo;n}L z`VOMt#W8z$-l|&`{s=Vt{ME*RA=lAO9%mp!M$-W%j3t{h`270nS<>Hf32MK7@-tRH z*^}wt>6SV$-f}6`E3g$)A~WMdEa{@wi@znEc|^!nRk`&XU$CB6{$$9r|tc0gRQ&ZBb@YU$HNX0W5b9E z0(Rj1ZPeyj@a_NT2zfM1ypQhvTIOTM&)TdGtg0s~TN|n^c6T@bg zhFqA*Z3oQ1U@Ybl^_&XG9Gy@^>JrJp9bQ-mapM?;If#}O%tdc?GCn#xV;5Oev~A(k1i@nDS(yD)dzDE2*_9B6zxgEvJH7$t)^Q( zfnn6CB*;&6^7=QZrCESd)8)Uy=gtiD!S=nt-r|ODe2nMpACy$&l0_f}@j?m7VFKgp zL0(dyNhIXxQK)0<<}f5lCK>TEo#9=Ln-_rd$mW)CTq zs&;y71HqW0Gmxa5nQm<=FVQ^av2shUkeva*e2oh{@)FfX#kR*Q5xxMu>x7|zt;D#f z-=GkQyDyrjbu(gFf&es^1BclX!LYUpkd<=B!`}>u#9IYUhHn>`^`0a+(`0qYMc%yA zXOpPiIFhZEQH7Ck)F$lS8;jxnQWglz+er=zzg^~BwM7#_` zr!y~%Xm4%F*ywO8NJXb^)shUjnr%(w1Gbs*xF_sjgat$En(026hhC7${n z%j@c;xGVzAj=ZiUdQH*@SZ}><1EQ*Q9RfSH^pDrV6RdEx`PFSFDEJw`B^ z=P{$?`{jht&0A~ow&Gw~SA#!V4OHhlG+!+z3R5<}=O!UU4);avds`hB$2E|Tn!?Md zabvLimeCDaPOx0xT-Bzs;#2o_J3zul zgScdUv-j)9*TO&9nj9#<-XLURq2P(b$yeY*{ahy}^%wg4huCqn@`K%xomg656C#xj za5YxgyIn`TP}^npbgKMGnP7A8?aOoGcLLgl!cOf#fB!Tq9hXqKt{IJaDWYSEraIGJ zTgyYo1T8-LA?9sMQ7u{;x^DnB?2Luk+ux(tn@4!Yl zJT6GywZ9f4F)-Gb2X5ro9VPzV8?rCIu>ZB1YHD{DHu7iu!*<5b9c7sO2{&>Aqpq{v zq(PE5+^>iu{m6g}JK*fRqFQH)@Z%6@_#Gf+WmuwdMS+v`X6JNcma21Qn-`kvY}_mf ze=jItT&}BPt@_aPFp}o#a^74a)3@e=dzk#E`VS}$%BD>o=&SPTkEJ!XCR))&&(oaY zs!49xW@L*M8C+P3RwPA7b|8sE5F(!LIz$&sVV`V0dIP3yBRv9iJXDHsk6=*g=l9Kq z$Q_5Lk6u#VR(tyQTUW^oalYk|y3jVEm|KnkzKKcZ+2FHjXiH2gupfSbs!&%zW5GY& zFclSaQ2HP?RUF6$>9AH?>mY2D789hE)n9dlcY**kIHcfk8r}}=qnip{L1QP zy~HRsF5{qza41sx(%bk*Z&i8`LSRkHqYdG=o1bO|F782)Ibj~~W&`ZW9h!lr$s6JT zkAiA^{<&+h1}K(cj^FK?o>ppo|784l_A0$p;PY8i;Xqo~g3q|}V2=s33G5xo>3(rW6#t{7O-?Nbi~r@g#CJ6QrkTY$Un zJ0&6rLwG$yBXT}$W~juha_%6wkVWdHrl=mA-?@#OMpJDvp>GiFLL8UCLirt_z*F+I zVY2OB>#BNLmOb&0)NUwigNI^P>tAQ&M|dg$(3F~YiycbL(x|l*DbrS2q{1g2>l>cY8f>)&(qDZF%mGDznvUbej5IbmIN>(N#lu{rpGZs1(~ ztnu+Ui1Ys|lPy3`hT?EnH7NbSG@YcB>(PMaMVtmx!YI%Hz_}9DJ{GA}MEX;6xV>&b z#aOkJ0(xI9bSQy5ZdP|hrdHCW?4}jgXMB9!%B@2H1Ccwx22&Q_Imb3NraQ^7YEQ%L z{-X_w7>8r`6&I6XY>u_l4g9_>>sbr#k0*V#{KNt+97FF3StNphPc@$YrJGI+!9TVF z&ItHBlA!Bxc_bvlOiPeo1tifu5|u!dE+7Ab48NCT*kwrY``kG)OIq)}1G{ly1PilO zX0GLm;V&*SUiu{ltY#yyS{vVkw|#73z&$qDyZC4GiWkHpDLWA@9u7$dYM2UCCcSaJO6VmV0f@Vcb-#Tst>mRrqu-#vzGy0Jelij%e*?2h4C zXF!-)u!w8t$1Ale`o+;IqrQ#&h9SYWcea9&g70RcHs;ujvirE=Qgr%U2-sWy{C)?F!v(s-bKHp+Wq36^h zg(6Mumz27;g`f5bu$9w7iy~-44*|V9lbxeQB=md=OzrWz%kyONhR_YC9k|l<`SZNW>o_iq_$P7WuW_g@kM#Ak z+N+h_?(}C@gbSGcx-yny^V-5K8!$SX{gqQ zE(oDICgmzb5?}VyJ{r!uK7c=9ZilCj2CPCW~Y$+I7vAW#>^+iP3z>{SkAAU)~1vkf* z1Fy)J!*3W6y7wGB@py`>!D$bbn}HmH@h!A&Yv^NHTsi`z`6Iq{vPsAb$CR&RGt9P7`Ijq3Sz2L4Bhv>Ll|#yPTSwT5V;U9bJX=g%qIs@+^?`a+5Cn>ybDCUU0;3$+GseMj z1H~iazjauU^LrzJa(@W#4vUN@TREc+JorO%;E-5EEKj*N=5eWk5GSI!j5;qNDnD4& zj4Nkla8)Wk)RSNC%bPDYRL-CZpEv6mfR_uFcCBWcs?;ZB;6Ppj zLC1hPQ%f4IdLtlG!YHP9pb^{&Oof_}DP#&S`+)$rvw^Uf6G>cUC47(hX8sNFrLHR| zo(EN2uiHpR<228^$W#FQGb76V^!|zF5-ZAIN2RwKB<6RhLpCjumu9o{9BrLN(H;Z0 z$uhWGbRQ;GJpOZrL{Pj4lR&=_`hQ((bvbn)Egff7$sCr_s~VoH1H>nY=Hby?K5)_FvZ7YZ;LJWIsi8O zejaz603b0c?>6(A!wxZfa{XJSTVBh}*%d<7K=_PqR(rrpEl{CT?}>jO#QFWEyt`Oa zuq~-s773nKX2AqshfJ2MR-oHgDk5jHgt7CF~rbG}+9Mxh~%?4*89~R_k}J zI4nRevCjEB1hu!W%1_;Af{q3_-l}Nh6ll(RaY=YTNGPs)?reBJhoF3&Hklx4vpme_ zE7PPjXGZ4d1bogB1mw|8Pu3muYT`&iFCq*HfThfQ-032h za^*OLeM$O$XT4CkCLc~orr*W}Ig5>w*vy3Xh2Q9NJiDuaT-|}n5sqNaT{5nKPAk7d zn=ERGfOHc)L51UigO^jx+C&CY7y=R;GEfGGd7VPt&Z43uhCeH5Rpt@LOzAAF5}&Kx zOQiwRQ5~F1;&diT$fRaGFK4Y~EQz`=L=vN^oFJqIii&{0sJturqZJMIUdem?gtR>3 z#NfSb{Dc#$S|?`J(K%Ho5pAY*B%j<@g=Vea**Ah|Jl1K2J}5ZXh}K~eeu1#z=i;Y< z<^x2YF#kpHIMgA6^XqI2P(^MC4f8B9Q!P$5Ce*oSFo54OIy{^ za2bgie~@LSstAMdIs}3YgkqYsqj-bAO#&vogGl#9VXd z^Hc|x(ng(NZQN56c_7hx5yix}uE=@g*Oi8isck0kMu8un<6MK>XQWSe&06VfNGe>j z{VZTu{M2j&?w^SF)>nts>`fNEmB3liH|WL>TyV7#1c`jw)co!`D2b;$?&O{bK(2E@fFAS_HJ01X+lJw+~GwMh%~C2S{}koS3c&wMa3dr~(JP z*EYO=#QLI3nc;v#eqB-5?A(v_O0W{v6BHfkaum;X%~EhXns82?*j)Tq0W1x|9RA24 z);?%1d=gxH5;;PqyKnWxX2&otcpMht5WViCb@&6;P1oST)GPJxE5(0N_fAc^a8Z+B zowAKnPub=v+qP}nwr$(CZQHhObKZ%Gn2YZ3qHlZugdNLkWu}~z9_#m;!rtB;IHqD+ zAAUH7Ue74!pa^2O)M7*-e9gMS^QlqC1fxv8Bmlj_RSWOp6v({-!;=_!))X!jg)LXw z9b|vliCoqq1$)ToI@{TazlYG{^fdg;0s}K?aKFki5Q2EpG;H)I(L-j*n+&DhowZ=U zf)6eeGw^96a_Prh>jbJnzpp}B7lPWP;r)@tkjuhWCS*(JZdr_AY!=FnvD}lZ++!u7 zvzc6ERT_)@nBd%12Y3s1kpUj|y{lU0qlkohv;%ixo%0>t+VK)gD4JhMq#)?9?{IE| z5>$%t)iufOgD!d8qT!o7pQwlqcG=_xUt*-cL>rq3DlhU5bU%1k+wNL)GF+92G5(dx z5uJaXRKfm_7YfjS9l{P6n&{Q`n?`jA0e~dl2w_?d3nM}~qsXpVKm7_R4is)B>o8$4 zBdg2@!TvZNotFSei@5==b<4EZE&ARWMvzaFT-@`pt z(NV^v6s9XAPtdml3>8)Lg~0qoVz%QNzhfd|bX29!dd(bT{d-bx$G55J*7ncT7T4t+T?JX)2A{(D$Yd9%*Z5pp{$ zbBAsiM&O^ z#@^o$tZh$@z1j&VpUR2SX7^wAF$Iu0qYStXz;biNNpDF(&DDM^wsnR(uo$!tvKC^- z>Kifi4h5@&k98y+B;r-{9vt?b;>t&F@w-L!&C==o<+_!;U;S#$ypj(MDjyz!ToT87 zN1~`SYnh8;EO?a>g&q<$V{CPW_}vif8jNKiNnCJ|4a8*=w-#1K-RS+Jj(c0Z3C9nc z8za|>2*5Q&>r)*&XN43aipRIS74~2DtPe6K_h<5tdCmp2EQ@tPQSeY4Mjl|lFrW4k zE}XOEhSot;E)>AHpJ~BX{ADsp{C^oQ>E=AXj9R`1*i{f*a#M`!-|#2QvIr8qZeRxi z&S|zRSTjT{+)@|ys^;*mDn&Xx#2~YcIjsVTb0*QQ;V~Kg&YLdK=6D&zb&}*ZMJ))dR#XH){)A4wW%G%PlV*K{@;H`nQSCav;rx1I;GOcDr80zwtCNqVhYxr{ zBB35pUuT>bkt;aE13`DKkf|BZvoDXj%Su08qIDgWe@EzrQfXZMqOO&Oaj_) ziACfl0oS?Nv9=IoH_98b;vP5OZS{2op5I|yO7?0O#6PxpV6w8* zJDBZ~TSThmfLuU>qM4srm}Y|l>71s5-YgIf^wT>8`Nd|-V{^VIXf~xK-|-15o3AnI zPex-`5W{n&hcv1UqcTBG{{xUN_rlZ&e)mNSZlkxld5WyH|u){paH0`w-^Av!w&${&# ztZ+-d@7PTg3J?07yab0R%-2mt?Cw*oy}A^6D{`iQ+w`#9>P(lfjB#C5R6L0O;bcy3 zMucH#ltYHx(vGOS8_Z$@M+m_I+^^tmRD5$yV0*nGFTYZ#4dH#x`x_LGUTZ6aJ!><~ z^{!N78=5-7roi-P6B%W&f6&gj@3ygUz`;Vqq)*HI0|~!>*=O~QG?~>J0Y@$13vd^3eNKy!UzLn0rlN7!)w|ZtP*IW;6T#IZ}rk-S^kxMr)I+ zOkT;gfcoXK_3^RXAYX8)G1KWUi|L}98!28oDl5^G+Jt50Hxm9qr?wS6fCd1#zcBy! z8%H=nLZ0pFZ!`1NJA%w0qBGb@%piuM6J}iS1uX51lDs2hf=#Rktvw z=(6Z$U|k!D5|jNV>4W^uto7R;+7K4GV{Z^lq#Vi*d1s9YPt4xf-i|PZy>O?g+HNjT zs-Y>@GaC`+$C1-IAjH1fpi^}J3)EvmLZf3d8`=#sn6)JnGIyAco0!tm`aDDngZ!N0 z6eJ0Qr}1Ktgv}dA`f&0KkbY%sH!U1er@3-YQ4&~l^qma?dDss{`4d&!I|E@O7Cm(Q z?k0Q7ae1SJcr<6A0m}+TjdUVp6-}%4E)N_6mrp@nq|oePX_Hj|Ce5N(`FvWzgKIs{ zNWFZ$t6s*b-qg0>-Nnh4d~M=VaLZrZt;294mdJG3LZ+;m3F;gKFVecL{qWqBj1weR zsTt8c>$@x_cA7uqRu=j19v#6TbHn4tUQ25&zn=3k|4B%ylUHnkL=8#<)=(0Wjgz{Q z%N35aaT$`Q&P(6Y1NOXWs*x^&M$GFubS_>r_5DSsi2El67!-1g-Q46%1?tB^KmJ{B z7qR%NRl4U1{)JxLsdShB#K?ipX_x#WHmqN$)+0l`FO}|qsidn6Z2HV3zD}`cdM075 zhiOSrybg~qF1z=F#4VSgwY%Uium2i?eJA{~DGXxK#r=XQh>AiU4s$em`;QU#a5FWS zeH-93c6U@|>`R%wU+Ls=1chRXf<^Tvg*X8!O#k)!NNR1s>MHf+zwZfXXp{s#^f|uF ze&8wbhGMpV>bH9=tX8Ve&-J?tX>0KMQYieL|4q&-0~&!C_avT8DRn+L=Nawk`0`QA zlz*l>6*EKx935h+b^ntXT6R|LlmO+%@fEmO!1xAQaLg&J1jb|h3pcZu!W2+WO;HeU zn$jv_WIb<@<~(KAyoojex3lW$vVXW@2_qU@*GcYRw@m{o$)#yze1o!eRa=}S!vX#9 z4CNY}d`S|ZH-udAyijKV{!+iXdqldUM>X6<#~f&BJT)*tTeDdknSd2D7BO@zt2_Y% zjU}f7^XK4AB8G|J<%Q{cmu$9Xd*JOm8t)Cmt#}555xo%408Mw=ols&}oh4z!Q=bW|8 z`-6X&lnNES=d(~|Uha?@th4S^d<~>qm+f)oW|PX{FpIU)ard(CSeQcjeqs5wfr_YY z2jkgor~}?ur@slI_wdfnE<|r((2)BB!~D9bj(??I|G{2$3(xjgJ?ZjZG!l)X1oLhz zoXrCGm8gfWOoZn*kd78`PkVnVT|0g|Sfm3)_l3eHaVF+N>?()$i9Y%rix!@utDLlT z9cmk(gSEGw%Fa}jRN2CLeV!%Kr$EMKDrP*$MaNGf>%Uss@S{ZO)E=96PjyA7EB+XH zijOk1ZZGL9rOQpct}pNF>rvHgH+T}c);G6%)klcgn+VGpRERT`S@L5WNZc^&_RC!I z`bcSt;4w|iU`J7D(Y3(DjR}%oGq_)o;J@ZzbOKC+f<_jT|I*I`&=9eB!NPK9U3Oe4 zZ&0p6);sPb1hJxd_$vjqaB!Ejl2^6~8qb3`>*0k2LPxJt`c(rD-eNX-6}+louB!8U z1PxBrg$ip!{!{v71B?!=OE{tgYjoCMiY{2TjlsM|&sZ!aIv35tIwp$y?r$d@$kxrX z6WA<3orGyU&dhXgbx_0w-`3GU@I^1C-X3`{Y81r27stxiGR*1O@tLMVm;4Eb<6> zDRa3z;O88Jddu{@sUu~P!MVfkWXul#&@g)SRpE0juN;UP1vktMKTQ3GUd!@~&at_KF^CKCrPKxN9^}T}MtvCH!q<|j%$fiM=q737 z`V`V7`9EkxuMx2tK=Cc3*6JlS-AJiiAy2Htz_uSrPb6BKX_SmyH!#8|O}P zNQC2exxe=CjO%~p6T{Iy<0?kWiO`*QGd6;lXuPI^9XDDmy-0H*t*@?T`kX}dB5RQq zAxXo{{}O+j@Ad^K5#o=eYZaVlRVA`nsF*aZ2=7raT3Oi`LtrZ{33hyT>oW!io`^;z zqI)+HPuBm@6L0V8xqw3A{lAZNHCKF5xAY%+s2C$X3$-8g?H%l*?jL!aXm z!ej<z+xN36DFOlVd>|f3~yYOxTPdyl1ed1U9KK*SC{Ey{!ltrri1Pq#= ze%eh^L?AUOQQH~~-;Ou`v?+hZWznQusVi5`Twrw7Ink+sxG>W=4M)jM- zdjvlOw12YNDv(6L9@=~LQtGi9Tv}16m(quk>TG0*U*ucJ9N8ES%Z^kNN%7vZYGdF2 z|F%gueI`*)DOxj#XyeFmtGlL?3X8rNDL-;LXy#r)qU=tp`pSYht6@VPVYk5R@rNJBgw zWU>_KB6C67H-pU9_kOh^Nz2A>zQ~6VUP0fBX^6ZaQaEb83^T0)kXDD9u7Vs{enXCP z$PIAsYB~re?bNYf{u)e|JHi$Dr%^hb$GcdS0bRBwiP)Suf<2`2ZRcplbVX`O^WC+; zWZuO7eLSF9t2Yj{^MpQI>)mX=frx&~6dGC;;r%Spk`p;;r+h!coVqal?FXwAwOnvf+<5 z{(KQ2+&OHyY)4)bbV|%#y;PZ}(My8e^4qlU3=VcpXgG1xb-h112g3~;z{GkOU5-1( z?_NpkkSH7?(c4rfL>Zy{M?S|qnt-8WhSl^0X8#QBo1MSWT0a;=+D*N@lj0^?2MOO_ zns%?rP)=kBk0z%&KkdX$`#5PH)N%uX2#p<#rTAjL^oW59tN=ValVfl_B40@CqgaP? z-j&7FHKOPYXIS)PxUHO(%23_Bgr6HK7)*YO==QtGw(^vr1>MydsH8$UQk5+D^$K+@ zK$b4(e7hYV9L?8BZv0LSJxNI}aHgFm<__Y1@=Ih&^c-0kcA-=z0ZqE~v`R8_I+TB) zX57U|ymnbeEb%qegm@dg6UslA9At+8wOuScF-2)F5UmUSc!OmT^lGrf&6K=AaKCJN z2O}iXn}N}L+>==qVf!{W<@P=(H#jY-JI3ivx-~ijt))QaMPw1XP$1{2?8tPKWY*gZ#hLHGx3M++U;QU=`mnopk- zWE+}b%~b(_b&Z)c4ct;y`4ZKgc+*4U|HU07Ju(;7^Tbl}r?hSV@jxhPPkuXDBXtJ` z>IL=)x&Kk43~OKL9T5w++~za4`@BNbU)e+d8c}&eC0cIz^v23ZfMQ+DrMfl|L&03RCw`bmd=Yb;nebb2!5M&myp?8g@pGjOf8^-lfk) zH!OEc%RKBG)g}d%qDFK3S(Zm;H=ca-vk5QooZ%DM=CGFj;*&|2OZlK05A8(yMHuPT zbBBVxj^bNwfnNiQ@wB2Iev?8crP+Ri&Eu~wP#~$-dK2xdv0RpBSt{yHNo*yZnwKOg z35DuKIRxNURAza2e3b7+7|{}(JDk?FM4qvTbE_QFt@;S}Y8U4PITHOBs$-p5E^5?y=8kK1v2O23!?H{#S7V~W@yeB*0 z-B4*VRVqI|p{Si=?EAYz%oPq==W-Dwyt=tD(|=XT@VGGo5yjWCAD{ja{unVFy9;iN@hR@!$as?9U`zYemPB57J>nvPM zWhL9_GB$0#`}u@qYYJw_Ro{oyG<$U%dWVT`j7DswkZ0?CPG*0U1d3qjUUKs>8}c#S z+_Zv8Dng@PnLMY={ZtweJuEX_|9#ZwAG1Y=Hr2ZQrgGpKaYN%BfzKizA6jcc=}jrm+{(b0`Y-HX24FPkG-a!hD?o!+ ztryX?O1Zbzra44DySz;1vp}M8Kn}C+Qo>TcKSjVCk{s5&JIHeSFgEIa-0vQFhT<&?Mge)b{|*)Wu2?XkPi>= z>{U+D@t#T@t3f~yTWA)BoB;?e3J1vMpJm6C-rzx#Yq%mz1s7<5sR1@iH`Ji4VRQh2 zD-~NJI~lwtIW5?tPb?az8$+7EbYYd4C{#gF*=pZ@F(~RFOku4bNM%rzc0J$E|pJRZ8*0jAJxTUYLX@ z4;(jadK}jk+CZ$I2(up`e=4;uB3*v#2)HeLJYNG;XIwv*)e=tk?1U&yAMnSDf~R3L zf@eNS0};sy+T~r7^3zHY@WeZyL7}hE)%b2bN}y`{r|ZX1z%wIGh%fyya+m=~>4Yl) zBn%bz?>MDhY(2Sz7X)nfxUC>JF$#)EOJ8E_@woYOqL$_fW_Rxmie=;5X$6ZE|VGBe_K+}>5B0b7qbdt}KnWIc?mdO-} ztTI!hDDu3D<*JeqpZ;$spHU=?SYI|e_^&dRe}J4mz8cezZ;|>wUIyRph0XPKe2{Ec zOhc4uWU%gxHN2tehe%*$!AMF@-B)dg7I(!BAsl^gG>s#OD6Q|u%mXFtewU0E4%pHs zlt>n8@HJxpY7WBXHaYcz3sLtfx|bRN`Ovo-z9O76*C~6ukYgzOgrnL}$ob>N$i9*A zNqC>IPDAV^Z#|%^rs*gblR=)O<;I>;LhHhb;%}P#t7|#aCX)N=s8{wzsRj*f{TTs^ z(KCDp@o4Khor?GwyBFR6u8}ar3plOSF&Tgs5*1hF89u3MAP?fk(k0}{a^k&!11g}wQL=Ra;bL$Ijiucs3N(3FoFC(>7mt%LC784pSC4K%ZL7des5?FBU3 zq2lM#mFTxBc5I)~gpKv>$gI5v^F$jb6TzIzWdqqM<_+s1bAYmFEBhZf@`ma==EGw( z!P4zj)epJ8Qe}6xAuiFsWZ^de1(~vv6=`>-DjI{Xy4IMuP|dVeqE3+XLoLAkT8B^f zIR6Z`s$q>Qcb%Vv!koU!8dzIhHC}MQ)_@e-6;CV?pv$3$Na?AoCrI2h=eBmRY{SAS&O6rgM2$ptDVOGl8)UZ zo$cRLNuc(SQxt2O&E}PB1@0yM65?@W_EfJESa$ms9hUv;%h43a#?2_S+=L)z=6Dl) z;I7ELPTbsd6E}C}&Wh8xG0MKpz2nwu8qP7W9+W z&&IRO7KNjz%q}h|fMMA&G6xa)yF7JUbN5($H;t%wEZqad_gqzSMJwf%!+bL5ky{9~ z=d1vT0!GMgQFQ?+gQ@-H;43A@{>2Ao#M5e4xi$h+7MO2s6Yn5Xl`yr4WQAgf7iUTU zryIbv%gZ}ww1KwRjW!vKDAnpVDg=ur3|1knI9j+X`?SUi7~#|~@v_cw``{U4*Kj(g zKUD~e8Rvf@t7Qoxx*S-VjAwgSE1n8P^Qy5Je^o^;*fjh_&2A@KElYI7!q`vbX8f=& zh4ZZCyjm`WINJ#1?+BUqAM<(1xx!D84bq9y48Wdv=Pe4sk048P9t)nJ=V|(Va;fgN zGp^v3=z{?Xd~suZOH32)0Bg;HA(2XUopQT)M(9AMxtvFv+^_V|zpyQZP6v`~1(sg= zAh(7XZf%JnnNczXO$r-Kj~woA7j8E|>l>HGfuk{gtw0eu7~;qQOd+gl zfrBt1@Mh~E9;cYADHSo|pV_bpJ0{}wtn#?hKcT&_bD=c=L9+C2y8TnCm*1PGfFL^c z_uq~Yb}YVPv<-R_1g%aq#DDFV<3f><@v`rH;UtRtIje0EPETSA>ekA7LeaL7-+-!K zQ3o`WQY=VMX9iD$uU}p3i2JC%??cqC7`Sn((>O#Bd}dvM@0v^PML*(|1*oZP)EHrJ za_~69?u$S?)I8N?Gx(2>GTQ{ux7((T=wWbGAhnNEDnaHS&bHMONvUy^kfGWZ1e;Wc zS)hOV`*bAcMKtfhLZ?kl2bVX0R09?fc&w#gfI6C2!<8bN=T)}b7AD}#l{2|ITIGf& z0$84|-R8+bU0e0!>YR^xa0$(|pK~$x?oFn}-eBOQ^P1CyG*=JMfsrg;`@kPgvdS2S zb7oRvitvokXDlo5=-}neC-W3T3Ex{%<^rUIhcQ@1fhVGl-PsVVF}z~rGBK^%)GvrL zgi!QneV2RBB*dB=LhQd`+B0pl;quJAc27Y0v02sw;mzkX^umP z8af-=!2h0EWu4>j)F3|vC^_?dVu~W2iGHI(2qVf-+V??U(JGA5g zYRcxiGLj2NL`U=Y#q>ye=tmo}4q3#5nsOd%^ge{DfpsWp`I}xqaw!TXy{cNu2!HL2 z^a5#&TDmow@Nc)PlyrAsK6ScdiOqBIGtQUm2kRH4$mQcFyWJ`Upi(qbI^{|dhT2xu zj40VB0AT1O#3%TdbC4Q>8|cqcZygC)>b`HV=<`VQ5=<2}o)tK3{-$oxj*`)ZFF)r+$M5vxV%H@cucs9{kd zLVR(=>Awh>7jt6W`xeq>-`8uQ6k@O0@@hg(cJ1JE z^zCriz`|z63pbNf3Hp7PV4dp7D{c11li`GgyHs|h1<5m9#XR=bsRR9f34 z@e0I){$FpzaUKrhG?i$iUJ)1EYn*|%lIc zAq;G>Sr<1422B7xud8Of4HA)sq@z8gXT0KU<^)E;GUOW6uLu(OVyuXd$71%q@8C;X ztf2n<@2r9QOU2xd>4vz-Z0x1;{JjaW@FO|xK`|ldepBfS8m#C*1Qa+*0{!uA-99zr zU%C-@(HkjEy0o=T%LZ`Wh@V=8bVV6r=_6Szu#6*l8Z*BJ+w%)+)BLg#mE9^C3SCD- zbgjVq9U80VZ+ct)=V_M+^Nfg?-@&B&{Lf+Q9)I@|iW>ZO6?Yv|0*_V{;VStzhzC8k zorqypB7Kpo$xjE+Edy@tU4J9)8@8kdo;3g#)+slxC0W3azCGQO_id|yv?;Md5l@4k zjcZ(`S>zw{4^0CCl6q_nqT2OZiu(T~V$XA~!ts`jVg;fF5noB4pSBJYrDdC1mnfn>MRv?OnQjt@Hd7kdCG;U zHDXAU+DhKsCZZJzXCMUhi;2AyofTR>wwBpO@2EE2(zMKjuu+q34s%Eo;;NEuh@e4Vyv zVftUH)4K`E;|-;AdZWM7KIqAaNzmChj82@(aQf*gD$=h`7JVpdoyHE>(g&h&G+cFn z{1BX8NugQ>{jSZPY6Ow{8T`2vYodJW#Y(Dyvy*1(xF=|1+~%nDV%&+xaRPg1F-nr) zPvE!y$}qAG1w8w^Q>!S{Ar$%~x;2y8Y*h9sxMm<2y}{6ssR;&5(YvKk=}1?Qd~vIS zZkOH=oLSlls~=i&M{`tU9b9^bw+z+$USwJ@uPH-etp|VWPhixd33@^w-PHb=nd$*j z2Wc!-4ItPr!%~cNFl?y{e@{6e3OWn{r}Bg6m;`n-R1tq1E&G4Wl1@7iIp;pro}?md z8P|M?AiF_%K%aJ?f7DTFftRkJ*VjGa0PVH%S!%YHvldOChznO3npHF_>vlYcGRxrc zdQgmGUzp==RPbLH2J2rnUCMsAaP1#Ix=X^nHm+E7sZYJz(h;gUpveT7RuPj-Ln; zq-(_juA;@?dS~Ad2*yp?QbP_PipSuo1K$GT0i@I z{a=lMxPzxA(V9c^n-V-f8ygQ>D-fO$V5aAl{6P>WVZpe7{+ArrpSG017*|c}5j%R7 zxQtKgtfgl$@M`7EBDq==FXOdFAD1>7I3*Gc;Zb-{P&RR*9B<&=`S0SBK5+3Ovwu&v z4M=(eo1pB9hK>tf8|W8P=7d15$t<_;H&Q|BVHKg(qluc3rhSr zQ|}@@$#u}|P<=jnsdPY4n6|gy=%d>PZsxlGQxbZcK`r0#V9%MuWa~^$XgNR8XWt&0 z5rd=#*+vm|Sg(82wQfW2sFLb2EM*Eqd~jSEZ@m`wi0YNUwtIa+gt(Ln$Hl3QTS-(e zE4e+@htiWXX3>D)fO|{f4?8oKAhMZlY;IJ@+A>7VeJf5jRL4rTNOK*SX{hH1Ox)kD zSKJvL1rJ}- zzJjkMA32EjtMvOsTzaGaXsQM*2O+Ptb2QI_%f6zIQ#xlAs}q?7kj?$SL6)L{)&jZ< z+rQZ9Cq9_Yu9^nG&H?k|Uk~06=C5HbkIWp+G%{;`k zY(EU(TT5F)4zEAGT0PDsao{$8>M+I;A~wHsTjQyr9(#VM$pL?MT;BL}ejqOu~%jafWHfF$wS zid_nUXSh@WyN@L946v!m=tZ2zcwgKLjj5#!r-W&myHItjTNU-E?peE%s;Wgx|8${s z!>D-L?t^Se7N5y;bcu7-5^kG3~xra=2zfEJF9?@32D zW6{i0y$#mLtBX#6DwH^Wdfw-U#sOT4knj;BPR@4Qb>R)k*?)e)JtQ2wkHUX@S>y+9 zxESgf$gSux2X+4g^bX5tK+OvYHX81)Uy;cBz)u2Ycoz&JZ0!Qw zDh;Wuz@*!EDl$4MC~ldc)CQc)?TH<@eFiTLBG>Wtbx>yQ6i^mg0d`a28PgiAFM)md zZ|4PqFV-#qEvHw1gx(Ko#~w1h2L%aMuhzZNaVp9#Hq9+@0J>xTX# zFqsD-K0|l$!>H!4fn(_ zM=ytG`-PUd!{~_WvpT4s{|AT8b@v({(FbIX3iS+sTaux{!*9D`@>y##TXpr7Sx964 z8{Jdfdp#wdYvp10)|)qM)|IFZh3Ip0>=*;40~2pg5D&x11NW?c-yO^X;{DvOdf{zt z3}`k^_ykEljiOJHu%Q;SEh-zsP5h9RvJ4sVMWICXv-n76GCe@#tj;^POM&uCG8cKd z!Xn9S%c%@D?=E?*+0Y29G~~kjsl)-t7?SjQ)KSx*gq;efui@k{cU>6(MZGe1${Z$a za=Rs^dznrZ$++)#09kswtId<^f(Nus7O!J=tBkxxJBa*RVtHr_0on;+FKU!19rucP ziOWk-Q8V3Odlzd>X;g;9h4@3S*VJycYvHyKt<;@Jg^n(?xlGeekT(FDKcWl94^$>8J)&kW`}C;)tkD`n5 zJ=uj}gB$jOU6&2PuB2s_(}W=$`@aNzuWe{etg=IEmNi z@XGw4bU0HKS=(lEEmKr-tlaIe#$Avy*lw&FM=_90tuz&M0>^fz8=*X))~H>d2I)XY zu<>-qvF+{i=Rmm#wNuErpddY6AO*-|wMIV?QO>qdGm{B$eU6$98Y3Ov?Wnz)UZ7T2 zWi~mFTma(IitjOY!)6$1STpK0hhUp=w7AeI3^U0y2(XqOhwhgiG_o&^naSBrqaXwb zGJ8AJK3f1cmbI2SKP~VLlT;GZyb)9&?D5@0tNYN?7v#5YBIiBPr^5;Tp*9p zAS=+4K%#-;;_rA9;^AhCV=%NK+Jdw~FmxM}$&XkAOPt{hB;0XY z!dk>3(gSxKZa?w# zp+u0KyX^x+g;qNLYEX3q-IwejG;IQ+1o(Vb6v}{^9Be>dY%l5k-9UnP$p8w&g8Yj* z9&^-x+*AaKADU5+HQX?NJ^NPCeX;-DPR$f1V1+9S!x3_6T5}6gzNhh~^z?`CC)MCF zY-axx=WCJpGv^-qO0T*|3OQRz*FU(1jip@DcrqLNu%6F)x$RiF{7P+i(1_Bwf)+e! zNBgKR43so@=RRCO3xy z$92;pC4OUsmfml_SH>r`VyItolCe$uP}Tx|o>Ah}%MFI*-9DkCSr=kulw@pTv2w8P zcH4I&24mMrt}Ea_1}4G=?3hDsh7WSmT4ZO}lGd@D7+k}L(h-l^2vyN7ZiZlkp`zqf z=rALiHL*CE7jlg9;z-<)VI9mN9trthwro*(Pa8$=R{a#=(?~5f<0q2G0?*9x1ru6C$P*0)kw!Nbs)or74Az2scnm7b}^# z@71C%@3NrlU)?)$2G=5nmI61@)?gteO{Hx7G}FuflGt1od(E**<)pVMQ`sDw{H+!n zqEs3vNuKFcbtdWrV*qYeK8EXCF!nTI4F;JA!8^;kBI(hnL%r*@b>WTY^+{$hA=TR8 z=hi8?4U*IMsRoZcvn#an+2o)8tL{yr1nUZ#>PCm4#w01uMn%Z2HHz&QT7NjbTHguUKKhJNO)&wh-pcJ?7za zz6I+J6%&KB^9B}W*@dE56;CDVx)l~><6VcvHK)6LrKl>_qu4M3LVrn8qLYVVR0q*U zvIm9w{?!Ao9M&SWSFXxn@Prl&@1EvDc;g7nFKqBwCF%MO;^a*`K;_9!L;Oa#8W}+quEAcxmG4#>?HmW0W^QUH|Wmy>gfz)0U%vCK6b|?HAj`#nr_{0u{ zZliy+bmn}=+~F8b)d=3>=GwNsx~klz87NW?8)`-6mjoV+fWdZ*$+;{0nHxByjd#s< zYr4H;uK$xq4bHhTt1k6d5kvqJG)`l36F=E+Q?l=?nH^l+Bya2JG45(RjwZuQh3WSH zn~dy2cWlC|f$~5tj&=2j|FbH_A#vG}q%b@fFg6eCT9vP0X6dCw2j7A`v1K`dfJVF@ ze8M^;*0x81;TX8oibl}&IezWj{>w}a8@=V2{bGR#mnqZ}flpKELN_Phm>jeG*W$|2 zTRqx0fxfwa#Df|Ao#N4+XY@*Nq_p+gcPTCD>XI%E!4s)mjk z>$%aMnWrwHaKLuJ{g(G>5q9V<`?;A8?Wa3h9DO2Uyl^LilL_YB?^Re7n}guY6G~p` z1eK^&)|aG)YfG|Ewtjg$GN}vT%Zm$g^(pjh`E4zrh ziUxP!Ze_fE`A`^KEdeHWDjM~vr)yc}7;pJpble}y0-45WS+}qDUG6>I!)dfPjwG8d zt9^~z2-SL zl$G(Ad@$NLgGZ$oTGWo9g$*MuLe#%TrWWjKw|{>4*C2w}$FaR0eOp-xj!&`VBNVuJ z|AD&8|B?NIL zDkH#SeJ%Ucw0ffD;$r{J3Fbf0cFBr8aAHcEjJEQIm@HFRP?6Czctw7b9l1`3W%NX* zNejvM8QPwpc0?*q#iQ0Qq{~QB?>ap01{zTjmFqE5RNQZtJGXcy5kS-|q8$Gzap1?= z;#o|vW-O8>c+x))ay>`|AzHhM$~9}KD;u*7F}f%Vx?{dI@n1oCxCpVS=Z5=y%dt8S z9%B3cAD)BqVjv3>ab=h>zU({z-0Q13~WjPzK6pf&U zZ~OaH?~&Tt6a}SGr$jl$nUgyILVafmj5G#c(bV&GQSPx68vC z2v+4(ORU%yl^5b84aHBT62rG^p9T8<=Za3s!_jE(ihyS(C7RqFkot#noDXgl8+e|O z1ZDLAjVJolj&a@^pHz6Ai+qIF;5txZuO$`;X-~IcV%$gi&J`0hTP1Mvw_-#7MN_Aj zD}LD-F+g$HVI`BXEiph;Cc6vCs}=;;V#Qe$qJS(GN(+SfbO5T{1LKw<nw zvKh>v`Y>90(JsZy#bw}*{uq~u$R;%uD|UehrDtIVA8OVUsA4E zQ(~+8@oyI`?4d0#=vEd_Yi~inYjH>g90iI^lT{t=3TG26}xe*xz$#U0tA%SxpLF()!+OasEHl`r3}zz^+47=VDUXBXOW?$#i=m zEo7p9L+YHUxjG42u-JQxfN_3Rd>X8;+oG5XJ#le%ioPjwb@3z31>*C$E0X0Df zcu4gAda-jg0gtpi$5KlYHS0q$LcW6U!w-F;{C^<_Aclvo(CLeR8icXO0jee#aon{k zO!dr;2v?f_?2}aJx7Fc`3}D1EVZy-CArxd)r|brl|ER3P5}M4I!JYR{ z=dnm45yABQgXmPU)nWi3wH_S29{!`0AZJ^?j}r=XNDZ_(sI9F?0&`i0*7BjNQHVP?KWOleGJCVr)c%`EQY>akn)&>=3~l8W`9_AQ)NBAj;$a9~dX?ujl`u z*7J|ye^cwhXJTi<|NkB|ort-Wld%Inorsmbld+Jop{k~M zz09O#t)3D$diB1-g)P+1U|&B3Ae~Vzu3SWk88%X#$amLwfc(#Ko_mO zdhC*|4v&N3cocS^d6afQbrh6FG#jRUo%ICv5OBc$kiaISgJc`$c<|R<`s!u_QFJUo z4c|5#rapBh-O1xEG`Eb`t$jWg;J%$jVPV7JJod$z+KTc#ww}rD zn%dKpc=dXNy1jj@?QU+x$)%~eZo$RPTff>v)#{@6x=y;=^nABBmf6CkL&@3TLyGw+ z-|8R0bM>?Rlbs~32*b0kdvPe&iUR-O$&HP3KI(YF_kw1W^fdZ%+F_ZS=600Dskg17 zzN#1H$kZ*NzbLyZ$tdlN0)r z$iySGnA+3ez3o%?S-Y?`|Kh-bLt{jbTdh*n0HHcR{o7?po%zFd82$L;-XOKmdDk&f z({Q?2)AU{QT{oZbh^C1?Oxa-ld@bdW+rS&OwPgQ}jZl1;3<7(={6~b1FE1mEI}V61 z;*Nq8q7EnzYK#qN39%gl)o)-}!42QpPpCr+(Si|3EHwnEB7aWBzrP)rUeH5I`we!$ zpw7@KUK|()>TkIzv7VXJd?bC=h?YpueiSf0!XRc57D|ZY1$JEMKCFci7i_9H&;?6Y z=kvXX>EnIJq;KcX1*|Gek^NX)LLpTuZZ6SFGCKJE)Trgq4lo=XZMZ>&V|J{=IeKtW z2G~B>3Hs1!h{3IOjM_&}kmN4wXtUTZt0>O-CwkClkBtFFDGw>U#l%`%^O19we{B~g z@<;ML!;MJ|mer`*ouLZ`pV&yx@*#KP*c%O6Px8lXU)Rlg^Y>3_{Sf6y^ zJ1P{`-m}R9I;dZ(tNhIcayswZ7bqGk4HPv*XG`19tEKEXVP1`(!;|4nNu+NG`|H4= z|H%>l(=o%hHL!r@;`;yP%vji&|8H}I+5d;Vw~C5$U$?w*f`{N10t9ypg$D@k7TiP7 z;O_2{puyeU-CYZJcX!vX$XaWkz5C>R=bY}{7rVPJiW;M8jCa%pznagS^Qr$!elPBd zzh~Fp=33&PvHoB)h~M3;9U}KM^Q3Nnh=vxPXboF9PqmLbXc3mJL}1E6#X0e9QmdSeW?C;3QVKy60dZOs1uf^;;iD8%UpEzauwkRRjX#*fplfT z>Z0Z((IfdQ{~rk)bSdj;HjP#ue2rwSuV7y(pq0VC0TV&x>DmCp1Y-fmf%U*8zV?8S zsa1wY$wdAx5{tku2?Mq}_WC0$`WzJlKnd)tNO&GX3ZF8fT?ieMXetRf$z=!>Vkn&x zs^9p}fdGa?S+Fe~fVYiayMjO^J%T5Rbx*U zWE?pwo6WIx>(1t}_IJs*4xuw@scCJbvJ$q%=dyH*>E9J9-Zi!^c-<_>95fA~iZ91n z?A~wHVuJqUlDIB=Su9UW9;{9Dbn;2!;FZTThB2Q+vkCCGF!A`!Q=K=v@3yOQBHjb~_lIh+!F?FxxXC(SiT%+=U-8OKe{BoPRpo+oH6@hRW*%oV z>v)kPO;OMU0wLY(@LNJsJzDvWu!)6wy@NAl`t!t+*Y)o>VEOkPurag$*Evvp5d`$c zzXZWf1VYj0%eKH;={LpvNlhZgMUn5RuaO_G_fJV2X0O0-dBal-4%!wT9W zciA`?O02imiW9xEwnjWUIxFTNl;GsTlTUC;xaH16Zd!>vteZuV2#&7J8DPucg$CPd)c^jB-a`Q2RhoPcjqiWJMtH8`QpoW z6Oy=)9&_YxUQ1}*&0R>|w;h>B&Bk5cIxOJjYI7;mseH4mPP=?+WXJySIJ^>l_TQBf&j+)_TyZQSkWyG@tAv2t~o?4sucal0R$3W#rnk#0)DV*7M5ZGpIvIJe4cr=A0oUt@>uZEh zy_DuAD{$L+M?<^Xv2`x%-Y+0U&Ge9dhu1EHN4x2f_?Vj9i&VMdK}m5 z)<+1?PlyxQP}^GGX=SZP<_ucGuZd`%tzJcYnc>}KWtt3nqP3q8$Vo#>iEs;8@N3aSQ#)<$|dgeE?VL`om-*Jq^RT1b)kkR^Xw#KjcW((BNIutvJNNdqAcbi5uh5^K=gRz!8P@+@ z%*^L26g2Vc*8h0NM}&WOJiRV#@ejy{l5uQ0q~JVzY6= zYFmWTw<_N0uU}lH$F`b`xS{V$@7c}``3>~CD#1FxQEq$!AZ?Wz z+iQH!HoY?@mlk+lz2Jr#-){ckI^JAy4{Sf^ymR3?Li)t;mL|6F1Lr*O?y2g9neN5t z(<{qg%t-!?ndXFlIx~y^v&^8mZ$#Cwp7@-<<4^SUfOU?5D}7IQ0k`eBk5hX7j=9GY zbY6RrS25q}cR_wzXs(>9u=U2%1_`UP5&`eEqg>aw zWCh0r@*(r{%&uuJqgz&Kjtj>z<`i;*Tdv)iZBcR_X(td`SUl3Iw_HYt=b50llJ2>7 z+qXqyd8Bc!9s7NN@?@^b<+GQ=3-rs6W2YZhF`9UsChLw5op+K|uSZq`O;oL2L&FzQ z3l@5~*VlPrgn;@dDE@vqj=y8(!~YS?+NZ>21R@B2*PrdeHpuRy3CP&uyV)D2EJr{=I2M15fqaK{@F7p4U zGk>Qu)K0D!FFJEQ!d>;3&fxy3Gu=Jzh#|=XD}-%eIo`ixhV9=o!_L6)-Y*6;gS3<1l@^VJZn#sPn`R9J@%vq!0pvTmJsH^jhxksmFw#GLr{bNslFCXtnL#v?OW+_PRj@NL3at)M88wTg=bM(TJB^N|C(30{FnvNJL}^4 zKewKn7X=xgExOf)$M1>YC6|L7ZSQ&BqRi7t&7ZPjic>1-*3A|M0j}JOjC$0PwTkO( z`=cfAMxA7fg0jXaKl^#iK~R7zK+U}IfL;M}XaQdVhgwPpPfa#<42CU*DJ5zJADIA) zu2RJYn`mWP0h8e-&Q|?`J;9*f;Vqmer=C_5MM)Qf!9+DYlB+}Hqu2=DN#j>BF)wmb znyO6=V+=OZK?hdL3I;1RT=sEit#oJPvp6l<3b;cG>BY|lW|Vl+RK8M`aSx}o;dq#d zS3D-TG9-l++2EJBajf4MlrqfYvpbrTjf;wN79MMo==?@h)4~+qD}&MJQJPV1ktm_Z z`j}H}MVhzDsV*VlycbWmV2KD*t)|soQ!ir7UMLmYfZLKG7C!x#{26t>L6O+t8eKC4 ztgxyh@(4q zXMeK$7DmUI?8YGxP~OJ+RJTr9--Ng57(W)te~i(D?m*(lxRhMk@#LX#A#A>SdD=A{ zE_upZ47wr2@1O?!p9D3VGY^V+j!vTJ1`kqBP1N~lxya8ONVLk$6aaz$|YrNGr~-6y@hb(WBlwI`IXMw_QDfJVX6*X7DZp9r<&+F0(d59xw#g&~*Zl9y0q z4eve==FeZBI?UKv&V`kfDT~#;85sJi*je^$BFVXQ_Fy$sBwuVg7CsehtVk0rRmKE0 zf%y?GmAEwqj0Oz0^&SZf<=qJ;64<4}fEt$vs|OM|vPU*dZsBA*SSm~mIIPDWD&r(^ zN2=c{?prRg=r#DJED6i9!tb({enLnHM1^a#@4hl7W-SSM`9njiG0H%CytM;wEdmEv zScO6JWBCjESF0MwfuXeC)1>umBs-4KfFpSgfpA8!onlE9IsxI0tCPfvlsny9Xyjdo z>pIRtaCNC*V#~dG)N*LU=raXxn@QXT;UFq$Db7e(mtOncMSwBI1u|yrOtbf$${XK| zA2t)^-%!!EjYAnX{S=9%8T{X{2ZeX0hv{NScssPQk7$TrL7-0s=}nBr>m5uEroD%p zG{xxGvXHn<*6TNSq_5p&?Lp{t`3%2+co_}jjC3w>B*{oENyb`$xZTC9e#I;UC1OI^X52xgb$1xVW=^&AXYKTrs_E z#CK5bVXRd-+Lu|@+)K^gZ2qD<;Hnlh9i=79W1^^wX@80V0F3qH{hZdQ^m4~H$!cqh zb|GIO?P*RQI5wX0JcD#bG}s6TuZkMC3bD2{3ESl`1Hh!*u>l=KZEyVY58O*Co}2of zuJx~4O3I&`hMunJ?w6-$pZUH%!$v<6+FZFa%s!_LKA{lZ^Rmo7hxS#lY z1rnf)9?tFzk4I^uI~DC@wc;^`oL;38T)`fs^E$zm9Md(snFc+B%ed}J{0?f+GUor7 zCjQGR^|jNL%iATX4nSnDE3T9|<#vYt4~A1%GQ$C0OAh4w(*hZ-%qTeJaMy}u9X~zB zmXp`#)D^Kh2RR5hr-;VBW9fwT54H|DC69|{Xb84NjwXV9XD7RY1)=pWP&^mx! z4?Pn-M%Y?ikA#C`{p+_D4#C<)U&>Sid73l5jINI7HPFw)VH&fznh4WJE{c9C)*P>& zmL9HE5@_j_MOl%?Bn;&T=si!z+cj?9ZpN$SsLy5+7GX{1D^n%u>c7gR^?379(1R9S z84TIu8V~I4#}!&!u)VyP8V4{FFgyr+Fi9jCl>%Szk4Q9-$Y7Hsy7_{Bd`KOvTnX&{p}3g*%3W$72Xz7BO`%XI2=LXqsW4#N2M``=kQOT&_y|69$ic|p zswSAg-+ElD@Q3$tpQoxo;6f#UAjaA&H2N620@7&Kb`FqSm;6u}hp}e8%QoUT*w35V zbLwAopWoGeRfMr8BIpHu5)r=^qswC@XeoN*r^|B-LzA`H^qsH#J-jf4W zu3kSZhR8cJ}KhL;( zqL$AzEyhj4umWxi(Q9$`sFAL4x8fEObU(*S=qgj=yp9Yk_=s5q$mYn5W{d(di&-#p zWn{X1DCs%yI}Z2pM4Z<|9Ztl!i7gD|lj^#~{hWLAWIQN$T2;_Cd*;Y~QW>UaQL!+c z*4#9~CpqBS*BNtPjb1|8lI}8<-$`?{Mr~n{8O_E}(qIVv444x0_NKm-Y84N26^vb; zEQH*Iy}};uMI|($%-O`=UYo)nw_UJ6q#Vj7 ziVM|IaZff~?Da!F&I6PgLHCO{n#&q4k2C1ckk)~_vcG|vh2h^r4fw$JUmm|*6(vp9 zL0#Fsk|B!k)pw!t^^!Lb|@8ghsJk?c7`fw zG+dq4rA_C}7vI-U?)4?z4UE)^-nv>N78mC?*Ws(%H`^E69s-=}<--M*3l~*1VhfBX z4}omSjeGIa;`>5V+nMc62Ms9jQ?k>*qwP-C`DGy!ZX@K#@y#8-zF7$tx#a6@CFw`6 ztcR#OQ!!ajLNmbO{gG6h8t*aWKr!t-BrYekJZesM#=>H=39M{x^$6ZinX3CO8WJZq z*yGm`)8;u9oQ3rogoE40cN^r=+pD1$OHkwfX|^5B&a%@fa2Gz8n+`6vuQO~)m2;;K zT{Mmd9=BE|E`p1fLTba4o*8zH2y)mEac~XBR&=Y94_cjFiy^jFi;`jFi0Q z8^lM@%ftLG-SxgVh;BqY-dX{`5%~aM6zF=_{4Qk8Hxdsa(lG5-m}#;655n}mH{q_z z0nZAN&luvYx4e|OVK*pJT_#;8X=@Jnt8Jt2t$iGe^EZ9c(cpwx>Ef;%QtJ@CTgZ0E z(ya-}pPH?YV<*daiG$zPZ*~V`X83d5KrX0mgZ+-#->gUct1`QNn#nF96`O%aX23iu z;<%Ke#eInob0)u6K`99BR=Zkx+`y@CRyD;_dN5bcn_4E%fMIFO(Z6`uVE5YB7_{yP zr`TXV%#?0#eS%En_-Mz`(2+lX+2&H5E$wz@^L9z(SdzgNTb1pg0n7F=?xVD_R#=Y` zETb4~u&?pr@bqQ#f;qC3WXsN7((Qwt4OM2DPN?K^{kY|LtW^jwMaZC}R)xiccA|6gwOAFhJ@d(b`0N zz!Fe|pcxAw?Lk-xY7&w}v!q+|V@3CoUo*V>cwho0jW`{i+Gg?izRlb6mNA=N!!;yt z_>BIkH}5&r6RW+!0&`4Ln*e6v6SEL+-T{n5)Q{>4WbcNsJCzmHo_^eK*k(SVmqR&uFt%$lG1d zz8~HORN*~LOT6qEiL7|?u~KpOTC$!>d6RNU-f56T$+BI@+{HGmV(_W1kU3p_%4nxY zH-*-zY>nBea?Ki%<^|Ah)z2>7&6R7+Q&nrs51?ld#}{T@20Jxt%r>g0I8AD&IL#`j zaeKkQ5p&SXG$72?0)Q)6Ys@zwcDa3TBvF+g>q>~z173wWOK z_q~y3z11oMfg9k*DE2=N09HzrMOMTa zW^x?^OOo%P#cwGuXQR>~co!_@t{0P-YE(@KmF>RG5{}GJ{tN=J5^Nq_X>bPcSNSfr z`s6RN8Q_dIusisFZ*=2KTGW|5ywm1U8Yky<F8Q`((vzPMX!v{1UMsm?I%l(uEt^h$mD ziOqmmYW7IzXw2I7P%AC$Opt+16oA9#e1cKW5HsPE-TEd3SI|T%PqtD>Ov4I{($*Jj`ULwh z+;yv>?09SX>+9e~0Q!`l1tX-;ItLBfN`M74+C>Neb71G^I)+924Co#p2@nSOeAEUxdaSiQ*o_Jv2ZYuzGN+G-!L$773m zx)ls=vD`N%p1WHSRy6Jr%cx2LczwD~>GPKFft(84$Bc z`4op+^^_e3GbNCOM~@byv05NF_dyRg)zdfth(Hjp7a&$Sif%%dif#~>3vVPY|HK#* zL^o}x!3n}C&I7-TUoyW-wmOJx5W=Tj25SZ`Os``qUNxbw@xE|-(82$Z6aP@6oZt5> z%4gf@Zb79P$A+484>-L}a&9RM zdqh>a7@=j;tiBfy8F=#OmTFVz%-f}~uQ{IML(iwZfFV;jY-S$_ zSQ={M^x3$a-#tJsFq?)wuZ!oo?HhM=AZcQ2yU;OQEIrnoxHN#^)^TNjt3}XBK|q6< zZ_BAQeQ(vm4q$yu-?!g7pC8Tp-tEWw!F6A%M{?ay@_NmyZVG|5WM6Ql{;Gu?&9dK) z%_=szz~mX;Hj3V>j;|b!Qd+z6rDDSm16;#NzH?%j{ zA;_RJI;k+GPXIrav=tKNJj*i4SfFFHCn!{{#X{3r<@O>VMe?YjYW;c)-4B>kLS5Nf zK6oo{bfuMk@Cn9Yz@65K0~7Y4{+VjfS*9%1gJ0r-){P0+TtEk`15T}ni#%z2Rx9Zo zG}fZ<={=~ga9Jfg>jLnmWL`@JX6!%Kd{A{+lWX$FmXt^QD zd18ane0AKeBI4|6i*126g#DOVj<+H!q={!<)Z@q4ILzNY5+fKQ%bUQc2@yH%*Vy}} zJ2xdOBrwwQdE|Q_RwbRI&es!CYHR`P&rE*8DqTPKEdRU$piDeT{h&biJn6DS`AnXuRu@o~4O`J6W%vN5zSr^awH6cqcd9yW}LF zq~Y^Pp1kExRT*7!0dIvJELi&Rb&?B=+0%ADwabQzZ#~i((sitqz|{xtEc67n953AK z+a84Xru&=Kou+r~q#-|noj`9>{0`dR?D_yc{MVO1L5B8acev@Cy3t?kkSG*swIGNX z=an3CLs7hO)iin{og5^p=*zAT8*^ntK|bur`OVPHP{)kY^4n_Wd1Rm&=A!ZCj#P)f z=|bT{GbfCa(&UIbaxw3-1<25{fDA3l`iSX^p-nIzx8KH-Ub-0C&$30^x0YMgtbg+M zvYoh$yl1r@a$r#1SF!$?L?_HPJp48L$Js>EKg`DUrxQqzAf0tvf}L_zLxyFsgWn>S z8X~W|FE$sJ%}q{YV@NY@_?w@tdGWKRcaN`WVvV16Kz{c0#m}DKm)Yt~x8&{vp`6;U zthkyv0%SRqixl>+nv1VDdyZBn9$x&c^k04!5#(p>L-Fh%gArm>OD4*Tl|1+7fB9M9 zePF|ty2iayZiWj64N`=p2)I1)Ym)C4@6J3&z(`W7dU(D&;!orEy1WA?$?E3-CxIma zqB2lolYY(v5!qG_k+Bv9AHvF-Mp+7zAv780Be?VZnt`KQ9Y0d`ZFp*U*)~)jL!c?BbO74h(d>-4|H};f#|i&s`~i z%NE8Heg`Z%{yBug4vz%G?j7>zMX+$DvpEM7?hhfWwwO$Q)ik;xce7rnxIY^|YzW3M z2tCs1OC*Ne`};{WrrP!)RCv&h5Aw5?fM0$# z8{}v2L4G!neH-U@$o^*4=wB3Bj&Oq^9lLt`MF3|)oKU~K{XfX;Znr$!g?;~magnR` zV$G(-N4*?vy0r>04J;5eL4D-+Q#0^`k*tALNG$W!4ea`LSleWbv}TM>#-d29E5$tAeUc=#$d&8 zh7TU;C94}9Wa5BNL(M=XmDj2)j}{MM!T`dRJxgd5m(sQmJaYmALcK$;lJ_!>KD#+# zxj~lZY)wWPue}QbJ9NKP!h@t8Lt+GBO_?S`FHETwP7fi`$_zfyGVz9ed#W{N-9i|#Pb@6|g|FWB`nJqfM)J8b!+ORa}M z`DZ*xdLR2$;>@O24#e8PuOV)7vq&ctBqgCWQ+gfPphKSY3+ufYe5qGVrj=m!n=6XE_6ZSY1p-m zt^AA6s=}KPSCF0-nsgc5fSy4Z?<|5O_Qkt`-0jPl>{7ADJc*U^OLrzyr~ExI6X$)P7vpWE^rim-VU z@WV;C0P$bK7=VgZi840CtGV5z=WbXmv6dIpP>Y{zj@CPmonGv${~va?-jK1r#GBW| zbX)6p$o^*2>0cDtw5f_M22RjqoR~BuL9&_0+2XW^MYEYRVIUs_|6sG8hj;g90(CTR z1$arIuq=&v`WEe7IfM8w5nmFhdDg$VS=SdgJAUl1U8is^405yKzufF{coAO1lc0t> z*$7&7?E2{>U&vUSah7V$wQUnUuN`d8)-N~f^rxHsY6x<(CJVLuTI!_}PFXRwP4Mc= zzuc_jlJr8=p9xffw$Xn(fr|Mffhv4SpjdyKK&9LbV#zNL9WPS+l|X_2T>=ID&rG21 z=$|_ON}y2x(*z1LWcoi!prHRROP~OEebh-OFHXWUr)%lDd7GaGKy>R?^H}NM4MW z{P@0Za&MH-|9s|7^wQNjptyK1jr-Wu{chEDyJ6tqREj%9py7(#R-MY+} z3z*bW%0nLgq(AL0QyNz9cGg1HOmIyWeweu^9k%UFNKXEe8qXzZLV{9b_&-zQyVKe~ znI$ScXfU41DAQvBrN&M_8Wt}XDc~oWFNDZGFBWt61uPx%0AAee>Be<|8|SANH|y88 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 a scale. The next iterate is +\begin{equation} +\label{eq:step} +x' \;=\; x \;+\; \bigl(1 - S(f(x)/\sigma)\bigr)\,(x_{\mathrm{far}} - x). +\end{equation} +\end{definition} + +The rule is exactly the informal statement ``step further when the outcome is +dissimilar to the expectation, and less far when it is similar''. Bisection is +the degenerate member $S\equiv\tfrac12$: a similarity function that carries no +information about $f$. + +\subsection{The two-point normalisation is false position} + +The most obvious way to make~\eqref{eq:step} scale-free is to normalise the +similarity by the two ends of the bracket, $S(a)=|f(b)|/(|f(a)|+|f(b)|)$ and +$S(b)=1-S(a)$, and to place the next iterate at the similarity-weighted average +of the ends. + +\begin{proposition} +\label{prop:falsi} +$S(a)\,a + S(b)\,b \;=\; \dfrac{a f(b) - b f(a)}{f(b)-f(a)}$. +\end{proposition} + +That is the false-position formula. The identity is elementary but decisive: a +similarity rule whose scale is taken from the bracket is not a new method, and +it inherits false position's stalling failure. In our measurements plain false +position solves $127$ of the $154$ Alefeld--Potra--Shi problems, against $153$ +for bisection. + +\subsection{The contraction law} + +Write $e_n = x_n - r$ for the error, $D = x_{\mathrm{far}} - r$, and let $c$ be +the slope of $1-S$ at the origin, $1-S(z) = c\,z + O(z^2)$. + +\begin{proposition}[Contraction law] +\label{prop:law} +For a simple root and $e_n$ small, rule~\eqref{eq:step} satisfies +\begin{equation} +\label{eq:law} +e_{n+1} \;=\; e_n\left(1 - \frac{c\,|f'(r)|\,D}{\sigma}\right) + O(e_n^2), +\qquad +\text{rate} = \left|1 - \frac{c\,|f'(r)|\,D}{\sigma}\right| . +\end{equation} +\end{proposition} + +\begin{proof}[Derivation] +$|f(x_n)| = |f'(r)|\,|e_n| + O(e_n^2)$, hence +$1-S(f(x_n)/\sigma) = c\,|f'(r)|\,|e_n|/\sigma + O(e_n^2)$, and +$x_{\mathrm{far}}-x_n = D - e_n$. Substituting into~\eqref{eq:step} and +discarding second-order terms gives~\eqref{eq:law}. +\end{proof} + +Table~\ref{tab:law-check} checks~\eqref{eq:law} against measurement on +$f(x)=x^2-2$ over $[0,2]$ with $\sigma=|f(0)|$, for which $|f'(r)|=2\sqrt2$, +$D=2-\sqrt2$ and $\sigma=2$. + +\begin{table}[h] +\centering +\caption{The contraction law against measurement. $c$ is the slope of $1-S$ at +the origin. Similarities that approach $1$ quadratically have $c=0$ and are +predicted to stagnate.} +\label{tab:law-check} +\begin{tabular}{lrrr} +\toprule +$S(z)$ & $c$ & predicted rate & measured rate\\ +\midrule +$1/(1+|z|)$ & $1$ & $0.1716$ & $0.1716$\\ +$e^{-|z|}$ & $1$ & $0.1716$ & $0.1716$\\ +$1/(1+z^2)$ & $0$ & $1.0000$ & $0.9357$\\ +$e^{-z^2}$ & $0$ & $1.0000$ & $0.9444$\\ +$1/\sqrt{1+z^2}$ & $0$ & $1.0000$ & $0.9327$\\ +$\max(0,1-|z|)$ & $1$ & $0.1716$ & $1.0000$ (saturates)\\ +\bottomrule +\end{tabular} +\end{table} + +\begin{corollary}[A chosen similarity is not enough] +\label{cor:chosen} +For fixed $S$ and fixed $\sigma$ the rate in~\eqref{eq:law} depends on +$|f'(r)|$, $D$ and $\sigma$, none of which is under the method's control. +Convergence is at best linear and occurs only when the product lands in +$(0,2)$. +\end{corollary} + +Empirically, with $\sigma$ taken as $|f|$ at the starting point, five to eight +of eight standard problems fail outright for the six similarity functions +tested. + +\begin{corollary}[Faster is not better] +\label{cor:faster} +Increasing $c$ moves the rate away from $1$ in either direction. Similarities +with unbounded slope --- $1-\sqrt{|z|}$ has $c\approx3.2\cdot10^{3}$ at the +resolution used, $1-|z|^{1/3}$ has $c\approx4.6\cdot10^{4}$ --- overshoot as +readily as flat ones stagnate, and fail on five and six of the eight problems +respectively. +\end{corollary} + +\begin{corollary}[The scale must come from the data] +\label{cor:derived} +The rate is zero exactly when $c\,|f'(r)|\,D/\sigma = 1$, i.e. +$\sigma = c\,|f'(r)|\,D$. Substituting this $\sigma$ back into~\eqref{eq:step} +with $c=1$ gives $x' - x = |f(x)|/|f'|$, the Newton step. The similarity rule +is therefore superlinear precisely when its scale is the \emph{local scale of +the value axis}, and that scale is not available a priori: it must be read off +the evaluations. +\end{corollary} + +\section{The method} + +Corollaries~\ref{cor:chosen}--\ref{cor:derived} fix every choice in the method +before any benchmark is consulted. We record them here as a prediction, and +Section~\ref{sec:grid} tests it against the full grid. + +\paragraph{Similarity: any with $c\neq0$.} The law makes the shape of $S$ +almost irrelevant and its slope at the origin decisive. We take the plainest +member, the ratio form $S(z)=\max(0,1-|z|)$. + +\paragraph{Scale: the finest data-derived one.} We set +$\sigma = |\hat f'|\cdot|x_{\mathrm{far}}-x|$ with $\hat f'$ a divided +difference of the most recent evaluations. A divided difference is a +computation, not a fitted coefficient: nothing is chosen, regressed or tuned. +The two-point difference has slope error $O(h)$ and gives the secant order +$\varphi\approx1.618$; the three-point difference --- the derivative at $x_n$ +of the parabola through the last three evaluations, +$\hat f' = f[x_{n-1},x_n] + f[x_{n-2},x_{n-1},x_n](x_n-x_{n-1})$ --- has error +$O(h^2)$ and lifts it. Measured medians are $1.584$ and $1.944$, against +$1.809$ for Brent and $2.654$ for TOMS\,748. + +\subsection{The safeguard: project, do not replace} +\label{sec:guard} + +An interpolation-only rule has no worst-case bound. The obvious safeguards +\emph{replace} the computed step with a midpoint whenever some progress test +fails, and all of them are ruinous here, for a reason that is specific to a +fast method: a step that collapses the \emph{error} need not halve the +\emph{bracket}, so a bracket-based test fires on exactly the steps that were +best. With the three-point scale, replacing on that test drops the observed +order from $1.94$ to $1.00$ and the Alefeld--Potra--Shi total from $2806$ to +$7260$ --- worse than bisection. + +The remedy is to keep as much of the computed step as the budget allows. +Let $n_{\max}=2\lceil\log_2(w_0/\varepsilon_x)\rceil$ be twice the bisection +step count for the initial width $w_0$ and $x$-tolerance $\varepsilon_x$, and +let $\epsilon=\varepsilon_x/2$. At step $j$, with the bracket $[\ell,h]$, +define the allowance and the projection +\begin{equation} +\label{eq:proj} +\alpha_j = 2^{\,n_{\max}-j}\epsilon, +\qquad +x \;=\; \operatorname{clamp}\bigl(x_{\mathrm{sim}},\; h-\alpha_j,\; \ell+\alpha_j\bigr). +\end{equation} +The next bracket is at most $\max(x-\ell,\,h-x)$, so~\eqref{eq:proj} gives +$w_{j+1}\le\alpha_j$ directly, and induction bounds the run by $n_{\max}$ steps +in exact arithmetic. In floating point the bracket can land exactly on the +boundary, and the termination test then asks for one more; the guarantee +stated and verified is therefore +$2\lceil\log_2(w_0/\varepsilon_x)\rceil+3$ evaluations. + +Three remarks on why this introduces nothing. +\begin{itemize} +\item \textbf{The doubling is not a tuning constant.} It is the factor already +claimed in the bound. Zero slack --- $n_{\max}=\lceil\log_2(w_0/\varepsilon_x)\rceil$, +a worst case of exactly bisection --- is degenerate and was measured as such: a +worst case of exactly bisection demands a halving at \emph{every} step, so the +projection has no freedom, the radius on a unit bracket is $0.05$ from the +first step, and the guard behaves as bisection. +\item \textbf{This is ITP's projection stage without ITP's truncation stage.} +All three of ITP's constants live in the truncation, whose purpose is to repair +regula falsi; the similarity step needs no repair, so the truncation and every +constant with it are dropped. +\item \textbf{Writing the clamp in the form~\eqref{eq:proj} rather than as a +radius $\alpha_j-w_j/2$ about the midpoint is not cosmetic.} That radius is a +difference of two nearly equal numbers; the cancellation made the computed +radius too large by a relative $8.9\cdot10^{-5}$, which broke the invariant on +eleven Chandrupatla problems. +\end{itemize} + +\section{Experimental protocol} + +\paragraph{Problem sets.} The $154$ problems of Alefeld, Potra and Shi~\cite{aps} +and the $45$ of Chandrupatla~\cite{chandrupatla}, taken programmatically from +SciPy's \texttt{scipy.optimize.\_tstutils} so that no bracket or root is +transcribed by hand. + +\paragraph{Cost model.} Evaluations of $f$. A run counts as solved when it +reports convergence and lands within $10^{-6}$ of the published root; +$x$-tolerance $10^{-12}$; budget $200$ evaluations. \emph{Failures are charged +the full budget}, so no method can buy a low total by giving up early, and +totals are reported over all problems rather than over the subset a method +happened to solve. Rankings are by failures first, then by total. + +\paragraph{Fairness to the competitors.} Three deliberate concessions. +(i)~ITP is natively written against a half-width $\epsilon$ and terminates on +$b-a\le2\epsilon$; feeding the common tolerance in as $\epsilon$ would let it +stop at twice its competitors' bracket width, so $\epsilon=\varepsilon_x/2$ is +used. (ii)~ITP is reported both at the authors' recommended constants and as a +\emph{per-problem oracle}, the best of a $(\kappa_1,n_0)$ grid chosen +separately for every problem --- not an achievable method, included so that the +state of the art cannot be said to have been handicapped. (iii)~Our +implementation of ITP is validated against the method's own theorem, that it +never needs more than $n_{1/2}+n_0$ iterations, on all $154$ problems for +$n_0\in\{0,1,2,5\}$. + +\paragraph{Reproducibility.} All numbers come from a single Linux run. The test +functions call \texttt{libm}, whose last digit differs between platforms; the +same SciPy version scores $2819$ for TOMS\,748 on Windows and $2820$ on Linux +for the same set. Every number stated in this paper is checked against the run +data by a script that is part of the test suite. + +\section{Results} + +The grid is nine similarity functions $\times$ four scales $\times$ six +safeguards $=216$ configurations, plus ten baselines. The configuration +proposed in Section~3 --- ratio similarity, three-point scale, projection +safeguard --- is one entry of that grid, fixed by the theory rather than chosen +from the ranking. + +\begin{table}[h] +\centering +\caption{Alefeld--Potra--Shi, $154$ problems, out of $226$ configurations.} +\label{tab:aps} +\begin{tabular}{rlccrr} +\toprule +\# & configuration & tuned & solved & total evals & $>2\times$\\ +\midrule +1 & \textbf{proposed: ratio, 3-point, projection} & \textbf{no} & 153/154 & \textbf{2806} & 0\\ +3 & TOMS\,748 & yes & 153/154 & 2820 & 0\\ +4 & Brent & yes & 153/154 & 2890 & 0\\ +11 & ITP, per-problem oracle & yes & 153/154 & 3260 & 0\\ +18 & Ridders & no & 153/154 & 3313 & 0\\ +31 & ITP, recommended constants & yes & 153/154 & 3957 & 0\\ +61 & Illinois & yes & 153/154 & 7045 & 0\\ +65 & bisection & no & 153/154 & 7530 & 0\\ +206 & false position & no & 127/154 & 10560 & --\\ +\bottomrule +\end{tabular} +\end{table} + +On the problems both solve, the proposed configuration beats Brent +$102/11/40$ (wins/ties/losses), TOMS\,748 $86/16/51$, ITP at its recommended +constants $132/3/18$, the per-problem ITP oracle $121/4/28$, and bisection +$152/1/0$. + +\begin{table}[h] +\centering +\caption{Chandrupatla, $45$ problems, brackets up to $10^{12}$ wide.} +\label{tab:cha} +\begin{tabular}{rlccr} +\toprule +\# & configuration & tuned & solved & total evals\\ +\midrule +1 & similarity, $1-\sqrt{|z|}$, bracket scale, projection & no & \textbf{41/45} & 4516\\ +2 & ITP, per-problem oracle & yes & 40/45 & 2611\\ +3 & similarity, $e^{-|z|}$, bracket scale, both guards & no & 40/45 & 2733\\ +5 & ITP, recommended constants & yes & 40/45 & 2857\\ +6 & bisection & no & 40/45 & 3090\\ +10 & \textbf{proposed: ratio, 3-point, projection} & \textbf{no} & 40/45 & \textbf{3220}\\ +127 & TOMS\,748 & yes & 40/45 & 4000\\ +189 & Brent & yes & 38/45 & 4101\\ +\bottomrule +\end{tabular} +\end{table} + +The set's nominal winner is a similarity configuration that solves one problem +more than anything else, $41$ of $45$, at a worse total; ranking by failures +first puts it on top, and we report it as such rather than by the total that +would flatter our proposal. The proposed configuration is tenth by total and +beats Brent $30/4/4$ and TOMS\,748 $31/1/8$, while losing to ITP $17/0/23$ and +to the ITP oracle $16/0/24$. + +\subsection{What the guarantee costs} + +Nothing on one set, and less than nothing on the other. Against the identical +rule with no safeguard at all: + +\begin{center} +\begin{tabular}{lrrr} +\toprule +& solved & total evals & runs over the $2\times$ bound\\ +\midrule +APS, no safeguard & 153/154 & 2806 & 0\\ +APS, projection & 153/154 & 2806 & 0\\ +Chandrupatla, no safeguard & 35/45 & 4104 & 10\\ +Chandrupatla, projection & \textbf{40/45} & \textbf{3220} & \textbf{0}\\ +\bottomrule +\end{tabular} +\end{center} + +On the canonical set the projection never binds and the totals are identical to +the last evaluation. On the wide-bracket set it solves five more problems for +$21\%$ fewer evaluations. This is the opposite of the usual trade, and it is +the point of projecting rather than replacing: the two safeguards that replace +cost $7260$ and $7239$ on Alefeld--Potra--Shi, against $2806$. + +\subsection{Wall-clock time, and why it is not the cost model} + +Evaluations of $f$ are the cost model because in any real problem $f$ is the +expensive part. Wall-clock time measures something narrower --- the method's +own arithmetic per step --- and it is implementation- and language-bound. We +report it because a reader will ask, and because what it shows is instructive. + +On the $199$ problems as they stand, every $f$ being a formula of a few +operations, the proposed rule is the \emph{slowest} of the pure-Python methods +compared, at $32.8$\,ms against $18.4$ for Brent, $21.1$ for ITP, $14.2$ for +Ridders and $22.9$ for bisection --- while using the fewest evaluations of all +of them, $4991$ against $5932$, $5675$, $6421$ and $9474$. Bisection, needing +nearly twice the evaluations, finishes in two thirds of our time. + +That inversion is the point. Making $f$ progressively more expensive by a +controlled amount of arithmetic and timing the sweep directly --- nothing +subtracted, nothing modelled --- the proposed rule overtakes ITP once one call +to $f$ costs about $9\,\mu$s and Brent at about $20\,\mu$s, of the order of a +hundred arithmetic operations on this machine. Below that the ranking is +decided by per-step overhead; above it, by evaluations. + +Three caveats, all limitations of the measurement rather than of the methods. +Timings vary by tens of percent between runs even on an idle machine. An +attempt to separate our per-step cost into ``algorithm'' and ``Python call +overhead'', by timing a flattened rewrite of the same rule, produced a variant +that diverged from the original on $42$ of the $199$ problems and was +discarded rather than quoted; the question stays open. And an earlier version +of this measurement estimated a per-evaluation overhead by subtracting the +measured cost of $f$, which returned \emph{negative} overheads for four of six +methods --- an impossibility that condemned the estimator, and the reason +nothing is subtracted here. + +\subsection{The law across the whole grid} +\label{sec:grid} + +Corollaries~\ref{cor:chosen}--\ref{cor:derived} predict an ordering of the nine +similarity functions and of the four scales. Table~\ref{tab:grid} reports it. +The prediction holds without exception for every data-derived scale: the three +similarities with $c=1$ occupy the top three places and the three with $c=0$ +the bottom three. For the chosen scale the two groups are indistinguishable +($16102$ against $15345$), which is consistent --- with a chosen scale nothing +converges well and the ordering carries no information. + +\begin{table}[h] +\centering +\caption{Mean total evaluations over both sets, step guard, grouped by the +slope $c$ of $1-S$ at the origin.} +\label{tab:grid} +\begin{tabular}{lrr} +\toprule +scale & $c=1$ (linear approach) & $c=0$ (quadratic approach)\\ +\midrule +3-point derived & \textbf{6809} & 22294\\ +2-point derived & 6906 & 22167\\ +bracket & 10263 & 19137\\ +start (chosen) & 16102 & 15345\\ +\bottomrule +\end{tabular} +\end{table} + +Ranked individually and best over scales, the similarities come out $1-|z|$ +($6496$), $e^{-|z|}$ ($6822$), $1/(1+|z|)$ ($7038$), $(1+|z|)^{-2}$ ($9502$), +$1-\sqrt{|z|}$ ($10497$), $1-|z|^{1/3}$ ($11941$), $e^{-z^2}$ ($14314$), +$1/(1+z^2)$ ($15102$), $1/\sqrt{1+z^2}$ ($16394$); the scales come out 3-point +($6496$), 2-point ($6628$), bracket ($9081$), start ($14540$). Both orderings +are those the law predicts, and both were predicted before the grid was run. + +\section{Where the evaluations go} + +Splitting each run at the geometric mean of the initial width and the +attainable tolerance --- the log-midpoint of the journey, at which bisection by +construction has spent half its evaluations --- separates the \emph{approach} +from the \emph{endgame}. On Alefeld--Potra--Shi the two-point rule spends +$2235$ on the approach and $668$ on the endgame against Brent's $2175$ and +$515$: its deficit is almost entirely the endgame, i.e.\ the order, which is +what motivated the three-point scale. On Chandrupatla it spends $1068$ and +$1161$ against Brent's $1343$ and $1358$, winning both phases. + +Two natural explanations of the Chandrupatla advantage were tested and +\emph{refuted}. Brent discards $53.3\%$ of its interpolations to its safeguard +on the set it wins and only $34.0\%$ on the set it loses, so safeguard rate is +not the mechanism; and on Chandrupatla Brent is the bolder of the two --- +$56.3\%$ of its probes land in the outer tenths of the bracket against our +$41.8\%$ --- so step length is not the mechanism either. + +The mechanism is step \emph{quality}. Reconstructing each method's bracket from +the signs it observed, the median probe removes $0.500$ of the bracket for +every method on Alefeld--Potra--Shi, but on Chandrupatla it removes $0.275$ for +the similarity rule against $0.058$ for Brent and $0.068$ for TOMS\,748 --- +and that comparison already flatters them, since $69$ and $141$ of their probes +respectively fall outside the proven bracket and are excluded, against none of +ours. High-order interpolation is a wager that $f$ is locally polynomial. When +the wager pays, order $1.84$ or $2.65$ wins the endgame; when it fails, the +probes are wasted. The similarity rule makes the weakest available assumption +--- a single local slope --- and degrades gracefully. + +\section{Negative results} + +\begin{enumerate} +\item \textbf{The prototype-aggregation form of the method loses.} A richer +construction --- prototypes over \emph{pairs} of evaluated points, softmax +weights over the whole memory, similarity on both the value and the abscissa +axis --- leads on eight hand-picked problems but loses decisively on the real +set: $0$ wins, $6$ ties and $147$ losses against Brent. The simplest form of +the idea won. +\item \textbf{Every safeguard that replaces the step destroys the order.} +Bracket-based and step-based replacement both drop the three-point rule from +order $1.94$ to $1.00$ and cost $7260$ and $7239$ evaluations on +Alefeld--Potra--Shi. Only projection preserves both. We record this because it +is the trap the construction naturally falls into. +\item \textbf{Zero slack in the projection is degenerate.} A worst case of +exactly bisection demands a halving at every step and leaves the projection no +freedom at all. +\item \textbf{Regimes exist, at the level of a function family, and cannot be +exploited by a switch.} The cube-root similarity beats the proposed rule on +all five members of Chandrupatla's \texttt{fun4} --- $32/32/40/47/59$ against +$89/93/113/125/153$, a factor of $2.6$ --- and consistency across a family at +different parameters is the signature of structure rather than luck. But the +same similarity over the whole Chandrupatla set costs $4099$ against $3220$, +so a switch chosen per benchmark is worse than no switch at all: $6905$ +against $6026$ over both sets. The scale axis offers only $5.3\%$ headroom +even to an oracle handed the best scale per problem, two thirds of it inside a +single family, and the winners are not separated by anything the method can +see before it commits --- the proposed scale wins on bracket widths from +$10^0$ to $10^{12}$. + +\item \textbf{The phase detector: derivation sound, estimator not.} Redoing +the contraction law without the assumption $|f|\approx|f'(r)|e$ --- taking +$|f|\approx K e^m$ instead --- produces the march exponent on its own, +$p = L/(L-\ln m)$ with $L=\ln(e/D)$, giving $p=1$ at a simple root and dropping +to $0.50$ and $0.23$ as the approach flattens, which is the neighbourhood of +the cube root that wins those families. Substituted back it collapses to the +multiplier $m$, measurable as $m = 1/(1-\theta)$ with $\theta = f f''/(f')^2$ +from three divided differences and no constant. It preserves the order +($2.001$) and improves the eight standard problems ($82$ against $84$) --- and +loses on the full benchmark, $6304$ against $6026$. The estimator is the +failure: on Alefeld--Potra--Shi, where almost every root is simple and the +truth is $m=1$, it reports $m>1$ on $27.9\%$ of steps with excursions to +$m=34.8$, against $35.8\%$ on the flat families. $27.9$ against $35.8$ is no +separation. A cruder variant, correcting by the fraction of its own promise +the previous step kept, fails everything: the order collapses to $0.904$ and +the standard problems double to $161$. + +\item \textbf{One problem defeats every method}, \texttt{aps.13.00}, +$f(x)=x e^{-1/x^2}$, all of whose derivatives vanish at the root and which +underflows to exactly zero throughout $|x|<0.086$; every method returns a +machine zero at distance up to $0.086$ from the root. +\item \textbf{The symmetric ratio similarity degenerates.} For +$S(x,y)=\min(|x|,|y|)/\max(|x|,|y|)$ with $y$ the target $0$, $S\equiv0$; the +only usable reading is $1-|f|/\sigma$, which saturates and stagnates +(Table~\ref{tab:law-check}, last row). +\end{enumerate} + +\section{Conclusion} + +A root finder can be derived from a similarity function alone, and the +derivation shows where the content of such a method actually sits. It is not in +the shape of $S$ --- nine shapes were tried and their ranking is dictated by a +single number, the slope of $1-S$ at the origin. It is not in making the +similarity change faster --- that overshoots exactly as readily as flatness +stagnates. It is in the \emph{scale} against which similarity is judged: +chosen, the method is brittle and merely linear; taken from the bracket, it is +false position and three centuries old; read off the data, it is superlinear. +And the safeguard that makes such a method safe must project the step, not +replace it: replacing costs the order, projecting costs nothing on one +benchmark and improves the method on the other. + +The resulting rule has no tuning constant and carries a worst case of twice +bisection plus one step. On the canonical Alefeld--Potra--Shi set it is level +with TOMS\,748 --- $2806$ evaluations against $2820$ is a margin of $0.5\%$ and +should be read as a tie --- and ahead of Brent by $2.9\%$, which it also beats +$102$ problems to $40$ head to head. The claim the measurements support is +parity with methods that carry tuned constants, not superiority over them. + +This is the same movement as in parameter-free similarity control~\cite{sim}, +where membership functions are eliminated by normalising the input space from +the data rather than by choosing widths. Here the object normalised is the +value axis, and the price of choosing it by hand is measured rather than +asserted. + +\subsection*{Future work} + +One weakness has a clear diagnosis and no fix inside this framework. On +brackets many orders of magnitude wider than the distance to the root, the +search must cross those decades, and an \emph{additive} step of $|f|/|f'|$ is +sized by the local slope, which knows nothing about how many decades remain. +That is why the cube-root similarity, whose step is a fixed \emph{fraction} of +the bracket, beats the proposed rule $2.6$-fold on those families, and why ITP +keeps its lead on the Chandrupatla set. + +The regime is therefore multiplicative versus additive movement, not one +similarity function versus another --- a change of the space the method works +in, not of a coefficient inside it. The natural instrument is a logarithmic +change of variable, $u = \operatorname{sign}(x-c)\log(1+|x-c|/s)$, in which an +additive step becomes a geometric march and the exponent that the cube root +fixes at $1/3$ by accident disappears as a free quantity. Two conditions +decide whether that is a method or another refuted idea: the origin $c$ and +unit $s$ must be read from the bracket rather than chosen, and the transform +must be the identity to within rounding on narrow brackets, so that the +wide-bracket families are not bought at the price of the canonical set. Every +attempt reported in Section~7 failed on exactly that second condition. + +\begin{thebibliography}{9} +\bibitem{aps} G.~E. Alefeld, F.~A. Potra and Y.~Shi, ``Algorithm 748: Enclosing +zeros of continuous functions,'' \emph{ACM Trans.\ Math.\ Softw.}, vol.~21, +no.~3, pp.~327--344, 1995. +\bibitem{brent} R.~P. Brent, \emph{Algorithms for Minimization without +Derivatives}. Englewood Cliffs, NJ: Prentice-Hall, 1973. +\bibitem{chandrupatla} T.~R. Chandrupatla, ``A new hybrid quadratic/bisection +algorithm for finding the zero of a nonlinear function without using +derivatives,'' \emph{Adv.\ Eng.\ Software}, vol.~28, no.~3, pp.~145--149, 1997. +\bibitem{itp} I.~F.~D. Oliveira and R.~H.~C. Takahashi, ``An enhancement of the +bisection method average performance preserving minmax optimality,'' +\emph{ACM Trans.\ Math.\ Softw.}, vol.~47, no.~1, pp.~1--24, 2021. +\bibitem{ridders} C.~Ridders, ``A new algorithm for computing a single root of +a real continuous function,'' \emph{IEEE Trans.\ Circuits Syst.}, vol.~26, +no.~11, pp.~979--980, 1979. +\bibitem{sim} V.~Sitnikov, ``Parameter-free similarity control,'' preprint, +2026. +\bibitem{dowell} M.~Dowell and P.~Jarratt, ``A modified regula falsi method for +computing the root of an equation,'' \emph{BIT}, vol.~11, pp.~168--174, 1971. +\end{thebibliography} + +\end{document} diff --git a/audit_algorithm.py b/audit_algorithm.py new file mode 100644 index 0000000..f8562c1 --- /dev/null +++ b/audit_algorithm.py @@ -0,0 +1,342 @@ +"""Full audit of the algorithm: functional, logical, algorithmic. + +Every finding below is DEMONSTRATED by a probe rather than asserted from +reading, because reading is how the last four defects got in. Each probe +prints PASS or the failure it provoked. + +Sections + 1 contracts and degenerate input + 2 the bracketing invariant + 3 the convergence claim: what "converged" is allowed to mean + 4 the credit safeguard's arithmetic over its full domain + 5 wasted evaluations: does the method ever re-ask a point it knows? + 6 the competitors, since every conclusion rests on them + 7 determinism +""" +from __future__ import annotations + +import math + +from simroot.baselines import (BASELINES, chandrupatla, chandrupatla_scipy, + dekker) +from simroot.pure import GUARDS, PURE_SIMS, _Safeguard, pure_root + +XTOL, MAXFEV = 1e-12, 200 +FINDINGS = [] + + +def probe(name, fn): + try: + ok, detail = fn() + except Exception as exc: + ok, detail = False, f"raised {type(exc).__name__}: {exc}" + print(f" {'PASS' if ok else 'FAIL'} {name:56s} {detail}") + if not ok: + FINDINGS.append((name, detail)) + + +def ours(f, a, b, guard="credit", **kw): + return pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", + scale="derived3", guard=guard, **kw) + + +# ========================================================================== +def sec1(): + print("\n1. CONTRACTS AND DEGENERATE INPUT") + + def reversed_bracket(): + # a > b is not a bracket in the sense the docstring implies; what + # happens? + x, n, conv = ours(lambda t: t * t - 2.0, 2.0, 0.0) + inside = min(0.0, 2.0) <= x <= max(0.0, 2.0) + return inside, f"returned x={x:.6g} conv={conv} inside={inside}" + + def no_sign_change(): + try: + ours(lambda t: t * t + 1.0, 0.0, 2.0) + return False, "accepted a bracket with no sign change" + except ValueError: + return True, "ValueError, as it should" + + def zero_tolerance(): + x, n, conv = pure_root(lambda t: t * t - 2.0, 0.0, 2.0, 0.0, MAXFEV, + similarity="ratio", scale="derived3", + guard="credit") + return n <= MAXFEV, f"xtol=0 -> n={n} conv={conv} (must not hang)" + + def negative_tolerance(): + x, n, conv = pure_root(lambda t: t * t - 2.0, 0.0, 2.0, -1.0, MAXFEV, + similarity="ratio", scale="derived3", + guard="credit") + return n <= MAXFEV, f"xtol<0 -> n={n} conv={conv}" + + def nan_function(): + x, n, conv = ours(lambda t: float("nan"))if False else ours( + lambda t: float("nan") if 0.3 < t < 0.7 else t * t - 2.0, 0.0, 2.0) + return (n <= MAXFEV and not math.isnan(x)), \ + f"f returns NaN on part of the bracket -> x={x} n={n} conv={conv}" + + def infinite_function(): + # a genuine pole INSIDE a genuine bracket: f(-1) < 0 < f(1) with a + # singularity at 0. The first version of this probe had both ends + # negative, so it measured the author's inattention rather than the + # method - the signature refused it, correctly. + def f(t): + if t == 0.0: + return math.inf + return 1.0 / t + x, n, conv = ours(f, -1.0, 1.0) + return n <= MAXFEV, (f"pole at 0 inside [-1,1] -> x={x:.6g} n={n} " + f"conv={conv} (no root exists; must not hang " + f"or crash)") + + probe("reversed bracket stays inside", reversed_bracket) + probe("no sign change is refused", no_sign_change) + probe("xtol = 0 terminates", zero_tolerance) + probe("xtol < 0 terminates", negative_tolerance) + probe("NaN inside the bracket", nan_function) + probe("pole inside the bracket", infinite_function) + + +# ========================================================================== +def sec2(): + print("\n2. THE BRACKETING INVARIANT") + + fs = [(lambda t: t * t - 2.0, 0.0, 2.0), + (lambda t: math.exp(-t) * (t - 1.0), -1.0, 40.0), + (lambda t: t ** 10 - 1.0, 0.0, 1.3), + (lambda t: math.atan(t), -1.0, 3.0)] + + def never_leaves(): + bad = [] + for guard in GUARDS: + for f, a, b in fs: + probes = [] + def g(t, _p=probes, _f=f): + _p.append(t) + return _f(t) + try: + ours(g, a, b, guard=guard) + except Exception as exc: + bad.append((guard, repr(exc)[:40])) + continue + lo, hi = min(a, b), max(a, b) + out = [t for t in probes if not (lo <= t <= hi)] + if out: + bad.append((guard, f"probed outside: {out[:3]}")) + return not bad, ("no probe left the initial bracket" + if not bad else str(bad[:3])) + + def sign_change_preserved(): + """Every returned interval must still straddle the root.""" + bad = [] + for guard in GUARDS: + for f, a, b in fs: + x, n, conv = ours(f, a, b, guard=guard) + if conv and abs(f(x)) > 1e-6 and abs(x - a) > 1e-9: + # allow the tolerance itself, but a converged answer whose + # |f| is large is a false claim + bad.append((guard, x, f(x))) + return not bad, ("converged answers all have small |f|" + if not bad else str(bad[:3])) + + probe("no probe ever leaves the initial bracket", never_leaves) + probe("a converged answer really is near a root", sign_change_preserved) + + +# ========================================================================== +def sec3(): + print("\n3. WHAT 'CONVERGED' IS ALLOWED TO MEAN") + + def converged_implies_tolerance(): + """conv=True must imply the final bracket is within xtol - otherwise + the flag is an opinion.""" + bad = [] + for guard in GUARDS: + f = lambda t: math.exp(-t) * (t - 1.0) + x, n, conv = pure_root(f, -1.0, 40.0, 1e-300, 400, + similarity="ratio", scale="derived3", + guard=guard) + if conv and abs(x - 1.0) > 1e-8: + bad.append((guard, x, n)) + return not bad, ("an impossible tolerance is reported as failure" + if not bad else str(bad)) + + def budget_respected(): + bad = [] + for guard in GUARDS: + for budget in (0, 1, 2, 3, 7, 25): + _x, n, _c = pure_root(lambda t: t * t - 2.0, 0.0, 2.0, XTOL, + budget, similarity="ratio", + scale="derived3", guard=guard) + if n > budget: + bad.append((guard, budget, n)) + return not bad, "never spends more than the budget" if not bad else str(bad) + + probe("conv=True implies the tolerance was met", converged_implies_tolerance) + probe("the evaluation budget is never exceeded", budget_respected) + + +# ========================================================================== +def sec4(): + print("\n4. THE CREDIT SAFEGUARD OVER ITS FULL DOMAIN") + + def credit_overflow(): + """credit accumulates log2 of every shrink. 2**(C-1) overflows a + double at C ~ 1025. Is C bounded in the implementation?""" + sg = _Safeguard("credit", 1.0, XTOL) + sg.credit = 1100.0 + try: + sg.project_credit(0.9, 0.0, 1.0) + return True, "no overflow at C=1100" + except OverflowError as exc: + return False, f"OverflowError at C=1100 ({exc}); C is unbounded" + + def credit_reachable(): + """A large credit is REACHABLE - sixty nine-decade steps reach 1012 - + so what matters is that it is harmless, not that it is small. An + earlier version of this probe asserted C < 1000, which after the fix + reports a defect that no longer exists.""" + sg = _Safeguard("credit", 1.0, XTOL) + sg.credit = 1.0 + w = 1.0 + for _ in range(60): + sg.note_shrink(w, w * 1e-9) # nine decades per step + w *= 1e-9 + big = sg.credit + x = sg.project_credit(0.9, 0.0, 1.0) + return x == 0.9, (f"C reaches {big:.0f} and a step is then " + f"unrestricted (x={x}), which is the correct " + f"behaviour: credit that large restricts nothing") + + def wide_dynamic_range(): + """An end-to-end problem with a huge bracket and a tight tolerance.""" + f = lambda t: t - 1.0 + x, n, conv = pure_root(f, -1e150, 1e150, 1e-12, 4000, + similarity="ratio", scale="derived3", + guard="credit") + return (conv and abs(x - 1.0) < 1e-6), \ + f"bracket 1e150 wide -> x={x:.6g} n={n} conv={conv}" + + probe("credit cannot overflow the exponent", credit_overflow) + probe("credit stays in a reachable range", credit_reachable) + probe("a 1e150-wide bracket is handled", wide_dynamic_range) + + +# ========================================================================== +def sec5(): + print("\n5. WASTED EVALUATIONS") + + def repeats(): + """The duplicate check compares only against the last two points. Is + a third-back point ever re-evaluated?""" + worst = 0 + where = None + from scipy.optimize._tstutils import _APS_TESTS_DICTS, \ + _CHANDRUPATLA_TESTS_DICTS + probs = [((lambda ff, aa: lambda t: ff(t, *aa))(d["f"], + d.get("args", ())), + float(d["bracket"][0]), float(d["bracket"][1]), d["ID"]) + for d in _APS_TESTS_DICTS] + probs += [((lambda ff: lambda t: ff(t))(d["f"]), + float(d["bracket"][0]), float(d["bracket"][1]), d["ID"]) + for d in _CHANDRUPATLA_TESTS_DICTS] + for f, a, b, pid in probs: + seen = [] + def g(t, _s=seen, _f=f): + _s.append(t) + return _f(t) + try: + ours(g, a, b) + except Exception: + continue + dup = len(seen) - len(set(seen)) + if dup > worst: + worst, where = dup, pid + return worst == 0, (f"no repeated evaluation" if worst == 0 + else f"{worst} repeats, worst on {where}") + + probe("no point is evaluated twice", repeats) + + +# ========================================================================== +def sec6(): + print("\n6. THE COMPETITORS") + + def dekker_sane(): + """Dekker solves 24/45 on Chandrupatla, which is either its known slow + convergence or a bug in our transcription. It has no library version, + so the check is against its defining property: it must never be worse + than its own secant/bisection choice on an easy problem.""" + x, n, conv = dekker(lambda t: t * t - 2.0, 0.0, 2.0, XTOL, MAXFEV) + return (conv and abs(x - math.sqrt(2.0)) < 1e-8 and n < 30), \ + f"x^2-2 -> n={n} conv={conv} x={x:.12f}" + + def chandrupatla_agrees_with_scipy(): + from scipy.optimize._tstutils import _APS_TESTS_DICTS + diff = 0 + for d in _APS_TESTS_DICTS: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + args = d.get("args", ()) + f = (lambda ff, aa: lambda t: ff(t, *aa))(d["f"], args) + x1, n1, c1 = chandrupatla(f, a, b, XTOL, MAXFEV) + x2, n2, c2 = chandrupatla_scipy(f, a, b, XTOL, MAXFEV) + if c1 and c2 and abs(x1 - x2) > 1e-6: + diff += 1 + return diff == 0, f"{diff} problems where the two disagree on the root" + + def exact_zero_handling(): + """f(x) == 0 exactly: every method must return that x, not keep going.""" + bad = [] + for name, m in BASELINES.items(): + x, n, conv = m(lambda t: t - 1.0, 1.0, 5.0, XTOL, MAXFEV) + if not (conv and abs(x - 1.0) < 1e-12 and n <= 3): + bad.append((name, n, conv, x)) + return not bad, "all return the exact root at once" if not bad else str(bad) + + probe("dekker behaves on an easy problem", dekker_sane) + probe("our chandrupatla agrees with scipy's root", chandrupatla_agrees_with_scipy) + probe("an exact zero at an endpoint costs <= 3 evaluations", exact_zero_handling) + + +# ========================================================================== +def sec7(): + print("\n7. DETERMINISM") + + def repeatable(): + f = lambda t: math.cos(t) - t + runs = {ours(f, 0.0, 1.0) for _ in range(5)} + return len(runs) == 1, f"{len(runs)} distinct results over 5 runs" + + def similarity_independence(): + """Changing the similarity must change only the step, never the + contract: all nine must stay inside the bracket and respect the + budget.""" + bad = [] + for sim in PURE_SIMS: + x, n, conv = pure_root(lambda t: t * t - 2.0, 0.0, 2.0, XTOL, + MAXFEV, similarity=sim, scale="derived3", + guard="credit") + if not (0.0 <= x <= 2.0 and n <= MAXFEV): + bad.append((sim, x, n)) + return not bad, "all nine respect the contract" if not bad else str(bad) + + probe("the same call gives the same answer", repeatable) + probe("every similarity respects the contract", similarity_independence) + + +def main(): + print("=" * 78) + print("ALGORITHM AUDIT") + print("=" * 78) + for s in (sec1, sec2, sec3, sec4, sec5, sec6, sec7): + s() + print("\n" + "=" * 78) + print(f"FINDINGS: {len(FINDINGS)}") + print("=" * 78) + for name, detail in FINDINGS: + print(f" - {name}: {detail}") + + +if __name__ == "__main__": + main() diff --git a/bench_full.py b/bench_full.py new file mode 100644 index 0000000..449d182 --- /dev/null +++ b/bench_full.py @@ -0,0 +1,201 @@ +"""The full benchmark: similarity root finding against the state of the art. + +Problem sets, both taken from scipy so that nothing is transcribed by hand: + + APS 154 problems - Alefeld, Potra & Shi, "Algorithm 748: Enclosing + Zeros of Continuous Functions", ACM TOMS 21(3), 1995. The + canonical set for bracketed root finding. + Chandrupatla 45 problems - Chandrupatla, "A new hybrid quadratic/bisection + algorithm for finding the zero of a nonlinear function without + using derivatives", Adv. Eng. Software 28, 1997. + +Cost model: number of evaluations of f, which is the only cost that matters +for a bracketed solver. A run counts as SOLVED when it reports convergence +AND lands within `acc` of the published root. + +Reporting rules, chosen so the numbers cannot flatter the new method: + + * failures are charged at the full evaluation budget, so a method cannot + buy a low total by giving up early; + * the total is reported over ALL problems, not over the ones a method + happened to solve; + * ITP is reported twice - at the authors' recommended constants, and as an + ORACLE that is given the best of a (kappa1, n0) grid per problem, i.e. + tuned individually to every problem it is asked to solve. The oracle is + not an achievable method; it is there so that no one can say the + state of the art was handicapped; + * every method that carries tuning constants is marked in the table. +""" +from __future__ import annotations + +import math +import sys + +from scipy.optimize._tstutils import _APS_TESTS_DICTS, _CHANDRUPATLA_TESTS_DICTS + +from simroot.baselines import (anderson_bjorck, bisection, brent, illinois, + itp, pegasus, regula_falsi, ridders, toms748) +from simroot.pure import pure_root +from simroot.sim import sim_root + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 # a run must land this close to the published root + + +def load(which): + out = [] + if which in ("aps", "all"): + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + f = d["f"] + out.append((d["ID"], (lambda ff, aa: lambda x: ff(x, *aa))(f, args), + float(a), float(b), float(d["root"]))) + if which in ("chandrupatla", "all"): + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + f = d["f"] + out.append((d["ID"], (lambda ff: lambda x: ff(x))(f), + float(a), float(b), float(d["root"]))) + return out + + +ITP_GRID = [(fac, n0) for fac in (1.0, 0.1, 0.01, 1e-4) + for n0 in (0, 1, 2, 5, 10)] + + +def itp_oracle(f, a, b, xtol, maxfev): + """The most generous ITP possible: the best of the grid, per problem.""" + best = None + for fac, n0 in ITP_GRID: + try: + x, n, conv = itp(f, a, b, xtol, maxfev, + kappa1=fac * 0.2 / (b - a), n0=n0) + except ValueError: + continue + if conv and (best is None or n < best[1]): + best = (x, n, True) + return best if best is not None else (0.5 * (a + b), maxfev, False) + + +# name -> (callable, has_tuning_constants) +METHODS = { + "bisection": (bisection, False), + "regula_falsi": (regula_falsi, False), + "illinois": (illinois, True), + "pegasus": (pegasus, True), + "anderson_bjorck": (anderson_bjorck, True), + "ridders": (ridders, False), + "brent": (brent, True), + "toms748": (toms748, True), + "itp (recommended)": (itp, True), + "itp (per-problem oracle)": (itp_oracle, True), + "PURE.ratio.step": (lambda f, a, b, xt, mx: pure_root( + f, a, b, xt, mx, similarity="ratio", scale="derived", guard="step"), False), + "PURE.exp_abs.step": (lambda f, a, b, xt, mx: pure_root( + f, a, b, xt, mx, similarity="exp_abs", scale="derived", guard="step"), False), + "PURE.rational.step": (lambda f, a, b, xt, mx: pure_root( + f, a, b, xt, mx, similarity="rational", scale="derived", guard="step"), False), + "PURE.ratio.both": (lambda f, a, b, xt, mx: pure_root( + f, a, b, xt, mx, similarity="ratio", scale="derived", guard="both"), False), + "PURE.ratio.bracket": (lambda f, a, b, xt, mx: pure_root( + f, a, b, xt, mx, similarity="ratio", scale="derived", guard="bracket"), False), + "PURE.ratio.none": (lambda f, a, b, xt, mx: pure_root( + f, a, b, xt, mx, similarity="ratio", scale="derived", guard="none"), False), + "SIM.pair2d.inv": (lambda f, a, b, xt, mx: sim_root( + f, a, b, xt, mx, similarity="inv", prototypes="pair2d", guard=True), False), + "SIM.pair2d.neg_sq": (lambda f, a, b, xt, mx: sim_root( + f, a, b, xt, mx, similarity="neg_sq", prototypes="pair2d", guard=True), False), +} + + +def run(problems, label): + results = {} + for name, (m, _tuned) in METHODS.items(): + total, solved, fails, per, over = 0, 0, [], {}, [] + for pid, f, a, b, root in problems: + note = "" + try: + x, n, conv = m(f, a, b, XTOL, MAXFEV) + except Exception as exc: # a crash is a failure, loudly + x, n, conv = float("nan"), MAXFEV, False + note = repr(exc)[:60] + ok = bool(conv) and math.isfinite(x) and abs(x - root) <= ACC + # failures are charged the full budget + total += n if ok else MAXFEV + per[pid] = (n, ok, note) + if ok: + solved += 1 + else: + fails.append(pid) + # Does the run respect the "no worse than twice bisection" bound? + # Only SOLVED runs can be judged against it: a run that failed sat + # at the evaluation cap, which says nothing about the bound and + # would silently fill this column with budget exhaustion. + bound = 2 * math.ceil(math.log2(abs(b - a) / XTOL)) + 4 + if ok and n > bound: + over.append(pid) + results[name] = dict(total=total, solved=solved, n=len(problems), + fails=fails, per=per, over=over) + + print(f"\n{'=' * 96}\n{label} ({len(problems)} problems, " + f"xtol={XTOL:g}, budget={MAXFEV} evaluations, accepted within " + f"{ACC:g} of the published root)\n{'=' * 96}") + print(f"{'method':28s}{'tuned':>7s}{'solved':>9s}{'failed':>8s}" + f"{'total fev':>11s}{'mean/solved':>13s}{'over 2x bisect':>16s}") + print("-" * 96) + order = sorted(results, key=lambda k: (len(results[k]["fails"]), + results[k]["total"])) + for name in order: + r = results[name] + tuned = "yes" if METHODS[name][1] else "no" + mean = (sum(v[0] for v in r["per"].values() if v[1]) / r["solved"] + if r["solved"] else float("nan")) + print(f"{name:28s}{tuned:>7s}{r['solved']:>6d}/{r['n']:<3d}" + f"{len(r['fails']):>8d}{r['total']:>11d}{mean:>13.2f}" + f"{len(r['over']):>16d}") + return results + + +def head_to_head(results, a_name, b_name, problems): + ra, rb = results[a_name], results[b_name] + win = loss = tie = 0 + both = 0 + for pid, _f, _a, _b, _root in problems: + na, oka, _ = ra["per"][pid] + nb, okb, _ = rb["per"][pid] + if not (oka and okb): + continue + both += 1 + if na < nb: + win += 1 + elif na > nb: + loss += 1 + else: + tie += 1 + print(f"\n{a_name} vs {b_name}, on the {both} problems both solve: " + f"{win} wins / {tie} ties / {loss} losses") + + +def main(): + which = sys.argv[1] if len(sys.argv) > 1 else "all" + aps = load("aps") + cha = load("chandrupatla") + if which in ("aps", "all"): + r = run(aps, "Alefeld-Potra-Shi 1995") + head_to_head(r, "PURE.ratio.step", "brent", aps) + head_to_head(r, "PURE.ratio.step", "toms748", aps) + head_to_head(r, "PURE.ratio.step", "itp (per-problem oracle)", aps) + head_to_head(r, "SIM.pair2d.inv", "brent", aps) + for nm in ("PURE.ratio.step", "brent", "toms748"): + if r[nm]["fails"]: + print(f" {nm} failed on: {', '.join(r[nm]['fails'][:12])}" + + (" ..." if len(r[nm]["fails"]) > 12 else "")) + if which in ("chandrupatla", "all"): + r2 = run(cha, "Chandrupatla 1997") + head_to_head(r2, "PURE.ratio.step", "brent", cha) + + +if __name__ == "__main__": + main() diff --git a/odestep/__init__.py b/odestep/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/odestep/controllers.py b/odestep/controllers.py new file mode 100644 index 0000000..b6074be --- /dev/null +++ b/odestep/controllers.py @@ -0,0 +1,157 @@ +"""Step-size controllers. Everything else in the integration is SciPy's +(the RK45 tableau, the stage combination, the embedded error estimate), so +these are the only thing under comparison. + +The classical controllers are made of constants somebody chose - a safety +factor, growth clamps, PI gains. The question this module asks is what +happens if the quantity a constant is GUESSING is measured instead. + + root finding step-size control + ------------ ----------------- + the scale of the value axis the safety factor + chosen -> brittle, linear chosen -> works, three constants + measured-> superlinear measured-> works, none + +What did NOT transfer is the credit ledger itself. A first version banked an +accuracy margin exactly as the root-finding safeguard does; the margin turned +out to take no part in any decision and was removed. The move that transfers +is the more general one - replace a chosen constant by the measured value of +what it approximates - not the particular bookkeeping that carried it there. +""" +from __future__ import annotations + +import math + + +class Controller: + name = "?" + constants = 0 + + def reset(self): + pass + + def update(self, h, e, ok, order): + raise NotImplementedError + + +class Elementary(Controller): + """h_new = h * (1/e)^(1/(p+1)) with no safety factor and no clamps. + + Included because it is the controller the error model alone dictates. It + is what every practical code refuses to use, and the reason for that + refusal is exactly what the constants in the others are buying.""" + + name = "elementary (no constants)" + constants = 0 + + def update(self, h, e, ok, order): + if e == 0.0: + return h * 10.0 + return h * (1.0 / e) ** (1.0 / (order + 1)) + + +class Classical(Controller): + """The textbook controller: a safety factor and two growth clamps.""" + + name = "classical (scipy: safety 0.9, clamps 0.2/10)" + constants = 3 + # exactly the constants scipy.integrate._ivp.rk uses, so the driver can + # be validated against solve_ivp with the same control law + SAFETY, MINF, MAXF = 0.9, 0.2, 10.0 + + def update(self, h, e, ok, order): + if e == 0.0: + fac = self.MAXF + else: + fac = self.SAFETY * (1.0 / e) ** (1.0 / (order + 1)) + fac = min(self.MAXF, max(self.MINF, fac)) + return h * fac + + +class GustafssonPI(Controller): + """The PI controller used in modern codes: two gains, a safety factor and + two clamps.""" + + name = "PI (Gustafsson, 5 constants)" + constants = 5 + SAFETY, MINF, MAXF = 0.9, 0.2, 10.0 + K_I, K_P = 0.3, 0.4 + + def reset(self): + self.e_prev = None + + def update(self, h, e, ok, order): + if e == 0.0: + return h * self.MAXF + p1 = order + 1 + if self.e_prev is None or not ok: + fac = self.SAFETY * (1.0 / e) ** (1.0 / p1) + else: + fac = (self.SAFETY * (1.0 / e) ** (self.K_I / p1) + * (self.e_prev / e) ** (self.K_P / p1)) + fac = min(self.MAXF, max(self.MINF, fac)) + if ok: + self.e_prev = e + return h * fac + + +class MeasuredSafety(Controller): + """The safety factor measured instead of chosen. + + NOTE ON THE NAME. This began as "the credit rule transferred", and it + banked a margin exactly as the root-finding safeguard does. The margin + turned out to play no part in the decision - the step factor was computed + from the measured model discrepancy alone - so the banking was vestigial + and the name was unearned. What transfers is not the credit ledger but + the deeper move behind it: replace a chosen constant with the quantity it + is guessing, measured from the run. The ledger is left out because it did + nothing here, and calling this a credit controller would be a mislabel. + + The elementary controller aims at err = tol exactly, and is refused in + practice because the model err ~ C h^(p+1) is only approximate: aiming at + the boundary means missing it about half the time, and every miss costs a + whole rejected step. The classical answer is a safety factor chosen by + hand. + + The answer here is to measure the thing the safety factor is guessing. + After proposing a step, the model predicts what its error will be; the + step is taken and the error is observed. The discrepancy + + delta = log2(observed / predicted) + + is exactly how wrong the model was, in bits, and the next step aims at + 2^-delta instead of at 1. When the model is right, delta -> 0 and the + controller becomes the elementary one; when the model has just been + optimistic, the controller backs off by precisely the observed amount. + + The first step has nothing to have learned from, so it aims at the + tolerance itself - the same licence the root-finding guard grants. + """ + + name = "measured safety (no constants)" + constants = 0 + + def reset(self): + self.predicted = None # error the model expected for this step + self.delta = 0.0 # bits by which the model was last wrong + + def update(self, h, e, ok, order): + p1 = order + 1 + if self.predicted is not None and self.predicted > 0.0 and e > 0.0: + # only optimism matters: the model predicting too SMALL an error + # is what causes rejections. Pessimism costs nothing and is not + # corrected for. + self.delta = max(0.0, math.log2(e / self.predicted)) + if e == 0.0: + fac = 10.0 + else: + # aim at 2^-delta of the tolerance rather than at the tolerance + fac = (2.0 ** (-self.delta) / e) ** (1.0 / p1) + h_new = h * fac + # record what the model now predicts for the step just chosen, so the + # next call can measure how wrong it was + self.predicted = e * (h_new / h) ** p1 + return h_new + + +ALL = [Elementary(), Classical(), GustafssonPI(), MeasuredSafety()] diff --git a/odestep/driver.py b/odestep/driver.py new file mode 100644 index 0000000..ef5a8f5 --- /dev/null +++ b/odestep/driver.py @@ -0,0 +1,114 @@ +"""Integration driver whose only original part is the step-size controller. + +The tableau, the stage combination and the embedded error estimate are +SciPy's - `scipy.integrate._ivp.rk.rk_step` with RK45's A, B, C and E - so +nothing about the method itself is a transcription of ours. An earlier +version of this file carried a hand-typed Dormand-Prince tableau; that was an +unnecessary risk and an unnecessary thing for a reader to have to check. + +What remains ours is the loop that decides the next step size, which is the +object under study. Everything else is shared between controllers, so a +difference between two runs can only come from the controller. + +The driver is validated against SciPy's own `solve_ivp(method="RK45")`: with +the classical controller - SciPy's own safety factor and clamps - the two +must agree closely on the number of right-hand-side evaluations. +""" +from __future__ import annotations + +import math + +import numpy as np +from scipy.integrate._ivp.rk import RK45, rk_step + +ORDER = RK45.error_estimator_order # 4; the step exponent is ORDER + 1 + + +class Counter: + """Counts evaluations of the right-hand side - the cost model.""" + + __slots__ = ("f", "n") + + def __init__(self, f): + self.f = f + self.n = 0 + + def __call__(self, t, y): + self.n += 1 + return np.asarray(self.f(t, y), dtype=float) + + +def _norm(v, y, y_new, atol, rtol): + scale = atol + rtol * np.maximum(np.abs(y), np.abs(y_new)) + return float(np.sqrt(np.mean((v / scale) ** 2))) + + +def integrate(f, t0, t1, y0, controller, atol=1e-8, rtol=1e-8, + max_steps=200000): + """Integrate with the given controller. Returns what the comparison + needs. The initial step is chosen the same way for every controller, so + none can win by guessing it better.""" + g = Counter(f) + t = float(t0) + y = np.asarray(y0, dtype=float) + fv = g(t, y) + K = np.empty((RK45.n_stages + 1, y.size), dtype=float) + + d0 = _norm(y, y, y, atol, rtol) + d1 = _norm(fv, y, y, atol, rtol) + h = 1e-6 if (d0 < 1e-5 or d1 < 1e-5) else 0.01 * d0 / d1 + h = min(h, abs(t1 - t0)) + controller.reset() + + accepted = rejected = 0 + while t < t1 and accepted + rejected < max_steps: + h = min(h, t1 - t) + if h <= 0.0: + break + y_new, f_new = rk_step(g, t, y, fv, h, RK45.A, RK45.B, RK45.C, K) + err = np.dot(K.T, RK45.E) * h # RK45's own error estimate + e = _norm(err, y, y_new, atol, rtol) + ok = e <= 1.0 + h_next = controller.update(h, e, ok, ORDER) + if ok: + accepted += 1 + t, y, fv = t + h, y_new, f_new + else: + rejected += 1 + if not math.isfinite(h_next) or h_next <= 0.0: + break + h = h_next + return {"t": t, "y": list(y), "nfev": g.n, "accepted": accepted, + "rejected": rejected, + "reached_end": abs(t - t1) < 1e-12 * max(1.0, abs(t1))} + + +def validate_against_scipy(atol=1e-8, rtol=1e-8): + """The driver against SciPy's own solver, with SciPy's own controller. + + This replaces the hand-written order check that the previous version + needed: if the driver reproduces solve_ivp's evaluation count with the + same control law, the tableau, the stage combination, the error estimate + and the loop are all the library's behaviour.""" + from scipy.integrate import solve_ivp + + from .controllers import Classical + + out = [] + probs = [ + ("decay", lambda t, y: [-y[0]], 0.0, 10.0, [1.0]), + ("forced", lambda t, y: [-y[0] + math.sin(t)], 0.0, 10.0, [0.0]), + ("lotka", lambda t, y: [1.5 * y[0] - y[0] * y[1], + -3.0 * y[1] + y[0] * y[1]], 0.0, 15.0, + [10.0, 5.0]), + ("vdp", lambda t, y: [y[1], 5.0 * (1 - y[0] ** 2) * y[1] - y[0]], + 0.0, 25.0, [2.0, 0.0]), + ] + for name, f, t0, t1, y0 in probs: + mine = integrate(f, t0, t1, y0, Classical(), atol=atol, rtol=rtol) + ref = solve_ivp(f, (t0, t1), y0, method="RK45", atol=atol, + rtol=rtol) + out.append((name, mine["nfev"], int(ref.nfev), + max(abs(a - b) for a, b in zip(mine["y"], + ref.y[:, -1])))) + return out diff --git a/relax/__init__.py b/relax/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/relax/sor.py b/relax/sor.py new file mode 100644 index 0000000..9b828b7 --- /dev/null +++ b/relax/sor.py @@ -0,0 +1,238 @@ +"""Relaxation for iterative linear solvers, with the relaxation factor +pluggable. + +The relaxation parameter omega of SOR is the oldest hand-tuned constant in +numerical linear algebra. Convergence requires 0 < omega < 2; the optimal +value is known in closed form only for model problems, and everywhere else it +is guessed, swept, or left at a folklore value - the under-relaxation factors +of 0.7 and 0.3 in every SIMPLE-type CFD code being the best-known example. + +The similarity formulation. SOR over-relaxes because the Gauss-Seidel +correction under-shoots CONSISTENTLY IN THE SAME DIRECTION: the iteration +creeps towards the solution instead of stepping to it. How consistent the +direction is, is a similarity between successive corrections: + + s = cos(d_k, d_{k-1}) in [-1, 1], omega = 1 + max(0, s) in [1, 2] + +s = 1 means the correction is repeating itself exactly, so the step should be +doubled - the maximum over-relaxation the theory allows. s <= 0 means the +corrections are fighting each other, so no over-relaxation is warranted and +the method falls back to Gauss-Seidel. The admissible interval of the theory +and the range of the similarity coincide, and nothing is chosen. + +The sweeps below are written out because SciPy ships no SOR. They are +validated against theory: for the model Poisson problem the SOR spectral +radius is exactly omega_opt - 1, which the measured convergence rate must +reproduce. +""" +from __future__ import annotations + +import math + +import numpy as np + + +def poisson_rhs(n, rng=None): + """A right-hand side on an n x n interior grid.""" + if rng is None: + rng = np.random.default_rng(0) + return rng.standard_normal((n, n)) + + +def sweep_gs(u, f, h2, omega, coeff=None): + """One Gauss-Seidel / SOR sweep in place, returning the correction. + + coeff is None for the 5-point Laplacian; otherwise (cw, ce, cs, cn, cc) + arrays giving a variable-coefficient or anisotropic stencil. + """ + n = u.shape[0] + before = u.copy() + if coeff is None: + for i in range(n): + for j in range(n): + s = 0.0 + if i > 0: + s += u[i - 1, j] + if i < n - 1: + s += u[i + 1, j] + if j > 0: + s += u[i, j - 1] + if j < n - 1: + s += u[i, j + 1] + new = (s - h2 * f[i, j]) / 4.0 + u[i, j] += omega * (new - u[i, j]) + else: + cw, ce, cs, cn, cc = coeff + for i in range(n): + for j in range(n): + s = 0.0 + if i > 0: + s += cw[i, j] * u[i - 1, j] + if i < n - 1: + s += ce[i, j] * u[i + 1, j] + if j > 0: + s += cs[i, j] * u[i, j - 1] + if j < n - 1: + s += cn[i, j] * u[i, j + 1] + new = (s - h2 * f[i, j]) / cc[i, j] + u[i, j] += omega * (new - u[i, j]) + return u - before + + +def residual(u, f, h2, coeff=None): + n = u.shape[0] + r = np.zeros_like(u) + if coeff is None: + for i in range(n): + for j in range(n): + s = -4.0 * u[i, j] + if i > 0: + s += u[i - 1, j] + if i < n - 1: + s += u[i + 1, j] + if j > 0: + s += u[i, j - 1] + if j < n - 1: + s += u[i, j + 1] + r[i, j] = h2 * f[i, j] - s + else: + cw, ce, cs, cn, cc = coeff + for i in range(n): + for j in range(n): + s = -cc[i, j] * u[i, j] + if i > 0: + s += cw[i, j] * u[i - 1, j] + if i < n - 1: + s += ce[i, j] * u[i + 1, j] + if j > 0: + s += cs[i, j] * u[i, j - 1] + if j < n - 1: + s += cn[i, j] * u[i, j + 1] + r[i, j] = h2 * f[i, j] - s + return r + + +class Fixed: + def __init__(self, omega): + self.omega = omega + self.name = f"omega = {omega:g}" + self.constants = 1 + + def reset(self): + pass + + def next_omega(self, d_prev, d_now): + return self.omega + + +class OptimalPoisson(Fixed): + """The closed-form optimum for the model problem - an oracle that needs no + tuning because the answer is a theorem.""" + + def __init__(self, n): + w = 2.0 / (1.0 + math.sin(math.pi / (n + 1))) + super().__init__(w) + self.name = f"omega* = {w:.4f} (theory)" + + +class SimilarityOmega: + """omega = 1 + max(0, cos(d_k, d_{k-1})). + + The first sweep has no predecessor to compare with, so it runs at + Gauss-Seidel - the same licence granted in the root-finding safeguard. + """ + + name = "similarity (no constants)" + constants = 0 + + def reset(self): + pass + + def next_omega(self, d_prev, d_now): + if d_prev is None or d_now is None: + return 1.0 + a = float(np.vdot(d_prev, d_now)) + na = float(np.linalg.norm(d_prev)) * float(np.linalg.norm(d_now)) + if na <= 0.0 or not math.isfinite(na): + return 1.0 + return 1.0 + max(0.0, a / na) + + +class ContractionOmega: + """omega driven by the contraction the iteration actually achieves. + + The direction-similarity rule above over-relaxes: the cosine between + successive SOR corrections sits near 1 almost always, so 1 + cos saturates + at 2. Measured, it picks 1.87 where the optimum is 1.777 and 1.43 where + it is 1.2. The measure was right and the map into omega was not. + + The map that is derived rather than chosen comes from the theory itself: + for omega >= omega* the SOR spectral radius is exactly omega - 1. So the + observed contraction of the residual, rho = ||r_k|| / ||r_{k-1}||, says on + which side of the optimum the iteration is sitting: + + rho > omega - 1 -> below the optimum, lengthen + rho ~ omega - 1 -> at or above it, hold + + and the correction is the discrepancy itself, + + omega <- omega + (rho - (omega - 1)), clipped to [1, 2). + + The clip is the convergence condition of the method, not a tuning range, + and the first sweep runs at omega = 1 for want of a previous residual. + + REFUTED, and worse than the rule it was meant to repair. Measured: 235 + sweeps against the direction rule's 107 on the model problem, 589 against + 102 on the anisotropic one. The update is undamped, so on the first + sweep, with omega = 1 and rho near 1, it sets omega = 1 + (1 - 0) = 2 and + stays pinned at the limit. Damping it would take a constant, which is the + thing the exercise is trying to avoid, so the line stops here rather than + trying a third map. + """ + + name = "contraction-driven (no constants)" + constants = 0 + + def reset(self): + self.omega = 1.0 + self.r_prev = None + + def next_omega(self, d_prev, d_now): + return self.omega + + def note_residual(self, rn): + if self.r_prev is not None and self.r_prev > 0.0: + rho = rn / self.r_prev + if math.isfinite(rho): + w = self.omega + (rho - (self.omega - 1.0)) + # 2 is the convergence limit of SOR, 1 is Gauss-Seidel + self.omega = min(1.999, max(1.0, w)) + self.r_prev = rn + + +def solve(f, rule, tol=1e-8, maxit=20000, coeff=None): + """Iterate to ||r|| <= tol * ||r_0||. Cost is sweeps, which is what a + practitioner pays. Everything except `rule` is shared.""" + n = f.shape[0] + h2 = 1.0 / (n + 1) ** 2 + u = np.zeros_like(f) + r0 = float(np.linalg.norm(residual(u, f, h2, coeff))) + if r0 == 0.0: + return 0, 0.0 + rule.reset() + d1 = d2 = None # the two most recent corrections, newest first + omegas = [] + for k in range(1, maxit + 1): + # the rule sees the last two corrections; on the first two sweeps one + # of them does not exist yet and the rule returns 1 (Gauss-Seidel) + omega = rule.next_omega(d2, d1) + omegas.append(omega) + d1, d2 = sweep_gs(u, f, h2, omega, coeff), d1 + rn = float(np.linalg.norm(residual(u, f, h2, coeff))) + if hasattr(rule, "note_residual"): + rule.note_residual(rn) + if not math.isfinite(rn): + return maxit, float("nan") + if rn <= tol * r0: + return k, float(np.mean(omegas)) + return maxit, float(np.mean(omegas)) diff --git a/report_sweep.py b/report_sweep.py new file mode 100644 index 0000000..81b9ce9 --- /dev/null +++ b/report_sweep.py @@ -0,0 +1,165 @@ +"""Read sweep_full.json and answer the questions the paper needs answered. + +Everything printed here comes from the single server run; no number is +recomputed on a different machine. (The test functions use libm, whose last +digit differs between Windows and Linux, so mixing platforms would move +evaluation counts by a unit or two - measured: scipy's toms748 scores 2819 on +Windows and 2820 on Linux for the same set.) +""" +from __future__ import annotations + +import json +import sys + +BASE = {"bisection", "regula_falsi", "illinois", "pegasus", "anderson_bjorck", + "ridders", "brent", "toms748", "itp", "itp_oracle"} + +# The configuration the paper proposes. It is not the winner of a search over +# the grid - it is what the theory of section 2 dictates, fixed before the +# ranking is looked at: +# similarity a nonzero slope of (1 - S) at 0 -> the ratio form 1 - |z| +# scale the finest data-derived one -> the three-point difference +# safeguard the one that carries a bound without destroying the order +# AND without a free constant -> the credit projection, whose +# endowment is a licence of one unconstrained step rather than +# a number (see simroot.pure.project_credit) +# The grid is evidence for the theory, not the method's selection procedure. +PROPOSED = "pure.ratio.derived3.credit" +TUNED = {"illinois", "pegasus", "anderson_bjorck", "brent", "toms748", + "itp", "itp_oracle"} + + +def load(path="sweep_full.json"): + with open(path, encoding="utf8") as fh: + return json.load(fh) + + +def rank(rows, setname): + return sorted(rows, key=lambda r: (r[setname]["n"] - r[setname]["solved"], + r[setname]["total"])) + + +def place(rows, setname, lbl): + for i, r in enumerate(rank(rows, setname), 1): + if r["label"] == lbl: + return i + raise KeyError(f"no configuration labelled {lbl!r} in the sweep; " + "a mistyped name must not be reported as a missing place") + + +def best_pure(rows, setname): + """The best configuration OF OURS. The overall winner of a set may be a + baseline - itp_oracle tops Chandrupatla - and comparing that against + itself prints nothing of interest.""" + for r in rank(rows, setname): + if r["label"].startswith("pure."): + return r["label"] + raise KeyError("no pure configuration in the sweep") + + +def head_to_head(rows, a, b, setname): + ra = next(r for r in rows if r["label"] == a)[setname] + rb = next(r for r in rows if r["label"] == b)[setname] + win = tie = loss = both = 0 + for pid, (na, oka) in ra["per"].items(): + nb, okb = rb["per"][pid] + if not (oka and okb): + continue + both += 1 + if na < nb: + win += 1 + elif na > nb: + loss += 1 + else: + tie += 1 + return win, tie, loss, both + + +def main(): + rows = load(sys.argv[1] if len(sys.argv) > 1 else "sweep_full.json") + print(f"{len(rows)} configurations\n") + + for setname in ("APS", "CHA"): + r = rank(rows, setname) + n = r[0][setname]["n"] + print("=" * 90) + print(f"{setname} ({n} problems) top 12, with the best baseline " + f"positions marked") + print("=" * 90) + print(f"{'#':>3s} {'configuration':38s}{'tuning':>8s}{'solved':>9s}" + f"{'total':>9s}{'over 2x':>9s}") + print("-" * 90) + for i, row in enumerate(r[:12], 1): + d = row[setname] + tuned = "yes" if row["label"] in TUNED else "no" + star = " <-" if row["label"] not in BASE else "" + print(f"{i:>3d} {row['label']:38s}{tuned:>8s}" + f"{d['solved']:>6d}/{d['n']:<3d}{d['total']:>9d}" + f"{d['over']:>9d}{star}") + print() + for b in ("brent", "toms748", "itp", "itp_oracle", "bisection"): + p = place(rows, setname, b) + d = next(x for x in rows if x["label"] == b)[setname] + print(f" {b:38s}place {p:>3d} total {d['total']}") + print() + + print("=" * 90) + print(f"THE PROPOSED CONFIGURATION {PROPOSED}") + print(" (dictated by the theory, not selected from the ranking)") + print("=" * 90) + for setname in ("APS", "CHA"): + d = next(r for r in rows if r["label"] == PROPOSED)[setname] + print(f" {setname}: place {place(rows, setname, PROPOSED):>3d} of " + f"{len(rows)} solved {d['solved']}/{d['n']} " + f"total {d['total']} over 2x bound {d['over']}") + for opp in ("brent", "toms748", "itp", "itp_oracle", "bisection"): + w, t, l, both = head_to_head(rows, PROPOSED, opp, setname) + print(f" vs {opp:12s}: {w} wins / {t} ties / {l} losses " + f"(of {both})") + print() + + print("=" * 90) + print("HEAD TO HEAD, best pure configuration of each set") + print("=" * 90) + for setname in ("APS", "CHA"): + best = best_pure(rows, setname) + for opp in ("brent", "toms748", "itp", "itp_oracle"): + w, t, l, both = head_to_head(rows, best, opp, setname) + print(f"{setname} {best} vs {opp:12s}: " + f"{w} wins / {t} ties / {l} losses (of {both})") + print() + + print("=" * 90) + print("BEST CONFIGURATION THAT CARRIES THE PROVEN 2x BOUND") + print("=" * 90) + for setname in ("APS", "CHA"): + sound = [x for x in rank(rows, setname) + if x["label"].startswith("pure.") + and x["label"].rsplit(".", 1)[1] in ("bracket", "both")] + b = sound[0] + print(f"{setname}: {b['label']:38s} total {b[setname]['total']:>7d}" + f" place {place(rows, setname, b['label'])}") + + print("\n" + "=" * 90) + print("WHICH SIMILARITY, WHICH SCALE (guard = step, both sets summed)") + print("=" * 90) + sims, scales = {}, {} + for row in rows: + if not row["label"].startswith("pure."): + continue + _, sim, scale, guard = row["label"].split(".") + if guard != "step": + continue + tot = row["APS"]["total"] + row["CHA"]["total"] + sims.setdefault(sim, []).append(tot) + scales.setdefault(scale, []).append(tot) + print("similarity (best over scales):") + for sim, v in sorted(sims.items(), key=lambda kv: min(kv[1])): + print(f" {sim:12s} best {min(v):>7d} worst {max(v):>7d}") + print("scale (best over similarities):") + for sc, v in sorted(scales.items(), key=lambda kv: min(kv[1])): + print(f" {sc:12s} best {min(v):>7d} worst {max(v):>7d}") + + +if __name__ == "__main__": + main() diff --git a/simroot/__init__.py b/simroot/__init__.py new file mode 100644 index 0000000..afb1389 --- /dev/null +++ b/simroot/__init__.py @@ -0,0 +1,6 @@ +from .baselines import BASELINES +from .pure import GUARDS, PURE_SIMS, pure_root +from .sim import SIMILARITIES, sim_root + +__all__ = ["BASELINES", "GUARDS", "PURE_SIMS", "SIMILARITIES", "pure_root", + "sim_root"] diff --git a/simroot/baselines.py b/simroot/baselines.py new file mode 100644 index 0000000..a388cee --- /dev/null +++ b/simroot/baselines.py @@ -0,0 +1,489 @@ +"""Classical and state-of-the-art bracketing root finders, all with a common +signature and a shared function-evaluation counter. + +Every method returns (x, nfev, converged). + +Included: + bisection - the null model + regula_falsi - the raw "step proportional to dissimilarity" rule + illinois - Hafner/Dowell 1971 stalling fix (halve the stale end) + pegasus - Dowell & Jarratt 1972 + anderson_bjorck - Anderson & Bjorck 1973 + ridders - Ridders 1979 + brent - Brent 1973 (own implementation, verified vs scipy) + toms748 - Alefeld, Potra & Shi 1995 (via scipy) + itp - Oliveira & Takahashi, ACM TOMS 2021 (own implementation) + +The ITP method is the current state of the art for bracketed root finding: +superlinear average performance with a worst case that is provably no worse +than bisection. Note that it carries THREE tuning parameters (kappa1, kappa2, +n0); the authors' recommended defaults are used here and are reported as such. +""" +from __future__ import annotations + +import math + +from scipy.optimize import toms748 as _scipy_toms748 + + +class Counter: + """Counts calls to f and caches nothing (evaluations are the cost model).""" + + __slots__ = ("f", "n", "limit") + + def __init__(self, f, limit): + self.f = f + self.n = 0 + self.limit = limit + + def __call__(self, x): + if self.n >= self.limit: + raise _Budget() + self.n += 1 + return self.f(x) + + +class _Budget(Exception): + pass + + +def _converged(a, b, xtol): + return abs(b - a) <= xtol + + +# -------------------------------------------------------------------------- +# null model +# -------------------------------------------------------------------------- +def bisection(f, a, b, xtol, maxfev): + g = Counter(f, maxfev) + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + x = 0.5 * (a + b) + while not _converged(a, b, xtol): + x = 0.5 * (a + b) + fx = g(x) + if fx == 0.0: + return x, g.n, True + if fa * fx < 0.0: + b, fb = x, fx + else: + a, fa = x, fx + return 0.5 * (a + b), g.n, True + except _Budget: + return 0.5 * (a + b), g.n, False + + +# -------------------------------------------------------------------------- +# the false-position family (all are "similarity-proportional steps" with +# different stale-endpoint corrections) +# -------------------------------------------------------------------------- +def _false_position_family(f, a, b, xtol, maxfev, correction): + g = Counter(f, maxfev) + x = 0.5 * (a + b) # defined before the first evaluation: a budget that + # runs out on f(a) must give an honest failure, not + # an UnboundLocalError + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + while not _converged(a, b, xtol): + denom = fb - fa + if denom == 0.0: + x = 0.5 * (a + b) + else: + x = (a * fb - b * fa) / denom + lo, hi = (a, b) if a < b else (b, a) + if not (lo < x < hi) or not math.isfinite(x): + x = 0.5 * (a + b) + fx = g(x) + if fx == 0.0: + return x, g.n, True + if fa * fx < 0.0: + # b replaced; a became stale -> correct fa + fa = correction(fa, fb, fx) + b, fb = x, fx + else: + fb = correction(fb, fa, fx) + a, fa = x, fx + return 0.5 * (a + b), g.n, True + except _Budget: + return x, g.n, False + + +def regula_falsi(f, a, b, xtol, maxfev): + return _false_position_family(f, a, b, xtol, maxfev, + lambda f_stale, f_moved, fx: f_stale) + + +def illinois(f, a, b, xtol, maxfev): + return _false_position_family(f, a, b, xtol, maxfev, + lambda f_stale, f_moved, fx: 0.5 * f_stale) + + +def pegasus(f, a, b, xtol, maxfev): + return _false_position_family( + f, a, b, xtol, maxfev, + lambda f_stale, f_moved, fx: f_stale * f_moved / (f_moved + fx)) + + +def _ab_corr(f_stale, f_moved, fx): + m = 1.0 - fx / f_moved + if m <= 0.0: + m = 0.5 + return f_stale * m + + +def anderson_bjorck(f, a, b, xtol, maxfev): + return _false_position_family(f, a, b, xtol, maxfev, _ab_corr) + + +# -------------------------------------------------------------------------- +# Ridders 1979 +# -------------------------------------------------------------------------- +def ridders(f, a, b, xtol, maxfev): + g = Counter(f, maxfev) + x = 0.5 * (a + b) + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + while not _converged(a, b, xtol): + c = 0.5 * (a + b) + fc = g(c) + if fc == 0.0: + return c, g.n, True + d = fc * fc - fa * fb + if d <= 0.0: + x = c + else: + s = math.sqrt(d) + x = c + (c - a) * (math.copysign(1.0, fa - fb) * fc) / s + fx = g(x) + if fx == 0.0: + return x, g.n, True + # rebuild the tightest bracket among a, c, x, b + if fc * fx < 0.0: + a, fa, b, fb = (c, fc, x, fx) if c < x else (x, fx, c, fc) + elif fa * fx < 0.0: + b, fb = x, fx + else: + a, fa = x, fx + return 0.5 * (a + b), g.n, True + except _Budget: + return x, g.n, False + + +# -------------------------------------------------------------------------- +# Brent 1973 +# -------------------------------------------------------------------------- +def brent(f, a, b, xtol, maxfev, stats=None): + """stats: optional dict; on return it carries 'bisect' = how many of the + steps taken were Brent's midpoint fallback rather than an interpolation. + Used to explain, rather than assert, where the evaluations went.""" + g = Counter(f, maxfev) + n_bisect = 0 + b_ = b + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + if stats is not None: + stats['bisect'] = 0 + c, fc = a, fa + d = e = b - a + while True: + if fb * fc > 0.0: + c, fc = a, fa + d = e = b - a + if abs(fc) < abs(fb): + a, fa = b, fb + b, fb = c, fc + c, fc = a, fa + tol1 = 2.0 * 2.22e-16 * abs(b) + 0.5 * xtol + xm = 0.5 * (c - b) + if abs(xm) <= tol1 or fb == 0.0: + if stats is not None: + stats['bisect'] = n_bisect + return b, g.n, True + if abs(e) >= tol1 and abs(fa) > abs(fb): + s = fb / fa + if a == c: + p = 2.0 * xm * s + q = 1.0 - s + else: + q = fa / fc + r = fb / fc + p = s * (2.0 * xm * q * (q - r) - (b - a) * (r - 1.0)) + q = (q - 1.0) * (r - 1.0) * (s - 1.0) + if p > 0.0: + q = -q + p = abs(p) + if 2.0 * p < min(3.0 * xm * q - abs(tol1 * q), abs(e * q)): + e = d + d = p / q + else: + d = xm + e = d + n_bisect += 1 + else: + d = xm + e = d + n_bisect += 1 + a, fa = b, fb + b = b + (d if abs(d) > tol1 else math.copysign(tol1, xm)) + b_ = b + fb = g(b) + except _Budget: + if stats is not None: + stats['bisect'] = n_bisect + return b_, g.n, False + + +# -------------------------------------------------------------------------- +# TOMS 748 (Alefeld, Potra & Shi 1995) - via scipy, counted by the wrapper +# -------------------------------------------------------------------------- +def toms748(f, a, b, xtol, maxfev): + g = Counter(f, maxfev) + try: + x, r = _scipy_toms748(g, a, b, xtol=xtol, rtol=8.9e-16, + maxiter=maxfev, full_output=True, disp=False) + return x, g.n, bool(r.converged) + except _Budget: + return 0.5 * (a + b), g.n, False + except Exception: + return 0.5 * (a + b), g.n, False + + +# -------------------------------------------------------------------------- +# ITP - Oliveira & Takahashi, ACM TOMS 47(1), 2021 +# Three tuning parameters, authors' recommended defaults. +# -------------------------------------------------------------------------- +def itp(f, a, b, xtol, maxfev, kappa1=None, kappa2=2.0, n0=1): + """ITP is natively written against a half-width epsilon: it terminates on + (b - a) <= 2*eps. Every other method here terminates on (b - a) <= xtol. + Feeding xtol straight in as eps would let ITP stop at twice the bracket + width of its competitors and win the benchmark on the stopping rule rather + than on the search. eps = xtol/2 is therefore used, which makes the final + bracket identical across all methods. Requires a < b.""" + if not a < b: + raise ValueError("itp requires a < b") + g = Counter(f, maxfev) + x = 0.5 * (a + b) + eps = 0.5 * xtol + try: + if kappa1 is None: + kappa1 = 0.2 / (b - a) + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + n_half = math.ceil(math.log2((b - a) / (2.0 * eps))) if b - a > 2 * eps else 0 + n_max = n_half + n0 + j = 0 + while (b - a) > 2.0 * eps: + # interpolation (regula falsi) + x_f = (b * fa - a * fb) / (fa - fb) + # truncation + x_half = 0.5 * (a + b) + sigma = math.copysign(1.0, x_half - x_f) + delta = kappa1 * (b - a) ** kappa2 + x_t = x_f + sigma * delta if delta <= abs(x_half - x_f) else x_half + # projection + r = 2.0 ** (n_max - j) * eps - 0.5 * (b - a) + x = x_t if abs(x_t - x_half) <= r else x_half - sigma * r + fx = g(x) + if fx == 0.0: + return x, g.n, True + if fx * fa < 0.0: + b, fb = x, fx + else: + a, fa = x, fx + j += 1 + return 0.5 * (a + b), g.n, True + except _Budget: + return x, g.n, False + + +# -------------------------------------------------------------------------- +# Chandrupatla 1997 - the hybrid quadratic/bisection method. It owns one of +# the two benchmark sets used here and is the closest relative of the proposed +# rule, so its absence from the comparison would be the first thing a reader +# asked about. +# -------------------------------------------------------------------------- +def chandrupatla(f, a, b, xtol, maxfev): + g = Counter(f, maxfev) + x1, x2 = b, a + # defined before the first evaluation: a budget exhausted on f(b) must be + # an honest failure, not an UnboundLocalError in the handler + f1 = f2 = 0.0 + try: + f1, f2 = g(x1), g(x2) + if f1 == 0.0: + return x1, g.n, True + if f2 == 0.0: + return x2, g.n, True + x3, f3 = x2, f2 + t = 0.5 + while True: + x = x1 + t * (x2 - x1) + fx = g(x) + if (fx > 0.0) == (f1 > 0.0): + x3, f3 = x1, f1 + x1, f1 = x, fx + else: + x3, f3 = x2, f2 + x2, f2 = x1, f1 + x1, f1 = x, fx + xm, fm = (x1, f1) if abs(f1) < abs(f2) else (x2, f2) + if fm == 0.0: + return xm, g.n, True + tol = 2.0 * 2.22e-16 * abs(xm) + xtol + span = abs(x2 - x1) + if span == 0.0: + return xm, g.n, True + tl = tol / span + if tl > 0.5: + return xm, g.n, True + # accept inverse quadratic interpolation only inside the region + # where Chandrupatla shows it is safe + t = 0.5 + if x3 != x2 and f3 != f2: + xi = (x1 - x2) / (x3 - x2) + ph = (f1 - f2) / (f3 - f2) + if 0.0 < xi < 1.0 and 1.0 - math.sqrt(1.0 - xi) < ph < math.sqrt(xi): + d1, d2, d3 = f1 - f2, f1 - f3, f2 - f3 + if d1 != 0.0 and d2 != 0.0 and d3 != 0.0: + t = (f1 / d1) * (f3 / (-d3)) + \ + ((x3 - x1) / (x2 - x1)) * (f1 / d2) * (f2 / d3) + if not math.isfinite(t): + t = 0.5 + t = min(max(t, tl), 1.0 - tl) + except _Budget: + return (x1 if abs(f1) < abs(f2) else x2), g.n, False + + +# -------------------------------------------------------------------------- +# Dekker 1969 - secant with a bisection fallback, the direct ancestor of Brent +# -------------------------------------------------------------------------- +def dekker(f, a, b, xtol, maxfev): + g = Counter(f, maxfev) + bb = b + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + if abs(fa) < abs(fb): + a, b, fa, fb = b, a, fb, fa + c, fc = a, fa + while abs(b - c) > xtol: + m = 0.5 * (c + b) + if fb != fa: + s = b - fb * (b - a) / (fb - fa) + else: + s = m + lo, hi = (b, m) if b < m else (m, b) + bnew = s if lo < s < hi else m + a, fa = b, fb + b = bnew + bb = b + fb = g(b) + if (fb > 0.0) == (fc > 0.0): + c, fc = a, fa + if abs(fc) < abs(fb): + b, c = c, b + fb, fc = fc, fb + if fb == 0.0: + return b, g.n, True + return b, g.n, True + except _Budget: + return bb, g.n, False + + +# -------------------------------------------------------------------------- +# Library implementations. Where SciPy ships the method, its implementation +# is the one a reader can check and the one a user would actually run, so it +# belongs in the comparison. Ours are kept beside them for two reasons: the +# timing section needs pure Python throughout, and a competitor is entitled to +# the better of the two counts (see `best_of` below). +# +# Measured difference on the 199 problems: brentq 7004 against our 6991, +# _chandrupatla 5228 against our 5209 - that is, OUR versions are slightly +# cheaper, so taking the library number alone would flatter us. +# -------------------------------------------------------------------------- +def brent_scipy(f, a, b, xtol, maxfev): + from scipy.optimize import brentq + g = Counter(f, maxfev) + try: + x = brentq(g, a, b, xtol=xtol, rtol=8.9e-16, maxiter=maxfev) + return x, g.n, True + except _Budget: + return 0.5 * (a + b), g.n, False + except Exception: + return 0.5 * (a + b), g.n, False + + +def chandrupatla_scipy(f, a, b, xtol, maxfev): + import numpy as np + from scipy.optimize._chandrupatla import _chandrupatla + g = Counter(f, maxfev) + + def vec(x): + return np.asarray([g(float(xi)) for xi in np.atleast_1d(x)]).reshape( + np.shape(x)) + + try: + res = _chandrupatla(vec, a, b, xatol=xtol, xrtol=8.9e-16, + fatol=0.0, frtol=0.0, maxiter=maxfev) + return (float(np.asarray(res.x).ravel()[0]), g.n, + bool(np.all(np.asarray(res.success)))) + except _Budget: + return 0.5 * (a + b), g.n, False + except Exception: + return 0.5 * (a + b), g.n, False + + +def best_of(*methods): + """Give the competitor the cheaper of its implementations on every + problem. The same concession the paper already makes to ITP by reporting + a per-problem oracle over its constants.""" + def run(f, a, b, xtol, maxfev): + best = None + for m in methods: + try: + x, n, conv = m(f, a, b, xtol, maxfev) + except Exception: + continue + if conv and (best is None or n < best[1]): + best = (x, n, True) + return best if best is not None else (0.5 * (a + b), maxfev, False) + return run + + +BASELINES = { + "chandrupatla": chandrupatla, + "chandrupatla_scipy": chandrupatla_scipy, + "brent_scipy": brent_scipy, + "dekker": dekker, + "bisection": bisection, + "regula_falsi": regula_falsi, + "illinois": illinois, + "pegasus": pegasus, + "anderson_bjorck": anderson_bjorck, + "ridders": ridders, + "brent": brent, + "toms748": toms748, + "itp": itp, +} diff --git a/simroot/pure.py b/simroot/pure.py new file mode 100644 index 0000000..04656f7 --- /dev/null +++ b/simroot/pure.py @@ -0,0 +1,593 @@ +"""The pure similarity root finder: one similarity function, one step rule. + + direction : the side of the bracket that contains the sign change + length : (1 - S(z)) * (distance to the far end), z = f(x) / scale + +Everything about the method is in S and in where `scale` comes from. + + scale CHOSEN (a fixed reference value) -> linear convergence at a rate + that is a property of the problem, not of the method, and + therefore fails on some problems (stage 0b, 5-8 of 8) + scale DERIVED (the local slope of f, read off the two most recent + evaluations) -> the step becomes |f|/|f'| and + the convergence is superlinear (stage 0d/0e) + +The derivation, from the contraction law measured in stage 0c: + + e_{n+1} = e_n * |1 - c*|f'(r)|*D/scale| , c = slope of (1 - S) at 0 + rate = 0 <=> c = scale / (|f'(r)|*D) + +so the one quantity the pure rule needs is the LOCAL SCALE OF THE VALUE AXIS. +Choosing it is what makes the method brittle; reading it off the data is what +makes it parameter free - the same move the SIM control paper makes when it +normalises the input space from the data instead of choosing membership +widths by hand. + +Safeguards +---------- +An interpolation-only rule has no worst-case bound. Two parameter-free +safeguards are provided and are measured against each other: + + "bracket" bisect whenever a similarity step failed to halve the BRACKET. + Sound, but expensive: a secant step routinely collapses the + error while barely moving the proven bracket, so the guard + fires on steps that were in fact excellent (measured: 150 vs + 86 evaluations over the stage-0 problem set). + + "step" bisect whenever the proposed step is not at most half the step + taken two evaluations ago. Step lengths are then forced to + decrease geometrically, and a converging secant sequence - + whose steps shrink far faster than by half - never triggers + it. This is the criterion Brent's method uses internally, + stated without his tuning constants. + + It does NOT on its own bound the worst case, and an earlier + version of this docstring claimed that it did. A sequence + that creeps towards a non-root from one side with steps that + halve every time has small steps by construction, so the guard + stays silent, the sign never changes, and the proven bracket + never moves. Cheap, but not sound alone. + + "both" the step guard, with the bracket guard underneath it as the + backstop that actually carries the worst-case bound. The step + guard does the work on ordinary problems, so the bracket guard + almost never fires and almost never costs anything. + + "project" do not REPLACE the similarity step at all - PROJECT it onto the + largest interval still consistent with the bisection bound: + + allowed_j = 2^(n_max - j) * (xtol/2) + x = clamp(x_sim, hi - allowed_j, lo + allowed_j) + + with n_max = 2*ceil(log2(w0 / xtol)) fixed by the initial + bracket. The next bracket is at most max(x - lo, hi - x), so + the clamp gives w_{j+1} <= allowed_j directly, and induction + bounds the run by n_max steps in exact arithmetic - one more + when the bracket lands exactly on the boundary in floating + point. The guarantee is therefore + 2*ceil(log2(w0/xtol)) + 3 evaluations: twice bisection plus + one step. + + Zero slack (n_max = ceil(log2(w0/xtol)), a worst case of + exactly bisection) is degenerate and was measured as such: it + demands a halving at every single step, leaving the projection + no freedom, and the guard behaves as bisection. + + The three guards above discard a computed step; this one keeps + as much of it as the bound allows, which is why it does not + flatten the order. The construction is ITP's projection + stage. ITP's three constants (kappa1, kappa2, n0) all live in + its TRUNCATION stage, which exists to repair regula falsi; + the similarity step needs no repair, so the truncation - and + with it every constant - is dropped. + + "safe" the step guard for cheapness, with the projection carrying the + bound. This is the configuration the paper proposes: a proven + worst case AND the full order, which the three earlier guards + could not deliver together. + +The only constant in any of them is 1/2, which is the definition of bisection +rather than a tuned value. +""" +from __future__ import annotations + +import math + +from .baselines import Counter, _Budget + +# -------------------------------------------------------------------------- +# [0,1] similarity functions of a normalised residual z: S(0) = 1 (identical +# to the expectation), S -> 0 far from it. +# -------------------------------------------------------------------------- +PURE_SIMS = { + # the ratio form S = 1 - |f|/scale. Note that the symmetric ratio + # min(|x|,|y|)/max(|x|,|y|) is identically 0 when one argument is the + # target, so this is the only usable reading of "ratio similarity to 0". + "ratio": lambda z: max(0.0, 1.0 - abs(z)), + "sqrt": lambda z: max(0.0, 1.0 - math.sqrt(abs(z))), + "cbrt": lambda z: max(0.0, 1.0 - abs(z) ** (1.0 / 3.0)), + "rational": lambda z: 1.0 / (1.0 + abs(z)), + "ratio_soft": lambda z: 1.0 / (1.0 + abs(z)) ** 2, + "exp_abs": lambda z: math.exp(-abs(z)), + # similarities that approach 1 quadratically: c = 0, predicted rate 1, + # kept because the law has to be falsifiable in both directions + "rat_sq": lambda z: 1.0 / (1.0 + z * z), + "exp_sq": lambda z: math.exp(-z * z), + "cosine": lambda z: 1.0 / math.sqrt(1.0 + z * z), +} + +GUARDS = ("none", "bracket", "step", "both", "project", "safe", "credit") + + +class _Safeguard: + """Parameter-free worst-case protection. See the module docstring.""" + + __slots__ = ("mode", "guard_width", "pending", "step_2", "step_1", + "n_half", "eps", "j", "allow", "credit") + + def __init__(self, mode, width, xtol=None, budget_factor=2.0, + budget_extra=None): + if mode not in GUARDS: + raise ValueError(f"unknown guard {mode!r}, expected one of {GUARDS}") + self.mode = mode + self.guard_width = width + self.pending = False + self.step_2 = width # step two evaluations ago + self.step_1 = width # step one evaluation ago + # projection state: the bisection budget, fixed by the initial bracket + self.eps = 0.5 * xtol if xtol else 0.0 + self.j = 0 + # set for every mode: the step loop decrements it unconditionally, and + # leaving it to the projection branch made every other guard raise + self.allow = 0.0 + self.n_half = 0 + self.credit = 1.0 # one bit of endowment; see project_credit + if mode in ("project", "safe"): + if not xtol or width <= 0.0: + raise ValueError("the projection guard needs xtol and a " + "positive initial width") + half = math.ceil(math.log2(width / xtol)) if width > xtol else 0 + # The budget is TWICE the bisection budget. Zero slack (budget = + # half) is degenerate: a worst case of exactly bisection demands a + # halving at every single step, so the projection leaves no + # freedom at all - measured, r_0 was 0.05 of a unit bracket and + # the guard behaved as bisection. Doubling is not a tuned + # constant: it is the same factor 2 already claimed as the bound, + # and it buys total freedom until the budget is nearly spent. + # Two ways to give the projection room, and the difference + # matters for whether this method contains a constant at all. + # + # budget_extra = k -> n_max = half + k. The requirement is + # only r_0 >= 0, i.e. n_max >= half; at n_max = half there + # is no room and the guard degenerates to bisection. The + # MINIMAL non-degenerate choice is therefore k = 1 - not a + # tuned value but the smallest integer for which the + # construction works at all. + # budget_factor = c -> n_max = ceil(c * half). This is what + # the paper used, at c = 2, and the justification given for + # it ("the factor already in the bound") was circular: the + # bound is 2x because 2 was chosen. Kept as an ablation + # knob so the circularity can be measured rather than + # argued about. + if budget_extra is not None: + self.n_half = half + int(budget_extra) + else: + self.n_half = max(half, int(math.ceil(budget_factor * half))) + # The allowance 2^(n_max - j).eps is halved once per step, so it + # is carried forward rather than recomputed: an exponentiation in + # the inner loop was costing more than the projection itself. + # Halving is exact in binary floating point, so this changes no + # iterate and no evaluation count - only the arithmetic. + try: + self.allow = 2.0 ** self.n_half * self.eps + except OverflowError: + self.allow = math.inf + + def project_credit(self, x_sim, lo, hi): + """The projection with the budget EARNED rather than scheduled. + + The scheduled version fixes the allowance in advance from the initial + width, so the multiplier in n_max = c*half is a free constant, and the + argument that c = 2 is "the factor already in the bound" is circular: + the bound is 2x because 2 was chosen. Measured, c = 1.25 is 8% + better, so the constant is not neutral either. + + Here the method pays its own way. Let s_j = log2(w_j / w_{j+1}) be + the shrink a step delivers in bits; bisection delivers exactly 1. Keep + + C <- C + s_j - 1, C >= 0, + + the surplus banked so far, and allow a step to under-deliver only by + what has been banked: the width after the step may be at most + 2^(C-1) * w. Since C never goes negative, the shrinks over j steps + sum to at least j - C_0, so the run costs at most half + C_0 steps. + + C_0 = 1 - one bit of endowment - is the smallest integer for which the + rule is not degenerate: at C_0 = 0 the allowance is exactly w/2 on the + first step, which forces the midpoint and makes the method bisection. + So the guarantee is bisection plus one step, and the constant is the + promise, not a tuning knob. + """ + w = hi - lo + # The allowance is w * 2^(C-1), so it exceeds w exactly when C >= 1, + # and then it restricts nothing. Testing that FIRST removes the + # exponentiation from the common path and, more importantly, removes + # a crash: C accumulates the log of every shrink and is unbounded, so + # 2**(C-1) overflows a double at C ~ 1025. That is reachable - sixty + # nine-decade steps reach C = 1012, and a bracket of width 1e300 with + # a tolerance of 1e-8 has about 1023 bits of shrink available - and + # the OverflowError would escape, since only the budget exception is + # caught here. + if self.credit >= 1.0: + return x_sim + allowed = w * (2.0 ** (self.credit - 1.0)) + left, right = hi - allowed, lo + allowed + if left > right: + return 0.5 * (lo + hi) + return min(max(x_sim, left), right) + + def note_shrink(self, w_before, w_after): + """Bank what the step delivered beyond a halving, or draw on the bank + for what it fell short.""" + if w_before <= 0.0 or w_after <= 0.0: + return + s = math.log2(w_before / w_after) + self.credit = max(0.0, self.credit + s - 1.0) + + def project(self, x_sim, lo, hi): + """Pull the similarity step back to the edge of the interval that the + bisection budget still allows. Returns the admissible iterate. + + The budget says the next bracket may be at most + `allowed = 2^(n_max - j) * eps`. Whichever side the sign change turns + out to be on, that bracket is at most max(x - lo, hi - x), so the + admissible set is exactly + + [hi - allowed, lo + allowed]. + + Writing it this way rather than as a radius r = allowed - (hi-lo)/2 + around the midpoint matters numerically: r is the difference of two + nearly equal numbers, and the cancellation made the computed radius + slightly too large. Measured, that admitted points which broke the + invariant by a relative 8.9e-5 and cost exactly one extra evaluation + on eleven Chandrupatla problems. The clamped form below performs no + cancelling subtraction and cannot overshoot.""" + allowed = self.allow + if not math.isfinite(allowed): + return x_sim + left, right = hi - allowed, lo + allowed + if left > right: + # the budget no longer permits anything but a halving + return 0.5 * (lo + hi) + return min(max(x_sim, left), right) + + def bisect_before_step(self, width): + """Called before the similarity step is even computed. Only the + bracket guard can decide at this point.""" + if self.mode not in ("bracket", "both"): + return False + if width <= 0.5 * self.guard_width: + self.guard_width = width + # The similarity step that is about to be taken is itself the + # pending one. Clearing the flag here instead granted TWO + # consecutive similarity steps after every halving, which makes + # the guarantee one bisection in three evaluations (3x bisection) + # rather than one in two (2x) - measured at 139 evaluations + # against a 2x bound of 114 on Chandrupatla fun4.3. + self.pending = True + return False + if self.pending: + self.pending = False + return True + self.pending = True + return False + + def reject_step(self, step): + """Called with the proposed displacement. Only the step guard can + decide at this point.""" + if self.mode not in ("step", "both", "safe"): + return False + return abs(step) > 0.5 * self.step_2 + + def note_step(self, step): + self.step_2 = self.step_1 + self.step_1 = abs(step) + + +def _slope3(x2, f2, x1, f1, x0, f0): + """Derivative at x2 of the parabola through the three most recent points, + as Newton divided differences: + + f'(x2) ~ f[x1,x2] + f[x0,x1,x2] * (x2 - x1) + + Falls back to the two-point slope when a point is repeated or missing, so + the first iteration of a run behaves exactly like scale="derived".""" + if x2 == x1: + return 0.0 + d12 = (f2 - f1) / (x2 - x1) + # An overflowing difference must report "no usable slope" (0.0), which + # sends pure_root to its bisection fallback. Returning the infinity + # instead would make the scale infinite, hence z = 0, hence "perfectly + # similar to the target", hence a zero step - a stall dressed up as + # success. + if not math.isfinite(d12): + return 0.0 + if x0 is None or x0 == x1 or x0 == x2: + return d12 + d01 = (f1 - f0) / (x1 - x0) + d012 = (d12 - d01) / (x2 - x0) + s = d12 + d012 * (x2 - x1) + return s if math.isfinite(s) else d12 + + +def _local_order(x2, f2, x1, f1, x0, f0): + """The local order m of f, from three evaluations and nothing else. + + Redo the contraction law WITHOUT assuming |f| ~ |f'(r)|.|x-r|. Take + instead |f| ~ K.e^m near the current point, m = 1 being a simple root and + m > 1 a locally flat approach. Then for a power similarity S = 1 - z^p, + + z = |f| / (|f'|.D) = e / (m.D) (K cancels) + step = z^p . D = D^(1-p) . (e/m)^p + + and the step lands on the root when (e/D)^(p-1) = m^p, i.e. + + p = L / (L - ln m), L = ln(e/D) < 0. + + m = 1 gives p = 1, the earlier law. m > 1 drives p below 1 on its own - + at e/D = 0.1, m = 10 it gives p = 0.50, and at e/D = 0.5 it gives 0.23, + which is the neighbourhood of the cube-root similarity that stage 7 found + winning on the wide-bracket families. Substituting that p back collapses + the whole expression to step = e = m.|f|/|f'|, so the exponent is a + reparameterisation and the substance is the multiplier m. + + m is measurable without knowing the root: with theta = f.f''/(f')^2, + f ~ K e^m, f' ~ K m e^(m-1), f'' ~ K m(m-1) e^(m-2) + => theta = m(m-1)/m^2 = 1 - 1/m => m = 1/(1 - theta). + Both derivatives are divided differences of the three most recent points, + so nothing is chosen or fitted. + + Returns 1.0 whenever the power-law model does not apply - theta outside + (0,1) means the data does not describe a flat approach, and the honest + response is to decline the correction rather than to clamp it into range. + """ + if x0 is None or len({x0, x1, x2}) < 3: + return 1.0 + d01 = (f1 - f0) / (x1 - x0) + d12 = (f2 - f1) / (x2 - x1) + d012 = (d12 - d01) / (x2 - x0) + fp = d12 + d012 * (x2 - x1) # f'(x2) on the parabola + fpp = 2.0 * d012 # f''(x2) on the parabola + if fp == 0.0 or not math.isfinite(fp) or not math.isfinite(fpp): + return 1.0 + theta = f2 * fpp / (fp * fp) + if not math.isfinite(theta) or not (0.0 < theta < 1.0): + return 1.0 + m = 1.0 / (1.0 - theta) + return m if math.isfinite(m) and m >= 1.0 else 1.0 + + +def pure_root(f, a, b, xtol, maxfev, similarity="ratio", scale="derived", + guard="step", stats=None, budget_factor=2.0, + budget_extra=None, endowment=1.0): + """The pure similarity root finder. + + similarity : key into PURE_SIMS + scale : "derived" - local slope of f from the two most recent + evaluations (parameter free, order ~1.618) + "derived3_m" - REFUTED as an improvement. The three-point + scale divided by the local order m of f, which + is what the contraction law gives once the + linearity assumption is dropped. The derivation + is sound and the order is preserved; the + estimator of m is not sharp enough to pay for + itself. See the note at the use site. + "derived_rho", "derived3_rho" - REFUTED. The same, with the + scale multiplied by the fraction of its own + promise the previous step kept. Retained for + reproducibility only; see the note at the use + site. Do not adopt. + "derived3" - local slope from the three most recent + evaluations, i.e. the derivative at x of the + parabola through them. Still parameter free - + a divided difference is a computation, not a + fitted coefficient - but the slope error drops + from O(h) to O(h^2), which lifts the order from + 1.618 towards 1.84. This is the direct + consequence of the stage-4 finding that the + whole deficit against Brent is the endgame + order, and nothing else. + "start" - |f| at the starting point (a chosen reference) + "bracket" - largest |f| at the current bracket ends + guard : one of GUARDS + endowment : ABLATION KNOB for guard="credit", not a setting. The method + is defined at 1 bit, and 1 is not a chosen value: the + guarantee is bisection + ceil(C0) steps, so every C0 in (0,1] + promises the same thing - one step - and among those 1 is the + most permissive and therefore the cheapest. Measured over + the 199 problems: 0.1 -> 8395, 0.5 -> 7657, 1 -> 6588, all + with the same one-step guarantee; 2 -> 6404 but two steps, + 5 -> 5621 but five. Nothing is free to choose once the + promise is fixed, and the promise is the specification. + stats : optional dict; on return it carries 'forced' = how many steps + the safeguard turned into bisections. Comparable with the + same key from baselines.brent, so the two methods' fallback + rates can be put side by side. + + Returns (x, nfev, converged). + """ + if similarity not in PURE_SIMS: + raise ValueError(f"unknown similarity {similarity!r}") + if scale not in ("derived", "derived3", "derived_rho", "derived3_rho", + "derived3_m", "start", "bracket"): + raise ValueError(f"unknown scale {scale!r}") + S = PURE_SIMS[similarity] + g = Counter(f, maxfev) + x = 0.5 * (a + b) + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + if fa * fb > 0.0: + raise ValueError("f(a) and f(b) must straddle zero") + + A, FA, B, FB = a, fa, b, fb # the proven bracket + if abs(fa) <= abs(fb): + x, fx, x_prev, f_prev = a, fa, b, fb + else: + x, fx, x_prev, f_prev = b, fb, a, fa + # the third point does not exist yet; _slope3 falls back to two points + x_prev2, f_prev2 = None, None + start_scale = abs(fx) + sg = _Safeguard(guard, abs(B - A), xtol, budget_factor, budget_extra) + sg.credit = endowment + forced = 0 + if stats is not None: + stats['forced'] = 0 + + while abs(B - A) > xtol: + if sg.bisect_before_step(abs(B - A)): + x_new = 0.5 * (A + B) + forced += 1 + # keep the step history honest under guard="both": a bisection + # forced by the bracket backstop is still a step that was taken + sg.note_step(x_new - x) + else: + far = B if abs(B - x) >= abs(A - x) else A + if scale in ("derived", "derived_rho"): + slope = ((fx - f_prev) / (x - x_prev)) if x != x_prev else 0.0 + sc = abs(slope) * abs(far - x) + elif scale in ("derived3", "derived3_rho", "derived3_m"): + slope = _slope3(x, fx, x_prev, f_prev, x_prev2, f_prev2) + sc = abs(slope) * abs(far - x) + if scale == "derived3_m": + # REFUTED as an improvement - kept for reproducibility. + # The DERIVATION holds: dropping the linearity + # assumption from the contraction law does produce the + # march exponent, and it collapses to the multiplier m. + # The ESTIMATOR does not: theta from three points + # cannot tell a genuinely flat approach from curvature + # noise. Measured, it reports m > 1 on 27.9% of steps + # across Alefeld-Potra-Shi, where almost every root is + # simple and the truth is m = 1, with excursions to + # m = 34.8; on the flat fun3/4/5 families it fires on + # 35.8%. A separation of 27.9 against 35.8 is no + # separation, and the false positives cost 273 + # evaluations: 3079 against 2806 on APS, 6304 against + # 6026 over both sets. + # + # It does pass the two tests rho failed - the order + # stays at 2.001 and the eight standard problems + # improve to 82 - which is exactly why it must be + # labelled: a small hand-picked set makes it look like + # a win. + # + # step = m.|f|/|f'| is step = e for a locally flat + # approach; dividing the scale by m is the same thing + # written in the similarity's own terms. m >= 1, so + # like rho this can only lengthen a step - but unlike + # rho it is read from the CURVATURE, which stays + # meaningful as |f| goes to zero, and it returns to 1 + # at a simple root, leaving the endgame untouched. + sc /= _local_order(x, fx, x_prev, f_prev, + x_prev2, f_prev2) + elif scale == "start": + sc = start_scale + else: + sc = max(abs(FA), abs(FB)) + if scale.endswith("_rho"): + # REFUTED - kept only so the experiment is reproducible. + # Measured (stage 8): the fun3/4/5 families it was built + # for do not improve (1364 against 1367, where cbrt gets + # 677); the eight standard problems get twice as + # expensive (84 -> 161); and the observed order collapses + # from 2.000 to 0.904. + # + # Why the derivation was wrong: rho equates "how much + # value the step removed" with "how trustworthy the local + # model is". Near the root |f_n| and |f_{n-1}| are both + # negligible and their ratio is noise, so rho thrashes in + # exactly the place where the correction has to be inert. + # The alternative credibility - the ratio of the assumed + # slope to the realised one - is closed too: the realised + # slope is what the derived scale already computes, so + # correcting by it would double-count. + # + # The phase detector. A step of |f|/|f'| is a promise to + # land on the root; rho is the fraction of that promise + # the previous step actually kept: + # + # rho = 1 - |f_n| / |f_{n-1}| + # + # Near the root the local model is right and rho -> 1, so + # the correction vanishes and the order is untouched. Far + # from it - the approach phase on a very wide bracket - + # the model under-delivers, rho is small, and the step + # must be 1/rho longer to remove what is left. Dividing + # the scale by rho does exactly that. + # + # rho <= 1 always, so the correction can only LENGTHEN the + # step, never shorten it below the Newton step. rho <= 0 + # means the value did not improve at all: there is no + # credibility to read, so the correction is dropped rather + # than guessed, and the bracket projection keeps the step + # safe either way. + if f_prev != 0.0: + rho = 1.0 - abs(fx) / abs(f_prev) + if 0.0 < rho <= 1.0: + sc *= rho + if sc == 0.0 or not math.isfinite(sc): + x_new = 0.5 * (A + B) + else: + step = (1.0 - S(abs(fx) / sc)) * (far - x) + if sg.reject_step(step): + x_new = 0.5 * (A + B) + step = x_new - x + forced += 1 + else: + x_new = x + step + if guard in ("project", "safe", "credit"): + projected = (sg.project_credit if guard == "credit" + else sg.project)(x_new, min(A, B), max(A, B)) + if projected != x_new: + forced += 1 + x_new = projected + step = x_new - x + sg.note_step(step) + + if not math.isfinite(x_new) or not (min(A, B) < x_new < max(A, B)): + x_new = 0.5 * (A + B) + if x_new == x or x_new == x_prev: + x_new = 0.5 * (A + B) + if x_new == x or x_new == x_prev: + # the bracket can no longer be split in floating point + if stats is not None: + stats['forced'] = forced + return x_new, g.n, abs(B - A) <= xtol + + w_before = abs(B - A) + fnew = g(x_new) + sg.j += 1 # one step of the bisection budget is spent + sg.allow *= 0.5 + x_prev2, f_prev2 = x_prev, f_prev + x_prev, f_prev = x, fx + x, fx = x_new, fnew + if fnew == 0.0: + if stats is not None: + stats['forced'] = forced + return x_new, g.n, True + if FA * fnew < 0.0: + B, FB = x_new, fnew + else: + A, FA = x_new, fnew + if guard == "credit": + sg.note_shrink(w_before, abs(B - A)) + if stats is not None: + stats['forced'] = forced + return 0.5 * (A + B), g.n, True + except _Budget: + if stats is not None: + stats['forced'] = forced + return x, g.n, False diff --git a/simroot/sim.py b/simroot/sim.py new file mode 100644 index 0000000..233c96d --- /dev/null +++ b/simroot/sim.py @@ -0,0 +1,237 @@ +"""SIM root finding - the similarity-induced step, in the formulation of +"Parameter-Free Similarity Control" (Sitnikov). + +Mapping of the article's machinery onto root finding +---------------------------------------------------- + article here + ------- ---- + input x the target value y* = 0 ("the expectation") + prototype c_k an evaluated value f(x_k) (value space) + prototype memory y_k the abscissa x_k that produced it + similarity s(x, c_k) similarity of f(x_k) to zero + softmax weights w_k eq. (2) + prediction sum w_k y_k the root estimate, eq. (3) + +So a root finder IS the article's controller run backwards: it is asked "which +x is associated with the outcome 0?" and answers by normalized similarity +aggregation over its memory of evaluated points. + +Two levels of prototype are implemented: + + POINT prototypes x_hat = sum_k w_k x_k + Direct transcription of eq. (3). Exactness note: on a linear f this + recovers the root exactly only for the inverse-distance similarity; + every other similarity function biases it. Measured, not assumed. + + PAIR prototypes x_hat = sum_ij w_ij r_ij , r_ij = secant root of (i,j) + Each bracketing PAIR of memory points is a local rule ("if the outcome + changes sign between x_i and x_j then the root is near r_ij"), exactly + parallel to a fuzzy rule table entry. This is the level at which the + method departs from anything classical: regula falsi is the special + case of a single pair, and the stale-endpoint failure of regula falsi + disappears because a pair containing a large-|f| stale endpoint is by + construction dissimilar to the target and is down-weighted. + +Parameter freedom +----------------- +Similarity needs a scale in value space. It is taken from the data in play - +the largest |f| currently in memory - never from a chosen constant. There is +no sigma, no temperature, no threshold, no tuned coefficient anywhere below. +""" +from __future__ import annotations + +import math + +from .baselines import Counter, _Budget + +EPS = 2.220446049250313e-16 + + +# -------------------------------------------------------------------------- +# similarity functions on the value axis, all taking already-normalised +# residuals z = f / scale and returning a similarity in a comparable range +# -------------------------------------------------------------------------- +def sim_neg_sq(z): + """Negative squared Euclidean distance to the target, then softmax. + This is the article's default (eq. 6) and its benchmark choice.""" + return -z * z + + +def sim_neg_abs(z): + """Negative distance to the target, then softmax.""" + return -abs(z) + + +def sim_inv(z): + """Inverse distance. Returned as a log-similarity so the caller's softmax + reproduces plain inverse-distance weights. This is the unique member of + the family that is exact on a linear f (see module docstring).""" + return -math.log(abs(z) + EPS) + + +def sim_inv_sq(z): + return -2.0 * math.log(abs(z) + EPS) + + +def sim_cosine(z): + """Cosine similarity between the 2-vectors (1, f_k) and (1, 0), i.e. the + article's eq. (4) applied to the value axis lifted to 2-D.""" + return 1.0 / math.sqrt(1.0 + z * z) + + +SIMILARITIES = { + "neg_sq": sim_neg_sq, + "neg_abs": sim_neg_abs, + "inv": sim_inv, + "inv_sq": sim_inv_sq, + "cosine": sim_cosine, +} + + +def _softmax(scores): + m = max(scores) + ex = [math.exp(s - m) for s in scores] + tot = sum(ex) + if tot == 0.0 or not math.isfinite(tot): + n = len(ex) + return [1.0 / n] * n + return [e / tot for e in ex] + + +# -------------------------------------------------------------------------- +# SIM root finder +# -------------------------------------------------------------------------- +def sim_root(f, a, b, xtol, maxfev, similarity="neg_sq", prototypes="pair", + memory=None, guard=False): + """Similarity-induced bracketed root finder. + + similarity : key into SIMILARITIES + prototypes : "point" - eq. (3) verbatim, prototypes are evaluated points + "pair" - rule-level prototypes, similarity on the value axis + "pair2d" - rule-level prototypes, similarity on the value axis + AND the abscissa axis (support tightness) + memory : None = unbounded memory of every evaluated point; + an int k = keep only the k most recent points. + Unbounded is the default; the truncation is an ablation knob, + not a tuned parameter. + guard : enable the parameter-free safeguard. A similarity step is + taken only while the bracket keeps halving; the moment a + whole halving has failed to happen, one bisection step is + forced. The only constant involved is 1/2, which is the + definition of bisection rather than a tuned value, and it + bounds the worst case at twice bisection. Compare: Brent, + Ridders, TOMS748 and ITP all need a safeguard here too, and + ITP's carries three tuning constants (kappa1, kappa2, n0). + """ + sfun = SIMILARITIES[similarity] + two_d = prototypes == "pair2d" + g = Counter(f, maxfev) + x = 0.5 * (a + b) + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + # memory of every evaluated point + mem = [(a, fa), (b, fb)] + guard_width = abs(b - a) # width at the last acknowledged halving + pending = False # a similarity step has been tried since then + + while abs(b - a) > xtol: + lo, hi = (a, b) if a < b else (b, a) + width = hi - lo + + if guard: + if width <= 0.5 * guard_width: + guard_width = width # the halving happened; nothing owed + pending = False + elif pending: + # a similarity step was already spent without halving the + # bracket -> pay it back with one bisection step + x = 0.5 * (a + b) + fx = g(x) + mem.append((x, fx)) + pending = False + if fx == 0.0: + return x, g.n, True + if fa * fx < 0.0: + b, fb = x, fx + else: + a, fa = x, fx + continue + pending = True + # the memory is the WHOLE evaluation history, including points that + # have fallen outside the current bracket: a stale point is not + # deleted, it is merely dissimilar to the target and therefore + # carries little weight. (Restricting the memory to the bracket + # leaves exactly the two endpoints and collapses the method onto + # regula falsi - verified in stage 1.) + live = mem if memory is None else mem[-memory:] + scale = max(abs(fi) for (_, fi) in live) + if scale == 0.0: + return live[0][0], g.n, True + + if prototypes == "point": + scores = [sfun(fi / scale) for (_, fi) in live] + w = _softmax(scores) + x_new = sum(wi * xi for wi, (xi, _) in zip(w, live)) + else: # pair prototypes + cand, scores = [], [] + for i in range(len(live)): + xi, fi = live[i] + for j in range(i + 1, len(live)): + xj, fj = live[j] + if fj == fi: + continue + r = (xi * fj - xj * fi) / (fj - fi) + if not math.isfinite(r) or not (lo < r < hi): + # a rule whose conclusion falls outside the proven + # bracket is inadmissible, not merely unlikely + continue + cand.append(r) + # a pair is similar to the target when BOTH of its + # endpoints produced outcomes similar to the target + sc = sfun(fi / scale) + sfun(fj / scale) + if two_d: + # ...and when its support is tight. Without this + # term a flat tail (|f| ~ 1e-16 at 39 units from + # the root) looks maximally similar to the target + # and the method stalls there - measured, not + # assumed. Both axes are normalised by the data + # in play (largest |f| in memory; current bracket + # width), exactly as the article normalises its + # input space so that each axis contributes + # equally. + sc += sfun(abs(xi - xj) / width) + scores.append(sc) + if not cand: + x_new = 0.5 * (a + b) + else: + w = _softmax(scores) + x_new = sum(wi * ri for wi, ri in zip(w, cand)) + + if not math.isfinite(x_new) or not (lo < x_new < hi): + x_new = 0.5 * (a + b) + # never propose a point already in memory (would waste the budget) + if any(x_new == xi for (xi, _) in mem): + x_new = 0.5 * (a + b) + if any(x_new == xi for (xi, _) in mem): + # the bracket can no longer be split in floating point. + # Report success only if it is actually inside the + # tolerance; otherwise this is stagnation and must be + # reported as a failure, not counted as a win. + return x_new, g.n, abs(b - a) <= xtol + + x = x_new + fx = g(x) + mem.append((x, fx)) + if fx == 0.0: + return x, g.n, True + if fa * fx < 0.0: + b, fb = x, fx + else: + a, fa = x, fx + return 0.5 * (a + b), g.n, True + except _Budget: + return x, g.n, False diff --git a/stage0_principle.py b/stage0_principle.py new file mode 100644 index 0000000..5754388 --- /dev/null +++ b/stage0_principle.py @@ -0,0 +1,157 @@ +"""Stage 0 - does the similarity-proportional step actually converge faster than bisection? + +The principle under test (Valeri's formulation): + in bisection the next point is the MIDPOINT of the bracket; + in the similarity version the next point is placed proportionally to how + SIMILAR the current result f(x) is to the expectation (zero): + similar -> small step + dissimilar-> large step + +Formalisation used here. Bracket [a,b] with f(a)*f(b) < 0. Define the +similarity of an endpoint's value to the target 0 in a SCALE-FREE way, using +only the data inside the bracket (no parameter): + + S(a) = |f(b)| / (|f(a)| + |f(b)|) (a is similar to the root when |f(a)| is small) + S(b) = |f(a)| / (|f(a)| + |f(b)|) S(a) + S(b) = 1 + +Next point = similarity-weighted aggregation of the prototypes {a, b}: + + x = S(a)*a + S(b)*b + +which is identical to stepping away from `a` by (1 - S(a)) of the bracket. +Bisection is the degenerate case S(a) = S(b) = 1/2, i.e. "no similarity +information used at all". + +This file measures function evaluations to reach |x - root| <= tol, for + - bisection (S == 1/2, the null model) + - sim-step (the principle, raw) +and prints the per-problem numbers. No aggregate statistic is used to decide +anything; every problem is shown. +""" +from __future__ import annotations + +import math +from dataclasses import dataclass +from typing import Callable + +TOL = 1e-12 +MAXFEV = 200 + + +@dataclass +class Problem: + name: str + f: Callable[[float], float] + a: float + b: float + root: float + + +PROBLEMS = [ + Problem("x^2 - 2 ", lambda x: x * x - 2.0, 0.0, 2.0, math.sqrt(2.0)), + Problem("cos(x) - x ", lambda x: math.cos(x) - x, 0.0, 1.0, 0.7390851332151607), + Problem("exp(x) - 2 ", lambda x: math.exp(x) - 2.0, 0.0, 2.0, math.log(2.0)), + Problem("x^3 - x - 2 ", lambda x: x ** 3 - x - 2.0, 1.0, 2.0, 1.5213797068045676), + Problem("sin(x) - 0.5 ", lambda x: math.sin(x) - 0.5, 0.0, 1.5, math.asin(0.5)), + # the classical stalling case for regula falsi: strong convexity, root near + # one end -> one endpoint never moves + Problem("x^10 - 1 (STALL case) ", lambda x: x ** 10 - 1.0, 0.0, 1.3, 1.0), + Problem("exp(-x)*(x-1) (flat end)", lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0, 1.0), + Problem("atan(x) ", lambda x: math.atan(x), -1.0, 3.0, 0.0), +] + + +def _count(f): + """Wrap f with an evaluation counter.""" + state = {"n": 0} + + def g(x): + state["n"] += 1 + return f(x) + + return g, state + + +def bisection(f, a, b, tol=TOL, maxfev=MAXFEV): + g, st = _count(f) + fa, fb = g(a), g(b) + if fa == 0.0: + return a, st["n"] + if fb == 0.0: + return b, st["n"] + x = 0.5 * (a + b) + while st["n"] < maxfev: + x = 0.5 * (a + b) + fx = g(x) + if fx == 0.0 or (b - a) <= tol: + return x, st["n"] + if fa * fx < 0.0: + b, fb = x, fx + else: + a, fa = x, fx + return x, st["n"] + + +def sim_step(f, a, b, tol=TOL, maxfev=MAXFEV): + """The raw principle: x = S(a)*a + S(b)*b with S scale-free inside the bracket.""" + g, st = _count(f) + fa, fb = g(a), g(b) + if fa == 0.0: + return a, st["n"] + if fb == 0.0: + return b, st["n"] + x = 0.5 * (a + b) + while st["n"] < maxfev: + da, db = abs(fa), abs(fb) + tot = da + db + if tot == 0.0: + return 0.5 * (a + b), st["n"] + s_a = db / tot # similarity of endpoint a to the root + s_b = da / tot + x_new = s_a * a + s_b * b + # guard: keep the iterate strictly inside the bracket (numerical only, + # not a tuning parameter) + lo, hi = (a, b) if a < b else (b, a) + if not (lo < x_new < hi): + x_new = 0.5 * (a + b) + x = x_new + fx = g(x) + if fx == 0.0 or abs(b - a) <= tol: + return x, st["n"] + if fa * fx < 0.0: + b, fb = x, fx + else: + a, fa = x, fx + return x, st["n"] + + +def run(): + print(f"{'problem':26s} {'bisect fev':>11s} {'bisect err':>11s} " + f"{'sim fev':>9s} {'sim err':>11s} verdict") + print("-" * 90) + wins = ties = losses = 0 + for p in PROBLEMS: + xb, nb = bisection(p.f, p.a, p.b) + xs, ns = sim_step(p.f, p.a, p.b) + eb = abs(xb - p.root) + es = abs(xs - p.root) + # a method only "wins" if it reached the root at all + ok_b = eb <= 1e-8 + ok_s = es <= 1e-8 + if ok_s and (not ok_b or ns < nb): + verdict = "SIM faster" + wins += 1 + elif ok_s and ok_b and ns == nb: + verdict = "tie" + ties += 1 + else: + verdict = "SIM slower/failed" + losses += 1 + print(f"{p.name:26s} {nb:11d} {eb:11.2e} {ns:9d} {es:11.2e} {verdict}") + print("-" * 90) + print(f"SIM faster: {wins} tie: {ties} SIM slower/failed: {losses}" + f" (of {len(PROBLEMS)}; maxfev={MAXFEV})") + + +if __name__ == "__main__": + run() diff --git a/stage0b_pure_similarity.py b/stage0b_pure_similarity.py new file mode 100644 index 0000000..cd40176 --- /dev/null +++ b/stage0b_pure_similarity.py @@ -0,0 +1,158 @@ +"""Stage 0b - the PURE similarity idea, taken literally as a STEP-SIZE rule. + +Valeri's formulation, word for word: + + "in bisection the next point is chosen through half of the interval. + With similarity the next point is chosen proportionally to the value of + the similarity function (0 = not similar at all, 1 = identical) of the + result to the expectation (e.g. zero). So the step is LARGER when the + result is not similar to the expectation, and SMALLER when it is." + +This is NOT the same object as Stage 0. Stage 0 asked "where between a and b +does the root sit" (an interpolation rule, which turned out to be regula +falsi identically). Here the rule is: + + direction <- given by the sign (towards the side that brackets the root) + step <- (1 - S(f(x_n))) * (distance to the far end of the bracket) + +with S a genuine [0,1] similarity function of a single value f(x) to the +target 0. Bisection is the special case S == 1/2 for every input, i.e. +"the similarity function carries no information". + +The whole content of the method is therefore the similarity function itself. +The one thing S needs that a two-point rule did not is a SCALE: how large is +|f| = 3? Any constant here would be a hidden tuning parameter. Three +scale sources are compared, all taken from the run itself: + + s0 the value at the starting point (fixed reference) + srun the largest |f| seen so far (growing reference) + slive the largest |f| at the current bracket ends (shrinking reference) + +and the last one is the one that reproduces Stage 0 / regula falsi for the +linear S, which is exactly the collapse this stage is meant to expose. +""" +from __future__ import annotations + +import math + +from simroot.baselines import Counter, _Budget, bisection, brent + +XTOL = 1e-12 +MAXFEV = 200 + +# -------------------------------------------------------------------------- +# genuine [0,1] similarity functions of a normalised residual z = f / scale +# S(0) = 1 (identical to the expectation), S(large) -> 0 (not similar at all) +# -------------------------------------------------------------------------- +SIMS_01 = { + # linear ramp, saturating at the reference scale + "linear": lambda z: max(0.0, 1.0 - abs(z)), + # rational, never saturates + "rational": lambda z: 1.0 / (1.0 + abs(z)), + # rational in the square + "rat_sq": lambda z: 1.0 / (1.0 + z * z), + # exponential decay of the distance + "exp_abs": lambda z: math.exp(-abs(z)), + # the article's negative squared Euclidean distance, exponentiated to [0,1] + "exp_sq": lambda z: math.exp(-z * z), + # cosine similarity of (1, f) against (1, 0) - article eq. (4) on the + # value axis lifted to 2-D + "cosine": lambda z: 1.0 / math.sqrt(1.0 + z * z), +} + +SCALES = ("s0", "srun", "slive") + + +def pure_similarity_step(f, a, b, xtol, maxfev, sim="rational", scale="s0"): + """The literal step-size rule. Bracket kept only for safety and for + knowing which way to walk; the step LENGTH comes from similarity alone.""" + S = SIMS_01[sim] + g = Counter(f, maxfev) + x = 0.5 * (a + b) + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + + # start from the endpoint whose result is already more similar to 0 + if abs(fa) <= abs(fb): + x, fx, far, ffar = a, fa, b, fb + else: + x, fx, far, ffar = b, fb, a, fa + + s0 = abs(fx) + smax = max(abs(fa), abs(fb)) + + while abs(far - x) > xtol: + if scale == "s0": + sc = s0 + elif scale == "srun": + sc = smax + else: + sc = max(abs(fx), abs(ffar)) + if sc == 0.0: + return x, g.n, True + + s = S(abs(fx) / sc) # 1 = the result already IS zero + step = (1.0 - s) * (far - x) # dissimilar -> long step + x_new = x + step + lo, hi = (x, far) if x < far else (far, x) + if not math.isfinite(x_new) or not (lo < x_new < hi): + x_new = 0.5 * (x + far) + + fnew = g(x_new) + if fnew == 0.0: + return x_new, g.n, True + smax = max(smax, abs(fnew)) + if fx * fnew < 0.0: + # the root is between the old point and the new one + far, ffar = x, fx + x, fx = x_new, fnew + return x, g.n, True + except _Budget: + return x, g.n, False + + +PROBLEMS = [ + ("x^2 - 2", lambda x: x * x - 2.0, 0.0, 2.0, math.sqrt(2.0)), + ("cos(x) - x", lambda x: math.cos(x) - x, 0.0, 1.0, 0.7390851332151607), + ("exp(x) - 2", lambda x: math.exp(x) - 2.0, 0.0, 2.0, math.log(2.0)), + ("x^3 - x - 2", lambda x: x ** 3 - x - 2.0, 1.0, 2.0, 1.5213797068045676), + ("sin(x) - 0.5", lambda x: math.sin(x) - 0.5, 0.0, 1.5, math.asin(0.5)), + ("x^10 - 1 STALL", lambda x: x ** 10 - 1.0, 0.0, 1.3, 1.0), + ("exp(-x)(x-1) FLAT", lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0, 1.0), + ("atan(x)", lambda x: math.atan(x), -1.0, 3.0, 0.0), +] + + +def run(): + methods = [("bisection (S=1/2)", lambda f, a, b: bisection(f, a, b, XTOL, MAXFEV)), + ("brent [reference]", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV))] + for sc in SCALES: + for s in SIMS_01: + methods.append(( + f"pure.{s}.{sc}", + (lambda ss, scl: lambda f, a, b: pure_similarity_step( + f, a, b, XTOL, MAXFEV, sim=ss, scale=scl))(s, sc))) + + width = max(len(n) for n, _ in methods) + 1 + header = (f"{'method':{width}s}" + + "".join(f"{p[0][:13]:>15s}" for p in PROBLEMS) + + f"{'TOTAL':>8s}{'FAIL':>6s}") + print(header) + print("-" * len(header)) + for name, fn in methods: + cells, total, fails = [], 0, 0 + for _, f, a, b, root in PROBLEMS: + x, n, conv = fn(f, a, b) + ok = conv and abs(x - root) <= 1e-8 + cells.append(f"{n:>15d}" if ok else f"{'FAIL(' + str(n) + ')':>15s}") + total += n + fails += 0 if ok else 1 + print(f"{name:{width}s}" + "".join(cells) + f"{total:>8d}{fails:>6d}") + + +if __name__ == "__main__": + run() diff --git a/stage0c_why_pure_fails.py b/stage0c_why_pure_fails.py new file mode 100644 index 0000000..5156e5a --- /dev/null +++ b/stage0c_why_pure_fails.py @@ -0,0 +1,95 @@ +"""Stage 0c - WHY the pure step-size rule fails. Diagnosis, not assertion. + +Claim under test: x_{n+1} = x_n + (1 - S(f(x_n))) * L_n is a fixed-point +iteration whose contraction factor near a simple root r is + + x_{n+1} - r ~ (x_n - r) * (1 - c |f'(r)| L) + +because 1 - S(f) ~ c|f| for a similarity that reaches 1 linearly, and +|f(x)| ~ |f'(r)| |x - r|. Consequences, both checkable: + + (1) if S reaches 1 QUADRATICALLY (cosine, exp(-z^2), 1/(1+z^2)) then + 1 - S ~ c f^2, the step dies faster than the error and the sequence + stagnates at a non-root; + (2) even for a linear S the factor c|f'(r)|L is a property of the problem's + SCALING, not of the method - so convergence is a coincidence and the + rate is at best linear. + +Both are printed as traces: the distance to the root per iteration. +""" +from __future__ import annotations + +import math + +from stage0b_pure_similarity import SIMS_01 + + +def trace(f, x0, far, root, sim, n=14): + S = SIMS_01[sim] + x = x0 + scale = abs(f(x0)) + out = [] + for _ in range(n): + z = abs(f(x)) / scale + s = S(z) + x = x + (1.0 - s) * (far - x) + out.append(abs(x - root)) + return out + + +def main(): + f = lambda x: x * x - 2.0 + root = math.sqrt(2.0) + print("f(x) = x^2 - 2 on [0, 2], starting at x0 = 0, far end 2") + print("|x_n - root| for the first 14 steps\n") + for sim in SIMS_01: + t = trace(f, 0.0, 2.0, root, sim) + ratios = [t[i + 1] / t[i] if t[i] else 0.0 for i in range(len(t) - 1)] + tail = sum(ratios[-4:]) / 4.0 + kind = ("stagnates" if tail > 0.999 else + "linear" if tail > 0.05 else "fast") + print(f"{sim:9s} " + " ".join(f"{v:8.2e}" for v in t[:8]) + + f" last ratio ~ {tail:6.4f} -> {kind}") + + print("\nSame rule, same similarity ('rational'), only the SCALING of f " + "changed.\nThe root is identical; only the units of f differ.\n") + root2 = math.sqrt(2.0) + for k in (1e-3, 1e-1, 1.0, 1e1, 1e3): + g = (lambda kk: lambda x: kk * (x * x - 2.0))(k) + t = trace(g, 0.0, 2.0, root2, "rational", n=40) + print(f" f scaled by {k:8.0e}: |x_40 - root| = {t[-1]:.3e}") + print("\n(The scale is divided out by construction, so the rule IS " + "scale invariant.\n The failure mode is therefore NOT units - it is " + "the convergence RATE.)") + + # ------------------------------------------------------------------ + # the rate is not empirical folklore - it is derivable, and the + # derivation is checked against the measurement below. + # + # e_{n+1} = e_n - (1 - S)(far - x_n), 1 - S ~ c*|f'(r)|*e_n / scale + # => e_{n+1} = e_n * (1 - c*|f'(r)|*D / scale), D = far - r + # => rate = |1 - c*|f'(r)|*D/scale| + # + # c is the slope of (1 - S) at z = 0: 1 for 1/(1+z) and for exp(-z), + # 0 for every similarity that approaches 1 quadratically -> rate 1 + # (stagnation), which is exactly what the traces above show. + # ------------------------------------------------------------------ + print("\nPredicted vs measured contraction rate " + "(rate = |1 - c*|f'(r)|*D/scale|):") + fp = 2.0 * math.sqrt(2.0) # f'(root) for x^2 - 2 + D = 2.0 - math.sqrt(2.0) # far end minus root + scale = abs(f(0.0)) # |f(x0)| + for sim, c in (("rational", 1.0), ("exp_abs", 1.0), + ("rat_sq", 0.0), ("exp_sq", 0.0), ("cosine", 0.0)): + pred = abs(1.0 - c * fp * D / scale) + # measured in the asymptotic window, before machine precision is hit + # (past that point the error is pure round-off and the ratio is noise) + t = trace(f, 0.0, 2.0, root, sim, n=14) + win = [t[i + 1] / t[i] for i in range(len(t) - 1) if t[i] > 1e-11] + meas = sum(win[-3:]) / len(win[-3:]) if win else float("nan") + print(f" {sim:9s} c={c:3.1f} predicted {pred:7.4f} " + f"measured {meas:7.4f}") + + +if __name__ == "__main__": + main() diff --git a/stage0d_derived_similarity.py b/stage0d_derived_similarity.py new file mode 100644 index 0000000..1f7fcf5 --- /dev/null +++ b/stage0d_derived_similarity.py @@ -0,0 +1,142 @@ +"""Stage 0d - faster similarity functions, and similarity DERIVED FROM DATA. + +Two questions, in order. + +(1) Ratio-type similarities. S(x,y) = |x|/|y| and relatives change much + faster than 1/(1+z) or exp(-z). Stage 0c derived the contraction rate of + the pure step rule as + + rate = | 1 - c * |f'(r)| * D / scale | , c = slope of (1 - S) at 0 + + so a similarity that changes FASTER has a larger c and moves the rate away + from 1 - but it overshoots just as easily as it undershoots, because + nothing ties c to the problem. Measured below, not argued. + +(2) Similarity derived from the data. The same formula says the rate is + exactly ZERO when + + c = scale / ( |f'(r)| * D ). + + Nothing in that expression has to be chosen: |f'| is estimated by the + secant slope of the two most recent evaluations, D by the current distance + to the far end, scale by the value in play. Substituting it back: + + step = (1 - S)*(far - x) = c*|f|/scale * D = |f| / |f'| + + - the calibrated similarity step IS the Newton/secant step. So "derive + the similarity parameter from the data" is not a tweak of the pure idea; + it is the statement that the value axis has a LOCAL scale, and reading + that scale off the data is what turns linear convergence into superlinear. + + This is the same move the article makes when it normalises the input space + from the data instead of choosing membership widths by hand. +""" +from __future__ import annotations + +import math + +from simroot.baselines import bisection, brent +from simroot.pure import PURE_SIMS, pure_root + +XTOL = 1e-12 +MAXFEV = 200 + +# -------------------------------------------------------------------------- +# (1) fast, ratio-type [0,1] similarities of a normalised residual z +# -------------------------------------------------------------------------- +# The similarity functions and the step rule now live in simroot.pure, which +# is the single implementation behind every number in this project - the +# benchmark, the tables below and the paper all call the same code. This file +# keeps only the subset of similarities that stage 0d is about, plus two thin +# delegations so the stage-0d and stage-0e tables read unchanged. +FAST_SIMS = {k: PURE_SIMS[k] for k in + ("ratio", "sqrt", "cbrt", "ratio_soft", "rational", "exp_abs")} + + +def pure_step(f, a, b, xtol, maxfev, sim): + """The step rule with the scale CHOSEN: |f| at the starting point.""" + return pure_root(f, a, b, xtol, maxfev, similarity=sim, scale="start", + guard="none") + + +def derived_step(f, a, b, xtol, maxfev, sim="ratio", guard=True): + """The step rule with the scale DERIVED from the two most recent + evaluations. `guard=True` keeps the bracket safeguard that stage 0d + measured; stage 0e compares it against no safeguard at all.""" + return pure_root(f, a, b, xtol, maxfev, similarity=sim, scale="derived", + guard="bracket" if guard else "none") + + +PROBLEMS = [ + ("x^2 - 2", lambda x: x * x - 2.0, 0.0, 2.0, math.sqrt(2.0)), + ("cos(x) - x", lambda x: math.cos(x) - x, 0.0, 1.0, 0.7390851332151607), + ("exp(x) - 2", lambda x: math.exp(x) - 2.0, 0.0, 2.0, math.log(2.0)), + ("x^3 - x - 2", lambda x: x ** 3 - x - 2.0, 1.0, 2.0, 1.5213797068045676), + ("sin(x) - 0.5", lambda x: math.sin(x) - 0.5, 0.0, 1.5, math.asin(0.5)), + ("x^10 - 1 STALL", lambda x: x ** 10 - 1.0, 0.0, 1.3, 1.0), + ("exp(-x)(x-1) FLAT", lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0, 1.0), + ("atan(x)", lambda x: math.atan(x), -1.0, 3.0, 0.0), +] + + +def _table(methods, title): + print("\n" + title) + width = max(len(n) for n, _ in methods) + 1 + header = (f"{'method':{width}s}" + + "".join(f"{p[0][:13]:>15s}" for p in PROBLEMS) + + f"{'TOTAL':>8s}{'FAIL':>6s}") + print(header) + print("-" * len(header)) + for name, fn in methods: + cells, total, fails = [], 0, 0 + for _, f, a, b, root in PROBLEMS: + xx, n, conv = fn(f, a, b) + ok = conv and abs(xx - root) <= 1e-8 + cells.append(f"{n:>15d}" if ok else f"{'FAIL(' + str(n) + ')':>15s}") + total += n + fails += 0 if ok else 1 + print(f"{name:{width}s}" + "".join(cells) + f"{total:>8d}{fails:>6d}") + + +def rate_table(): + """The measured contraction rate of each fast similarity, against the + rate predicted by the stage-0c law.""" + f = lambda x: x * x - 2.0 + root = math.sqrt(2.0) + fp, D, scale = 2.0 * math.sqrt(2.0), 2.0 - math.sqrt(2.0), 2.0 + print("\ncontraction rate on x^2 - 2, pure rule, scale = |f(x0)|") + print(f"{'similarity':10s} {'c (slope of 1-S at 0)':>24s} " + f"{'predicted':>11s} {'measured':>10s}") + print("-" * 60) + for sim in FAST_SIMS: + S = FAST_SIMS[sim] + h = 1e-7 + c = (1.0 - S(h)) / h # numerical slope of (1 - S) at 0 + pred = abs(1.0 - c * fp * D / scale) if math.isfinite(c) else float("inf") + x, errs = 0.0, [] + for _ in range(14): + x = x + (1.0 - S(abs(f(x)) / scale)) * (2.0 - x) + errs.append(abs(x - root)) + win = [errs[i + 1] / errs[i] for i in range(len(errs) - 1) if errs[i] > 1e-11] + meas = sum(win[-3:]) / len(win[-3:]) if win else float("nan") + cs = f"{c:.3e}" if math.isfinite(c) else "inf" + ps = f"{pred:.4f}" if math.isfinite(pred) else "inf (overshoot)" + print(f"{sim:10s} {cs:>24s} {ps:>11s} {meas:>10.4f}") + + +def main(): + rate_table() + _table([("bisection", lambda f, a, b: bisection(f, a, b, XTOL, MAXFEV)), + ("brent [reference]", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV))] + + [(f"fast.{s}", (lambda ss: lambda f, a, b: pure_step( + f, a, b, XTOL, MAXFEV, ss))(s)) for s in FAST_SIMS], + "(1) FAST similarity functions, parameter CHOSEN") + _table([("bisection", lambda f, a, b: bisection(f, a, b, XTOL, MAXFEV)), + ("brent [reference]", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV))] + + [(f"derived.{s}", (lambda ss: lambda f, a, b: derived_step( + f, a, b, XTOL, MAXFEV, ss))(s)) for s in FAST_SIMS], + "(2) similarity SCALE DERIVED FROM DATA (secant slope), guarded") + + +if __name__ == "__main__": + main() diff --git a/stage0e_guard_cost.py b/stage0e_guard_cost.py new file mode 100644 index 0000000..da38e87 --- /dev/null +++ b/stage0e_guard_cost.py @@ -0,0 +1,57 @@ +"""Stage 0e - how much is the parameter-free safeguard costing? + +derived.ratio is, algebraically, the Newton/secant step: + + S = 1 - |z|, z = |f| / (|f'_secant| * (far - x)) + step = (1 - S)*(far - x) = |f| / |f'_secant| + +so it should be superlinear (order ~1.618) and land near Brent. It measured +150 evaluations over the eight problems against Brent's 82. The gap has to +come from somewhere, and the only extra machinery it carries is the +safeguard: a secant step often shrinks the ERROR fast while barely moving the +proven BRACKET, so the "did the bracket halve" test fires and buys a bisection +step that the search did not need. + +This measures the price directly: the same method with the safeguard on and +off, side by side. +""" +from __future__ import annotations + +import math + +from simroot.baselines import bisection, brent +from stage0d_derived_similarity import FAST_SIMS, PROBLEMS, derived_step + +XTOL = 1e-12 +MAXFEV = 200 + + +def main(): + methods = [("bisection", lambda f, a, b: bisection(f, a, b, XTOL, MAXFEV)), + ("brent [reference]", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV))] + for s in FAST_SIMS: + for gu in (True, False): + methods.append(( + f"derived.{s}" + (".guard" if gu else ".raw"), + (lambda ss, g: lambda f, a, b: derived_step( + f, a, b, XTOL, MAXFEV, sim=ss, guard=g))(s, gu))) + + width = max(len(n) for n, _ in methods) + 1 + header = (f"{'method':{width}s}" + + "".join(f"{p[0][:13]:>15s}" for p in PROBLEMS) + + f"{'TOTAL':>8s}{'FAIL':>6s}") + print(header) + print("-" * len(header)) + for name, fn in methods: + cells, total, fails = [], 0, 0 + for _, f, a, b, root in PROBLEMS: + x, n, conv = fn(f, a, b) + ok = conv and abs(x - root) <= 1e-8 + cells.append(f"{n:>15d}" if ok else f"{'FAIL(' + str(n) + ')':>15s}") + total += n + fails += 0 if ok else 1 + print(f"{name:{width}s}" + "".join(cells) + f"{total:>8d}{fails:>6d}") + + +if __name__ == "__main__": + main() diff --git a/stage10_claim_checks.py b/stage10_claim_checks.py new file mode 100644 index 0000000..7220a29 --- /dev/null +++ b/stage10_claim_checks.py @@ -0,0 +1,157 @@ +"""Stage 10 - checking the technical claims independently. + +Five of them change the content of the paper rather than its wording, so none +is accepted on authority. Each is recomputed here from scratch. + + A. The proposed similarity IS the one Table 1's last row calls degenerate, + and the degeneracy is specific to the CHOSEN scale. + B. Proposition 1 is true for the ratio form only, not for similarity rules + in general. + C. The bracket-endpoint divided difference plus the tent similarity is + regula falsi exactly - so the words "most recent" in the definition of + f-hat are load-bearing. + D. Table 1's c = 0 rows report a window artefact; the true behaviour is + sublinear, e_n ~ sigma^2 / (c2 f'(r)^2 |D| n). + E. The order of a Newton step with an O(h^2) derivative estimate is 2, not + the 1.84 the paper claims. +""" +from __future__ import annotations + +import math + +r2 = math.sqrt(2.0) +f = lambda x: x * x - 2.0 + +TENT = lambda z: max(0.0, 1.0 - abs(z)) +RATIO = lambda z: 1.0 / (1.0 + abs(z)) +RAT_SQ = lambda z: 1.0 / (1.0 + z * z) +EXP_SQ = lambda z: math.exp(-z * z) +COSINE = lambda z: 1.0 / math.sqrt(1.0 + z * z) + + +def iterate(S, n, sigma=2.0, x0=0.0, xfar=2.0): + x, errs = x0, [] + for _ in range(n): + x = x + (1.0 - S(f(x) / sigma)) * (xfar - x) + errs.append(abs(x - r2)) + return errs + + +def main(): + print("=" * 76) + print("A. the tent similarity under the CHOSEN scale") + print("=" * 76) + e = iterate(TENT, 200) + print(f" z at x=0 is {f(0.0) / 2.0:+.1f}, so S = {TENT(f(0.0) / 2.0):.1f} " + f"and the step is the whole bracket") + print(f" |e| after 1 step: {e[0]:.4f} after 200: {e[-1]:.4f} " + f"{'CAPTURED at the far end' if abs(e[0] - e[-1]) < 1e-15 else 'moves'}") + print(" => the paper proposes, in section 3, the function its own") + print(" Table 1 calls degenerate. CONFIRMED.") + + print("\n but under the DERIVED scale the clip never engages:") + # replay the proposed configuration and record how often |f|/sigma >= 1 + from simroot.pure import _slope3 + clipped = total = 0 + a, b = 0.0, 2.0 + fa, fb = f(a), f(b) + A, FA, B = a, fa, b + x, fx, xp, fp = a, fa, b, fb + xp2 = fp2 = None + for _ in range(40): + if abs(B - A) <= 1e-12: + break + far = B if abs(B - x) >= abs(A - x) else A + slope = _slope3(x, fx, xp, fp, xp2, fp2) + sc = abs(slope) * abs(far - x) + if sc == 0.0: + break + z = abs(fx) / sc + total += 1 + clipped += z >= 1.0 + xn = x + min(1.0, z) * (far - x) + lo, hi = min(A, B), max(A, B) + if not (lo < xn < hi): + xn = 0.5 * (A + B) + fn = f(xn) + xp2, fp2, xp, fp, x, fx = xp, fp, x, fx, xn, fn + if FA * fn < 0.0: + B = xn + else: + A, FA = xn, fn + print(f" steps {total}, of which clipped at z>=1: {clipped}") + + print("\n" + "=" * 76) + print("B/C. Proposition 1: which similarity reproduces regula falsi?") + print("=" * 76) + a, b = 1.0, 4.0 + fa, fb = f(a), f(b) + falsi = (a * fb - b * fa) / (fb - fa) + print(f" regula falsi point on [1,4]: {falsi:.6f}\n") + print(f" {'similarity':14s}{'scale = |f(x_far)|':>22s}{'match':>8s}") + print(" " + "-" * 44) + for name, S in (("1/(1+|z|)", RATIO), ("exp(-|z|)", lambda z: math.exp(-abs(z))), + ("1/(1+z^2)", RAT_SQ), ("1/sqrt(1+z^2)", COSINE), + ("tent", TENT)): + pt = a + (1.0 - S(f(a) / abs(fb))) * (b - a) + print(f" {name:14s}{pt:>22.6f}{'YES' if abs(pt - falsi) < 1e-12 else 'no':>8s}") + print("\n => the identity holds for the ratio form only. The paper's") + print(" conclusion 'a similarity rule whose scale is taken from the") + print(" bracket is not a new method' is too broad. CONFIRMED.") + + sigma = abs((fb - fa) / (b - a)) * abs(b - a) + pt = a + min(1.0, abs(fa) / sigma) * (b - a) + print(f"\n tent + divided difference over the BRACKET ENDS: {pt!r}") + print(f" equals regula falsi exactly: {pt == falsi}") + print(" => 'most recent' in the definition of f-hat is load-bearing:") + print(" ends give regula falsi, recent iterates give the secant.") + + print("\n" + "=" * 76) + print("D. Table 1, the c = 0 rows") + print("=" * 76) + print(f" {'n':>6s}" + "".join(f"{s:>14s}" for s in + ("1/(1+z^2)", "exp(-z^2)", "1/sqrt(1+z^2)"))) + print(" " + "-" * 48) + seqs = {n: iterate(S, 4001) for n, S in + (("1/(1+z^2)", RAT_SQ), ("exp(-z^2)", EXP_SQ), + ("1/sqrt(1+z^2)", COSINE))} + for n in (5, 10, 15, 40, 100, 1000, 4000): + row = "".join(f"{seqs[k][n] / seqs[k][n - 1]:>14.4f}" for k in seqs) + print(f" {n:>6d}{row}") + print("\n the ratio creeps to 1 - there is no rate to measure, and the") + print(" paper's 0.9357 / 0.9444 / 0.9327 are the value at n ~ 10-15.") + print("\n the real law: 1 - S = c2 z^2 + O(z^4) gives") + print(" e_{n+1} = e_n - c2 f'(r)^2 |D| e_n^2 / sigma^2 + ...") + print(" => e_n ~ sigma^2 / (c2 f'(r)^2 |D|) . 1/n") + fp, D, sig = 2.0 * r2, 2.0 - r2, 2.0 + # c2 is measured, not transcribed from a Taylor expansion done by hand: + # a verification script carrying my own derived constant would be checking + # my arithmetic against itself. + for name, S in (("1/(1+z^2)", RAT_SQ), ("exp(-z^2)", EXP_SQ), + ("1/sqrt(1+z^2)", COSINE)): + h = 1e-4 + c2 = (1.0 - S(h)) / (h * h) + pred = sig * sig / (c2 * fp * fp * D) + meas = 4000 * seqs[name][4000] + print(f" {name:14s} predicted n.e_n -> {pred:7.4f} " + f"measured at n=4000: {meas:7.4f}") + + print("\n" + "=" * 76) + print("E. the order of the three-point rule") + print("=" * 76) + print(" Newton with a derivative estimate of error O(h^2):") + print(" e' = e - f/f-hat = e - (e - c e^2 + ...)(1 + O(e^2)) = c e^2") + print(" so the order is 2, not the 1.84 of Muller's method, which uses") + print(" the quadratic's ROOT rather than its DERIVATIVE.") + from simroot.pure import pure_root + from stage5_three_point import PROBLEMS, order_of + ps = [order_of(lambda f_, a_, b_, xt, mx: pure_root( + f_, a_, b_, 1e-12, 200, scale="derived3", guard="project"), + fn, aa, bb, rr) for _n, fn, aa, bb, rr in PROBLEMS] + ps = [p for p in ps if math.isfinite(p) and 0.5 < p < 5.0] + print(f" measured median over the eight problems: " + f"{sorted(ps)[len(ps) // 2]:.3f} predicted: 2") + + +if __name__ == "__main__": + main() diff --git a/stage11_crosscheck.py b/stage11_crosscheck.py new file mode 100644 index 0000000..105696b --- /dev/null +++ b/stage11_crosscheck.py @@ -0,0 +1,137 @@ +"""Stage 11 - are our implementations of the competitors faithful? + +The proposed rule's margin over Brent is 3% and over TOMS 748 is 0.5%, and +Chandrupatla's own algorithm - added on revision - now beats +both of them and us. A conclusion that rests on margins this small is only as +good as the competitors' implementations, so each is checked against SciPy's, +by evaluation count, problem by problem. + +SciPy references used: + brentq compiled C, same algorithm as our brent + toms748 pure Python, the one we already call + _chandrupatla pure Python, SciPy's implementation of the + method whose problem set is half this benchmark + +A disagreement in the count is not automatically a bug in ours - the stopping +rules differ in their relative-tolerance terms - so the comparison is reported +per problem and in aggregate, and the tolerances are set to make the two as +comparable as they can be. +""" +from __future__ import annotations + +import math +import sys + +import numpy as np +from scipy.optimize import brentq +from scipy.optimize._chandrupatla import _chandrupatla +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from simroot.baselines import Counter, _Budget, brent, chandrupatla, toms748 + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 + + +def load(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(("APS", d["ID"], + (lambda ff, aa: lambda x: ff(x, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(("CHA", d["ID"], (lambda ff: lambda x: ff(x))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +def counted(f): + st = {"n": 0} + + def g(x): + st["n"] += 1 + return f(x) + + return g, st + + +def scipy_brentq(f, a, b): + g, st = counted(f) + try: + x = brentq(g, a, b, xtol=XTOL, rtol=8.9e-16, maxiter=MAXFEV) + return x, st["n"], True + except Exception: + return float("nan"), st["n"], False + + +def scipy_chandrupatla(f, a, b): + g, st = counted(f) + + def vec(x): + return np.asarray([g(float(xi)) for xi in np.atleast_1d(x)]).reshape( + np.shape(x)) + + try: + res = _chandrupatla(vec, a, b, xatol=XTOL, xrtol=8.9e-16, + fatol=0.0, frtol=0.0, maxiter=MAXFEV) + return float(np.asarray(res.x).ravel()[0]), st["n"], bool( + np.all(np.asarray(res.success))) + except Exception: + return float("nan"), st["n"], False + + +def main(): + probs = load() + pairs = [ + ("brent", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV), scipy_brentq, + "scipy.brentq (C)"), + ("chandrupatla", + lambda f, a, b: chandrupatla(f, a, b, XTOL, MAXFEV), + scipy_chandrupatla, "scipy._chandrupatla"), + ] + for name, mine, theirs, label in pairs: + print("=" * 78, flush=True) + print(f"{name} : ours against {label}", flush=True) + print("=" * 78, flush=True) + t_mine = t_theirs = 0 + ok_mine = ok_theirs = 0 + diffs = [] + for _s, pid, f, a, b, root in probs: + xm, nm, cm = mine(f, a, b) + xt, nt, ct = theirs(f, a, b) + gm = bool(cm and math.isfinite(xm) and abs(xm - root) <= ACC) + gt = bool(ct and math.isfinite(xt) and abs(xt - root) <= ACC) + t_mine += nm if gm else MAXFEV + t_theirs += nt if gt else MAXFEV + ok_mine += gm + ok_theirs += gt + if gm and gt and nm != nt: + diffs.append((pid, nm, nt)) + print(f" ours : {ok_mine}/{len(probs)} solved, {t_mine} evaluations", + flush=True) + print(f" theirs : {ok_theirs}/{len(probs)} solved, {t_theirs} " + f"evaluations", flush=True) + print(f" problems where the counts differ: {len(diffs)} of " + f"{len(probs)}", flush=True) + if diffs: + worse = sum(1 for _p, nm, nt in diffs if nm > nt) + print(f" ours dearer on {worse}, cheaper on " + f"{len(diffs) - worse}", flush=True) + diffs.sort(key=lambda t: abs(t[1] - t[2]), reverse=True) + for pid, nm, nt in diffs[:8]: + print(f" {pid:12s} ours {nm:>4d} theirs {nt:>4d}", + flush=True) + rel = abs(t_mine - t_theirs) / max(t_theirs, 1) + verdict = ("faithful" if rel < 0.05 and abs(ok_mine - ok_theirs) <= 1 + else "SUSPECT - the paper must not lean on this competitor") + print(f" aggregate difference {rel * 100:.1f}% => {verdict}\n", + flush=True) + + +if __name__ == "__main__": + main() diff --git a/stage12_validation.py b/stage12_validation.py new file mode 100644 index 0000000..39999fc --- /dev/null +++ b/stage12_validation.py @@ -0,0 +1,254 @@ +"""Stage 12 - the validation runs added on revision. + +Five independent questions, each printed as it completes so the log can be +read at any moment: + + 1. RE-RANKING with the baselines that were missing - Chandrupatla's own + method and Dekker - against the proposed rule. + 2. STABILITY to arithmetic noise. The margin over TOMS 748 is 0.5% and the + paper itself reports that libm moves counts by a unit between platforms. + Every f is perturbed by +-1 ulp at random, and the distribution of the + total is reported for each method. Without this, "a tie" is rhetoric. + 3. THE BUDGET MULTIPLIER. The method fixes it at 2 and argues that 1 is + degenerate. Showing 1 fails is not showing 2 is right; the sweep over + 1, 1.25, 1.5, 2, 3, 4 answers whether the result is flat in it. + 4. A LARGER EVALUATION BUDGET. On Chandrupatla the guarantee alone can + reach 160 evaluations against a budget of 200, so some "failures" may be + the budget rather than the method. Re-run at 400. + 5. STATISTICS. A sum of 2806 against 2820 is 14 evaluations over 154 + problems. The head-to-head count gets an exact sign test and the total + gets a bootstrap interval, so that "tie" and "win" are separated by + evidence rather than by wording. + +Seeded; the seed is printed. Nothing here selects a configuration. +""" +from __future__ import annotations + +import math +import random +import sys +import time + +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from simroot.baselines import (anderson_bjorck, best_of, bisection, brent, + brent_scipy, chandrupatla, chandrupatla_scipy, + dekker, itp, ridders, toms748) +from simroot.pure import pure_root + +XTOL = 1e-12 +ACC = 1e-6 +SEED = 20260824 + + +def ours(f, a, b, xtol, maxfev, budget_factor=2.0): + return pure_root(f, a, b, xtol, maxfev, similarity="ratio", + scale="derived3", guard="project", + budget_factor=budget_factor) + + +# Competitors are taken at the better of SciPy's implementation and ours, +# problem by problem, so no result can be attributed to a weak reimplementation. +# ITP has no library version, which is why it is validated against its own +# theorem instead; the false-position family and bisection are not in SciPy. +METHODS = [ + ("OURS (similarity)", ours), + ("chandrupatla", best_of(chandrupatla, chandrupatla_scipy)), + ("toms748 (scipy)", toms748), + ("brent", best_of(brent, brent_scipy)), + ("itp", itp), + ("ridders", ridders), + ("anderson_bjorck", anderson_bjorck), + ("dekker", dekker), + ("bisection", bisection), +] + + +def load(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(("APS", d["ID"], + (lambda ff, aa: lambda x: ff(x, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(("CHA", d["ID"], (lambda ff: lambda x: ff(x))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +def per_problem(method, probs, maxfev): + """Charged evaluation count per problem, and whether it was solved.""" + out = {} + for _s, pid, f, a, b, root in probs: + try: + x, n, conv = method(f, a, b, XTOL, maxfev) + except Exception: + x, n, conv = float("nan"), maxfev, False + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + out[pid] = (n if ok else maxfev, ok) + return out + + +def totals(per, probs): + t = {"APS": 0, "CHA": 0} + ok = {"APS": 0, "CHA": 0} + for s, pid, *_ in probs: + t[s] += per[pid][0] + ok[s] += per[pid][1] + return t, ok + + +def section(n, title): + print("\n" + "=" * 78, flush=True) + print(f"{n}. {title}", flush=True) + print("=" * 78, flush=True) + + +def main(): + probs = load() + t0 = time.time() + print(f"seed {SEED}; {len(probs)} problems; started", flush=True) + + # ------------------------------------------------------------------ + section(1, "RE-RANKING WITH THE MISSING BASELINES") + base = {} + for name, m in METHODS: + p = per_problem(m, probs, 200) + base[name] = p + t, ok = totals(p, probs) + print(f" {name:22s} APS {t['APS']:>6d} {ok['APS']:>3d}/154 " + f"CHA {t['CHA']:>6d} {ok['CHA']:>3d}/45 " + f"both {t['APS'] + t['CHA']:>6d}", flush=True) + + # ------------------------------------------------------------------ + section(2, "STABILITY TO +-1 ULP PERTURBATION OF f") + rng = random.Random(SEED) + REAL = 40 + print(f" {REAL} realisations, every evaluation of f nudged one ulp " + f"either way\n", flush=True) + + def perturb(f, r): + # The nudge is CACHED per abscissa. Drawing it afresh on every call + # would model a noisy function rather than one computed to within an + # ulp, and would penalise any method that asks about a point twice. + seen = {} + + def g(x): + if x in seen: + return seen[x] + v = f(x) + if v != 0.0 and math.isfinite(v): + v = math.nextafter(v, math.inf if r.random() < 0.5 + else -math.inf) + seen[x] = v + return v + + return g + + dist = {name: [] for name, _ in METHODS} + for k in range(REAL): + r = random.Random(SEED + k) + pp = [(s, pid, perturb(f, r), a, b, root) + for s, pid, f, a, b, root in probs] + for name, m in METHODS: + t, _ok = totals(per_problem(m, pp, 200), pp) + dist[name].append(t["APS"] + t["CHA"]) + if (k + 1) % 5 == 0: + print(f" ... {k + 1}/{REAL} realisations, " + f"{time.time() - t0:.0f}s", flush=True) + print(f"\n {'method':22s}{'min':>8s}{'median':>9s}{'max':>8s}" + f"{'spread':>9s}{'unperturbed':>13s}", flush=True) + print(" " + "-" * 70, flush=True) + for name, _m in METHODS: + v = sorted(dist[name]) + t, _ = totals(base[name], probs) + print(f" {name:22s}{v[0]:>8d}{v[len(v) // 2]:>9d}{v[-1]:>8d}" + f"{v[-1] - v[0]:>9d}{t['APS'] + t['CHA']:>13d}", flush=True) + print("\n If the spread of a method is comparable to the gap between two" + "\n methods, that gap is not a result.", flush=True) + + # ------------------------------------------------------------------ + section(3, "IS THE BUDGET MULTIPLIER 2 LOAD-BEARING?") + print(f" {'factor':>8s}{'APS':>9s}{'APS ok':>9s}{'CHA':>9s}" + f"{'CHA ok':>9s}{'both':>9s}", flush=True) + print(" " + "-" * 54, flush=True) + for fac in (1.0, 1.25, 1.5, 2.0, 3.0, 4.0): + p = per_problem(lambda f, a, b, xt, mx, _f=fac: ours(f, a, b, xt, mx, _f), + probs, 200) + t, ok = totals(p, probs) + mark = " <- the method" if fac == 2.0 else "" + print(f" {fac:>8.2f}{t['APS']:>9d}{ok['APS']:>6d}/154" + f"{t['CHA']:>9d}{ok['CHA']:>6d}/45" + f"{t['APS'] + t['CHA']:>9d}{mark}", flush=True) + + # ------------------------------------------------------------------ + section(4, "A LARGER EVALUATION BUDGET (400 INSTEAD OF 200)") + print(f" {'method':22s}{'solved@200':>12s}{'solved@400':>12s}" + f"{'evals@400':>12s}", flush=True) + print(" " + "-" * 60, flush=True) + for name, m in METHODS: + p4 = per_problem(m, probs, 400) + t4, ok4 = totals(p4, probs) + _t2, ok2 = totals(base[name], probs) + print(f" {name:22s}{ok2['APS'] + ok2['CHA']:>9d}/199" + f"{ok4['APS'] + ok4['CHA']:>9d}/199" + f"{t4['APS'] + t4['CHA']:>12d}", flush=True) + + # ------------------------------------------------------------------ + section(5, "STATISTICS ON THE MARGINS") + ourp = base["OURS (similarity)"] + + def sign_test(w, l): + n = w + l + if n == 0: + return 1.0 + k = min(w, l) + p = sum(math.comb(n, i) for i in range(k + 1)) / 2.0 ** n + return min(1.0, 2.0 * p) + + print(f" {'competitor':18s}{'W/T/L':>14s}{'sign test p':>14s}" + f"{'total diff':>13s}{'bootstrap 95%':>22s}", flush=True) + print(" " + "-" * 82, flush=True) + for name, _m in METHODS: + if name.startswith("OURS"): + continue + opp = base[name] + w = t_ = l = 0 + diffs = [] + for _s, pid, *_ in probs: + (no, oko), (nc, okc) = ourp[pid], opp[pid] + if not (oko and okc): + continue + diffs.append(no - nc) + if no < nc: + w += 1 + elif no > nc: + l += 1 + else: + t_ += 1 + if not diffs: + continue + p = sign_test(w, l) + tot = sum(diffs) + r = random.Random(SEED) + boots = [] + for _ in range(4000): + boots.append(sum(diffs[r.randrange(len(diffs))] + for _ in range(len(diffs)))) + boots.sort() + lo, hi = boots[int(0.025 * len(boots))], boots[int(0.975 * len(boots))] + print(f" {name:18s}{f'{w}/{t_}/{l}':>14s}{p:>14.2e}" + f"{tot:>13d}{f'[{lo}, {hi}]':>22s}", flush=True) + print("\n Negative total difference means we spend fewer evaluations.", + flush=True) + print(" An interval straddling zero means the totals are indistinguishable.", + flush=True) + print(f"\nfinished in {time.time() - t0:.0f}s", flush=True) + + +if __name__ == "__main__": + main() diff --git a/stage13_verdict.py b/stage13_verdict.py new file mode 100644 index 0000000..73a24f6 --- /dev/null +++ b/stage13_verdict.py @@ -0,0 +1,267 @@ +"""Stage 13 - the whole thing recomputed, asking one question: + + is there ANY axis on which this method is ahead? + +The ranking tables became unreadable because 216 of the 228 configurations in +them are variants of our own idea, so a place number says almost nothing. +Here the field is the proposed rule and the real competitors only, and every +axis ends in a plain verdict: AHEAD, LEVEL or BEHIND. + +"LEVEL" is not a courtesy. It means the gap is inside the spread measured by +perturbing every evaluation of f by one ulp - if arithmetic noise can move the +total by more than the gap, the gap is not a result. + +Axes: + A evaluations of f, each set and both + B problems solved + C head to head, problem by problem, with an exact sign test + D worst single problem + E robustness to +-1 ulp + F worst-case guarantee + G free constants, counted honestly for every method including ours + H wall-clock time +""" +from __future__ import annotations + +import math +import random +import time + +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from simroot.baselines import (best_of, bisection, brent, brent_scipy, + chandrupatla, chandrupatla_scipy, itp, ridders, + toms748) +from simroot.pure import pure_root + +XTOL, MAXFEV, ACC = 1e-12, 200, 1e-6 +SEED = 20260824 +REAL = 40 + + +def ours(f, a, b, xtol, maxfev): + return pure_root(f, a, b, xtol, maxfev, similarity="ratio", + scale="derived3", guard="credit") + + +OURS = "OURS" +FIELD = [ + (OURS, ours), + ("chandrupatla", best_of(chandrupatla, chandrupatla_scipy)), + ("toms748", toms748), + ("brent", best_of(brent, brent_scipy)), + ("itp", itp), + ("ridders", ridders), + ("bisection", bisection), +] + +# Counted by reading each method's definition, and counted the same way for +# ours. A constant is free if changing it leaves a working method whose +# performance differs - i.e. if it had to be picked. +CONSTANTS = { + OURS: (0, "the credit endowment is one unconstrained step, not a " + "number: every value in (0,1] promises the same bisection+1 " + "bound and 1 is the cheapest of them, while 0 locks the " + "mechanism into bisection for ever"), + "chandrupatla": (0, "the acceptance test is derived from where inverse " + "quadratic interpolation stays inside the bracket"), + "toms748": (2, "the interpolation order schedule and mu"), + "brent": (3, "three empirical acceptance inequalities"), + "itp": (3, "kappa1, kappa2, n0"), + "ridders": (0, "none"), + "bisection": (0, "none"), +} +GUARANTEE = { + OURS: "bisection + 1 step", + "chandrupatla": "bisection-bounded by construction", + "toms748": "bisection-bounded", + "brent": "quadratic in the bisection count", + "itp": "bisection + n0, optimal minmax", + "ridders": "bisection-bounded", + "bisection": "exactly the bisection bound", +} + + +def load(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(("APS", d["ID"], + (lambda ff, aa: lambda x: ff(x, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(("CHA", d["ID"], (lambda ff: lambda x: ff(x))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +def run(method, probs, maxfev=MAXFEV): + per = {} + for _s, pid, f, a, b, root in probs: + try: + x, n, conv = method(f, a, b, XTOL, maxfev) + except Exception: + x, n, conv = float("nan"), maxfev, False + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + per[pid] = (n if ok else maxfev, ok, n) + return per + + +def sums(per, probs): + t = {"APS": 0, "CHA": 0} + ok = {"APS": 0, "CHA": 0} + for s, pid, *_ in probs: + t[s] += per[pid][0] + ok[s] += per[pid][1] + return t, ok + + +def sign_p(w, l): + n = w + l + if n == 0: + return 1.0 + k = min(w, l) + return min(1.0, 2.0 * sum(math.comb(n, i) for i in range(k + 1)) / 2.0 ** n) + + +def verdict(ours_v, other_v, noise, lower_is_better=True): + d = ours_v - other_v + if abs(d) <= noise: + return "LEVEL" + if (d < 0) == lower_is_better: + return "AHEAD" + return "BEHIND" + + +def main(): + probs = load() + t0 = time.time() + print(f"{len(probs)} problems; competitors only; seed {SEED}\n", flush=True) + + per = {n: run(m, probs) for n, m in FIELD} + tot = {n: sums(per[n], probs) for n, _ in FIELD} + + # ---- E first: the noise floor, because every verdict needs it ------ + print("Measuring the noise floor (+-1 ulp, " + f"{REAL} realisations)...", flush=True) + spread = {} + for name, m in FIELD: + vals = [] + for k in range(REAL): + r = random.Random(SEED + k) + + def perturb(f, rr=r): + seen = {} + + def g(x): + if x not in seen: + v = f(x) + if v != 0.0 and math.isfinite(v): + v = math.nextafter( + v, math.inf if rr.random() < 0.5 else -math.inf) + seen[x] = v + return seen[x] + return g + + pp = [(s, pid, perturb(f), a, b, root) + for s, pid, f, a, b, root in probs] + t, _ = sums(run(m, pp), pp) + vals.append(t["APS"] + t["CHA"]) + spread[name] = max(vals) - min(vals) + print(f" {name:14s} spread {spread[name]:>5d} " + f"({time.time() - t0:.0f}s)", flush=True) + noise = spread[OURS] + print(f"\n our own spread is {noise} evaluations; any gap smaller than " + f"that is\n not a result, and is called LEVEL below.\n", flush=True) + + ot, ook = tot[OURS] + ours_both = ot["APS"] + ot["CHA"] + + print("=" * 92, flush=True) + print("THE VERDICT, AXIS BY AXIS", flush=True) + print("=" * 92, flush=True) + print(f"{'competitor':14s}{'A evals both':>14s}{'verdict':>9s}" + f"{'A APS':>8s}{'verdict':>9s}{'A CHA':>8s}{'verdict':>9s}" + f"{'B solved':>10s}{'G consts':>10s}", flush=True) + print("-" * 92, flush=True) + print(f"{OURS:14s}{ours_both:>14d}{'-':>9s}{ot['APS']:>8d}{'-':>9s}" + f"{ot['CHA']:>8d}{'-':>9s}" + f"{ook['APS'] + ook['CHA']:>7d}/199{CONSTANTS[OURS][0]:>10d}", + flush=True) + for name, _m in FIELD: + if name == OURS: + continue + t, ok = tot[name] + both = t["APS"] + t["CHA"] + print(f"{name:14s}{both:>14d}" + f"{verdict(ours_both, both, noise):>9s}" + f"{t['APS']:>8d}{verdict(ot['APS'], t['APS'], noise):>9s}" + f"{t['CHA']:>8d}{verdict(ot['CHA'], t['CHA'], noise):>9s}" + f"{ok['APS'] + ok['CHA']:>7d}/199{CONSTANTS[name][0]:>10d}", + flush=True) + + print("\n" + "=" * 92, flush=True) + print("C HEAD TO HEAD, and D WORST SINGLE PROBLEM", flush=True) + print("=" * 92, flush=True) + # The worst single problem must be taken over the problems BOTH solve. + # Over all problems it is the evaluation cap for every method, so the axis + # would report the budget rather than the methods - it did, 200 against + # 200 for all six. + print(f"{'competitor':14s}{'W/T/L':>14s}{'sign p':>11s}{'verdict':>10s}" + f"{'their worst':>13s}{'our worst':>11s}{'verdict':>10s}", flush=True) + print("-" * 92, flush=True) + for name, _m in FIELD: + if name == OURS: + continue + w = t_ = l = 0 + ow = tw = 0 + for _s, pid, *_ in probs: + (no, oko, _), (nc, okc, _) = per[OURS][pid], per[name][pid] + if not (oko and okc): + continue + ow = max(ow, no) + tw = max(tw, nc) + if no < nc: + w += 1 + elif no > nc: + l += 1 + else: + t_ += 1 + p = sign_p(w, l) + v = ("LEVEL" if p > 0.05 else ("AHEAD" if w > l else "BEHIND")) + print(f"{name:14s}{f'{w}/{t_}/{l}':>14s}{p:>11.2e}{v:>10s}" + f"{tw:>13d}{ow:>11d}" + f"{verdict(ow, tw, 0):>10s}", flush=True) + + print("\n" + "=" * 92, flush=True) + print("E ROBUSTNESS, F GUARANTEE, G WHAT EACH METHOD HAD TO CHOOSE", + flush=True) + print("=" * 92, flush=True) + for name, _m in FIELD: + c, why = CONSTANTS[name] + print(f" {name:14s} spread {spread[name]:>5d} " + f"constants {c} guarantee: {GUARANTEE[name]}", flush=True) + print(f" {'':14s} {why}", flush=True) + + print("\n" + "=" * 92, flush=True) + print("SUMMARY", flush=True) + print("=" * 92, flush=True) + ahead, level, behind = [], [], [] + for name, _m in FIELD: + if name == OURS: + continue + both = tot[name][0]["APS"] + tot[name][0]["CHA"] + v = verdict(ours_both, both, noise) + (ahead if v == "AHEAD" else level if v == "LEVEL" else behind).append(name) + print(f" by total evaluations over both sets:", flush=True) + print(f" ahead of : {', '.join(ahead) or 'nobody'}", flush=True) + print(f" level with: {', '.join(level) or 'nobody'}", flush=True) + print(f" behind : {', '.join(behind) or 'nobody'}", flush=True) + print(f"\nfinished in {time.time() - t0:.0f}s", flush=True) + + +if __name__ == "__main__": + main() diff --git a/stage14_is_anything_reusable.py b/stage14_is_anything_reusable.py new file mode 100644 index 0000000..0890cb6 --- /dev/null +++ b/stage14_is_anything_reusable.py @@ -0,0 +1,186 @@ +"""Stage 14 - is anything here reusable, or is the whole thing subsumed? + +Chandrupatla's method (1997) beats the proposed rule on every axis measured: +5208 evaluations against 6588, worst single problem 82 against 83, zero free +constants against zero, an ulp spread of 2 against 144, the same 193 of 199 +solved. As a one-dimensional root finder this work is not needed. + +So the question becomes what, if anything, survives on its own. The candidate +is the CREDIT SAFEGUARD, which has nothing to do with similarity: it is a way +to give ANY interpolating step rule a bisection+1 worst case without a single +constant. If it only works with our step, it is a detail of a redundant +method. If it converts other unsafe rules into safe ones, it is a separate +contribution and belongs in a separate paper. + +The test: take step rules that are known to be fast but unsafe, wrap each in +the credit safeguard, and measure what changes. + + regula falsi famously stalls; solves 127 of 154 here + secant not a bracketing method at all; can leave the bracket + inverse quadratic Brent's interpolation, unsafe on its own + +Each is run raw and credit-guarded, on the same 199 problems. +""" +from __future__ import annotations + +import math + +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from simroot.baselines import Counter, _Budget, chandrupatla +from simroot.pure import _Safeguard + +XTOL, MAXFEV, ACC = 1e-12, 200, 1e-6 + + +# -------------------------------------------------------------------------- +# step rules: given the bracket and the recent history, propose the next x +# -------------------------------------------------------------------------- +def rule_falsi(A, FA, B, FB, hist): + if FB == FA: + return None + return (A * FB - B * FA) / (FB - FA) + + +def rule_secant(A, FA, B, FB, hist): + """Uses the two most recent EVALUATIONS, not the bracket ends - so it is + not a bracketing rule and on its own may leave the interval.""" + if len(hist) < 2: + return rule_falsi(A, FA, B, FB, hist) + (x1, f1), (x0, f0) = hist[-1], hist[-2] + if f1 == f0: + return None + return x1 - f1 * (x1 - x0) / (f1 - f0) + + +def rule_iqi(A, FA, B, FB, hist): + """Inverse quadratic interpolation through the last three evaluations.""" + if len(hist) < 3: + return rule_secant(A, FA, B, FB, hist) + (x2, f2), (x1, f1), (x0, f0) = hist[-1], hist[-2], hist[-3] + if len({f0, f1, f2}) < 3: + return rule_secant(A, FA, B, FB, hist) + try: + return (x0 * f1 * f2 / ((f0 - f1) * (f0 - f2)) + + x1 * f0 * f2 / ((f1 - f0) * (f1 - f2)) + + x2 * f0 * f1 / ((f2 - f0) * (f2 - f1))) + except ZeroDivisionError: + return rule_secant(A, FA, B, FB, hist) + + +RULES = [("regula falsi", rule_falsi), ("secant", rule_secant), + ("inverse quadratic", rule_iqi)] + + +def solve(f, a, b, xtol, maxfev, rule, guarded): + """One driver, two modes: the raw rule with only a bracket clamp, or the + same rule with the credit safeguard on top. Nothing else differs.""" + g = Counter(f, maxfev) + x = 0.5 * (a + b) + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + if fa * fb > 0.0: + raise ValueError("no sign change") + A, FA, B, FB = a, fa, b, fb + hist = [(a, fa), (b, fb)] + sg = _Safeguard("credit", abs(b - a), xtol) + while abs(B - A) > xtol: + lo, hi = min(A, B), max(A, B) + x_new = rule(A, FA, B, FB, hist) + if x_new is None or not math.isfinite(x_new): + x_new = 0.5 * (A + B) + if guarded: + x_new = sg.project_credit(x_new, lo, hi) + if not (lo < x_new < hi): + x_new = 0.5 * (A + B) + if any(x_new == t for t, _ in hist[-3:]): + x_new = 0.5 * (A + B) + if any(x_new == t for t, _ in hist[-3:]): + return x_new, g.n, abs(B - A) <= xtol + w_before = abs(B - A) + fn = g(x_new) + hist.append((x_new, fn)) + x = x_new + if fn == 0.0: + return x_new, g.n, True + if FA * fn < 0.0: + B, FB = x_new, fn + else: + A, FA = x_new, fn + if guarded: + sg.note_shrink(w_before, abs(B - A)) + return 0.5 * (A + B), g.n, True + except _Budget: + return x, g.n, False + + +def load(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(((lambda ff, aa: lambda t: ff(t, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(((lambda ff: lambda t: ff(t))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +def measure(rule, guarded, probs): + total = solved = 0 + worst = 0 + for f, a, b, root in probs: + try: + x, n, conv = solve(f, a, b, XTOL, MAXFEV, rule, guarded) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + total += n if ok else MAXFEV + solved += ok + if ok: + worst = max(worst, n) + return total, solved, worst + + +def main(): + probs = load() + print(f"{len(probs)} problems; the credit safeguard applied to step rules " + f"it was not designed for\n") + print(f"{'step rule':22s}{'':4s}{'evals':>9s}{'solved':>10s}" + f"{'worst':>8s}") + print("-" * 56) + for name, rule in RULES: + for guarded in (False, True): + t, s, w = measure(rule, guarded, probs) + tag = "guarded" if guarded else "raw" + print(f"{name:22s}{tag:>8s}{t:>9d}{s:>7d}/199{w:>8d}", flush=True) + print() + + t, s, w = measure(lambda A, FA, B, FB, h: None, True, probs) + print(f"{'(bisection: the rule that proposes nothing)':44s}" + f"{t:>9d}{s:>7d}/199{w:>8d}") + tc = sc = wc = 0 + for f, a, b, root in probs: + x, n, conv = chandrupatla(f, a, b, XTOL, MAXFEV) + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + tc += n if ok else MAXFEV + sc += ok + if ok: + wc = max(wc, n) + print(f"{'(chandrupatla, for scale)':44s}{tc:>9d}{sc:>7d}/199{wc:>8d}") + + print("\nWhat to look for: if a raw rule that fails many problems becomes" + "\none that solves 193 with a worst case near bisection's, the" + "\nsafeguard is a contribution independent of everything else here." + "\nIf the guarded numbers merely track the raw ones, it is not.") + + +if __name__ == "__main__": + main() diff --git a/stage15_ode.py b/stage15_ode.py new file mode 100644 index 0000000..c3f27cc --- /dev/null +++ b/stage15_ode.py @@ -0,0 +1,189 @@ +"""Stage 15 - the credit rule in a second domain: ODE step-size control. + +The root-finding work ended with one transferable object, the credit +safeguard, and one honest conclusion: as a one-dimensional root finder the +method is subsumed by Chandrupatla 1997. Adaptive step-size control is the +natural place to test whether the transferable object transfers, because it +has the same shape - propose a bold step, look at the outcome, adjust - and +because every practical controller in it is made of constants somebody chose. + + classical scipy's own: safety 0.9, clamps 0.2 and 10 3 constants + PI the same plus two gains 5 constants + elementary what the error model alone dictates 0 constants + measured the safety factor MEASURED instead of chosen 0 constants + +Everything except the controller comes from SciPy: the RK45 tableau, the +stage combination and the embedded error estimate, via +scipy.integrate._ivp.rk. The driver is checked against solve_ivp(RK45) with +the same control law before any comparison is made. A difference between two +rows can only come from the controller. + +Cost model: evaluations of the right-hand side, as evaluations of f were in +the root-finding work. A run that does not reach the end of the interval is +a failure and is reported as one. Accuracy is checked against a reference so +that a controller cannot win by being fast and wrong. +""" +from __future__ import annotations + +import math + +from odestep.controllers import ALL +from odestep.driver import integrate, validate_against_scipy + +TOLS = (1e-4, 1e-6, 1e-8, 1e-10) + + +# -------------------------------------------------------------------------- +# problems: classics with known or high-accuracy reference endpoints +# -------------------------------------------------------------------------- +def p_decay(): + f = lambda t, y: [-y[0]] + return "exponential decay", f, 0.0, 10.0, [1.0], [math.exp(-10.0)] + + +def p_forced(): + f = lambda t, y: [-y[0] + math.sin(t)] + ex = 0.5 * (math.sin(10.0) - math.cos(10.0) + math.exp(-10.0)) + return "y' = -y + sin t", f, 0.0, 10.0, [0.0], [ex] + + +def p_lotka(): + def f(t, y): + return [1.5 * y[0] - y[0] * y[1], -3.0 * y[1] + y[0] * y[1]] + return "Lotka-Volterra", f, 0.0, 15.0, [10.0, 5.0], None + + +def p_vanderpol(mu=5.0): + def f(t, y): + return [y[1], mu * (1 - y[0] * y[0]) * y[1] - y[0]] + return f"van der Pol mu={mu:g}", f, 0.0, 25.0, [2.0, 0.0], None + + +def p_brusselator(): + def f(t, y): + return [1.0 + y[0] * y[0] * y[1] - 4.0 * y[0], + 3.0 * y[0] - y[0] * y[0] * y[1]] + return "Brusselator", f, 0.0, 20.0, [1.5, 3.0], None + + +def p_kepler(ecc): + """The two-body problem at eccentricity e - DETEST's D-class, the classic + hard non-stiff test: the solution has a sharp passage at perihelion.""" + def f(t, y): + x1, x2, v1, v2 = y + r3 = (x1 * x1 + x2 * x2) ** 1.5 + return [v1, v2, -x1 / r3, -x2 / r3] + y0 = [1.0 - ecc, 0.0, 0.0, math.sqrt((1 + ecc) / (1 - ecc))] + return f"Kepler e={ecc:g}", f, 0.0, 20.0, y0, None + + +def p_arenstorf(): + """The restricted three-body orbit, the standard showcase for adaptive + step control: the step must vary by orders of magnitude along the path.""" + mu = 0.012277471 + mp = 1.0 - mu + + def f(t, y): + y1, y2, y3, y4 = y + d1 = ((y1 + mu) ** 2 + y2 * y2) ** 1.5 + d2 = ((y1 - mp) ** 2 + y2 * y2) ** 1.5 + return [y3, y4, + y1 + 2 * y4 - mp * (y1 + mu) / d1 - mu * (y1 - mp) / d2, + y2 - 2 * y3 - mp * y2 / d1 - mu * y2 / d2] + y0 = [0.994, 0.0, 0.0, -2.00158510637908252240537862224] + return "Arenstorf orbit", f, 0.0, 17.0652165601579625588917206249, y0, y0 + + +PROBLEMS = [p_decay(), p_forced(), p_lotka(), p_vanderpol(), p_brusselator(), + p_kepler(0.5), p_kepler(0.9), p_arenstorf()] + + +def reference(f, t0, t1, y0): + """A reference endpoint from the same integrator at a far tighter + tolerance - not from a different code, so that a disagreement cannot be + blamed on a different method.""" + from odestep.controllers import Classical + r = integrate(f, t0, t1, y0, Classical(), atol=1e-13, rtol=1e-13, + max_steps=2000000) + return r["y"] if r["reached_end"] else None + + +def scaled_err(y, ref, atol, rtol): + """The achieved error in the SAME mixed norm the integrator controls. + + A purely relative criterion is wrong here and was: the decay problem ends + at exp(-10) ~ 4.5e-5, so at atol = 1e-4 the tolerance permits a hundred + per cent relative error, and a correct run was being marked as a failure. + What a run must be judged against is the accuracy it was asked for.""" + if ref is None: + return float("nan") + s = 0.0 + for a, b in zip(y, ref): + sc = atol + rtol * abs(b) + s += ((a - b) / sc) ** 2 + return math.sqrt(s / len(ref)) + + +def main(): + print("instrument check: the driver against scipy solve_ivp(RK45), " + "same control law") + worst = 0.0 + for name, mine, ref, d in validate_against_scipy(): + rel = abs(mine - ref) / ref + worst = max(worst, rel) + print(f" {name:10s} ours {mine:>6d} solve_ivp {ref:>6d} " + f"{100 * (mine - ref) / ref:+6.1f}% endpoint agrees to {d:.1e}") + if worst > 0.05: + print(" driver does NOT reproduce the library - stopping") + return + print(" the tableau, the stages and the error estimate are scipy's;") + print(" only the controller is ours\n") + + refs = {} + for name, f, t0, t1, y0, exact in PROBLEMS: + refs[name] = exact if exact is not None else reference(f, t0, t1, y0) + + grand = {c.name: [0, 0, 0] for c in ALL} # nfev, rejected, failures + for tol in TOLS: + print("=" * 96) + print(f"tolerance {tol:g} (atol = rtol = tol)") + print("=" * 96) + print(f"{'problem':22s}" + "".join(f"{c.name.split(' ')[0]:>15s}" + for c in ALL)) + print("-" * 96) + for name, f, t0, t1, y0, _exact in PROBLEMS: + cells = [] + for c in ALL: + r = integrate(f, t0, t1, y0, c, atol=tol, rtol=tol) + err = scaled_err(r["y"], refs[name], tol, tol) + # local error control does not bound the global error, so the + # bar is generous: a run fails only if it misses the accuracy + # it asked for by more than three orders of magnitude, or does + # not reach the end at all + bad = (not r["reached_end"]) or ( + math.isfinite(err) and err > 1000.0) + grand[c.name][0] += r["nfev"] + grand[c.name][1] += r["rejected"] + grand[c.name][2] += bad + cells.append(f"{r['nfev']:>9d}{'!' if bad else ' '}" + f"{r['rejected']:>4d}") + print(f"{name:22s}" + "".join(f"{c:>15s}" for c in cells)) + print() + + print("=" * 96) + print("TOTALS over every problem and tolerance " + "(nfev, rejected steps, failures)") + print("=" * 96) + print(f"{'controller':34s}{'constants':>11s}{'nfev':>10s}" + f"{'rejected':>11s}{'failures':>11s}") + print("-" * 96) + for c in ALL: + n, rej, bad = grand[c.name] + print(f"{c.name:34s}{c.constants:>11d}{n:>10d}{rej:>11d}{bad:>11d}") + print("\n'!' marks a run that did not reach the end or missed the " + "reference by more\nthan a thousand tolerances - a controller " + "cannot win by being fast and wrong.") + + +if __name__ == "__main__": + main() diff --git a/stage16_blend.py b/stage16_blend.py new file mode 100644 index 0000000..ee10320 --- /dev/null +++ b/stage16_blend.py @@ -0,0 +1,277 @@ +"""Stage 16 - similarity used to IMPROVE an existing method, not to replace it. + +Everything that worked in this project worked that way. The credit safeguard +did not produce a new root finder that beats the field; it took regula falsi, +the secant rule and inverse quadratic interpolation and made each of them +solve 193 of 199 with a near-bisection worst case. Building a method from +similarity landed second behind Chandrupatla 1997; grafting a measured +quantity onto existing methods was the part that paid. + +This stage tries the one graft that comes straight from the similarity +literature and has not been tried here: **similarity replaces a hard +partition by a graded weight**. + +Every strong bracketing method contains such a partition: + + Brent three empirical inequalities decide interpolation OR bisection + Chandrupatla the criterion 1-sqrt(1-xi) < phi < sqrt(xi) decides the same + +In both, the quantity being tested is continuous and the decision taken on it +is a step function. The similarity move is to keep the quantity and drop the +step: + + r = (how far outside the safe region the interpolation falls), 0 = safe + w = S(r), S the tent similarity, S(0) = 1, no constant + d = w * d_interpolation + (1 - w) * d_bisection + +At r = 0 this is exactly the original method. At r >= 1 it is exactly +bisection. In between, where the original flips discontinuously, it blends. + +The comparison is against the SAME implementation with the blend switched +off, so the difference can only be the blend. Our Brent is separately +validated against scipy.optimize.brentq to 0.2% of evaluations. +""" +from __future__ import annotations + +import math + +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from simroot.baselines import Counter, _Budget, brent, chandrupatla + +XTOL, MAXFEV, ACC = 1e-12, 200, 1e-6 + +# the tent similarity of the paper: S(0) = 1, S(1) = 0, no constant +TENT = lambda r: max(0.0, 1.0 - r) + + +def brent_blend(f, a, b, xtol, maxfev, mode="blend"): + """Brent's method with its accept/reject replaced by a similarity blend. + + The only change from simroot.baselines.brent is the four lines marked + below; with mode="off" the two are the same algorithm. mode is a name, not a + boolean carrying three states.""" + g = Counter(f, maxfev) + b_ = b + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + c, fc = a, fa + d = e = b - a + while True: + if fb * fc > 0.0: + c, fc = a, fa + d = e = b - a + if abs(fc) < abs(fb): + a, fa = b, fb + b, fb = c, fc + c, fc = a, fa + tol1 = 2.0 * 2.22e-16 * abs(b) + 0.5 * xtol + xm = 0.5 * (c - b) + if abs(xm) <= tol1 or fb == 0.0: + return b, g.n, True + if abs(e) >= tol1 and abs(fa) > abs(fb): + s = fb / fa + if a == c: + p = 2.0 * xm * s + q = 1.0 - s + else: + q = fa / fc + r = fb / fc + p = s * (2.0 * xm * q * (q - r) - (b - a) * (r - 1.0)) + q = (q - 1.0) * (r - 1.0) * (s - 1.0) + if p > 0.0: + q = -q + p = abs(p) + bound = min(3.0 * xm * q - abs(tol1 * q), abs(e * q)) + if mode == "project": + # The lesson from the root-finding safeguard, applied to + # somebody else's method: when the interpolation violates + # the safety condition, do not discard it and do not + # average it with the midpoint - keep as much of it as the + # condition allows, by clamping it to the boundary. + if 2.0 * p < bound: + e, d = d, p / q + elif bound > 0.0 and q != 0.0: + e, d = d, math.copysign(0.5 * bound / abs(q), + p / q if q else xm) + else: + d = e = xm + elif mode == "off": + if 2.0 * p < bound: + e, d = d, p / q + else: + d = e = xm + else: + # ---- the graft ------------------------------------- + # Brent's own test is 2p < bound. The ratio of the two + # is continuous; the decision on it is a step. Keep the + # ratio, weight by similarity, blend the two candidate + # steps. r = 0 reproduces Brent exactly, r >= 1 gives + # bisection exactly. + r_trust = (2.0 * p / bound) if bound > 0.0 else math.inf + w = TENT(r_trust) if math.isfinite(r_trust) else 0.0 + d_int = p / q if q != 0.0 else xm + e, d = d, w * d_int + (1.0 - w) * xm + # ---------------------------------------------------- + else: + d = e = xm + a, fa = b, fb + b = b + (d if abs(d) > tol1 else math.copysign(tol1, xm)) + b_ = b + fb = g(b) + except _Budget: + return b_, g.n, False + + +def chandrupatla_blend(f, a, b, xtol, maxfev, mode="blend"): + """Chandrupatla's method with its acceptance region softened the same way. + + Its test is 1 - sqrt(1-xi) < phi < sqrt(xi). The distance outside that + interval, scaled by its own width, is the continuous quantity; the + decision on it is a step.""" + g = Counter(f, maxfev) + x1, x2 = b, a + f1 = f2 = 0.0 + try: + f1, f2 = g(x1), g(x2) + if f1 == 0.0: + return x1, g.n, True + if f2 == 0.0: + return x2, g.n, True + x3, f3 = x2, f2 + t = 0.5 + while True: + x = x1 + t * (x2 - x1) + fx = g(x) + if (fx > 0.0) == (f1 > 0.0): + x3, f3 = x1, f1 + x1, f1 = x, fx + else: + x3, f3 = x2, f2 + x2, f2 = x1, f1 + x1, f1 = x, fx + xm, fm = (x1, f1) if abs(f1) < abs(f2) else (x2, f2) + if fm == 0.0: + return xm, g.n, True + tol = 2.0 * 2.22e-16 * abs(xm) + xtol + span = abs(x2 - x1) + if span == 0.0: + return xm, g.n, True + tl = tol / span + if tl > 0.5: + return xm, g.n, True + t = 0.5 + if x3 != x2 and f3 != f2: + xi = (x1 - x2) / (x3 - x2) + ph = (f1 - f2) / (f3 - f2) + if 0.0 < xi < 1.0: + lo = 1.0 - math.sqrt(1.0 - xi) + hi = math.sqrt(xi) + d1, d2, d3 = f1 - f2, f1 - f3, f2 - f3 + inside = lo < ph < hi + if d1 != 0.0 and d2 != 0.0 and d3 != 0.0: + t_iqi = ((f1 / d1) * (f3 / (-d3)) + + ((x3 - x1) / (x2 - x1)) * (f1 / d2) + * (f2 / d3)) + if mode == "off": + if inside: + t = t_iqi + else: + # distance outside the safe interval, in units of + # the interval's own width + width = hi - lo + if width > 0.0: + out = max(0.0, lo - ph, ph - hi) / width + w = TENT(out) + t = w * t_iqi + (1.0 - w) * 0.5 + elif inside: + t = t_iqi + if not math.isfinite(t): + t = 0.5 + t = min(max(t, tl), 1.0 - tl) + except _Budget: + return (x1 if abs(f1) < abs(f2) else x2), g.n, False + + +def load(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(("APS", (lambda ff, aa: lambda t: ff(t, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(("CHA", (lambda ff: lambda t: ff(t))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +def measure(method, probs): + t = {"APS": 0, "CHA": 0} + ok = {"APS": 0, "CHA": 0} + worst = 0 + for s, f, a, b, root in probs: + try: + x, n, conv = method(f, a, b, XTOL, MAXFEV) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + good = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + t[s] += n if good else MAXFEV + ok[s] += good + if good: + worst = max(worst, n) + return t, ok, worst + + +def main(): + probs = load() + rows = [ + ("brent, as published", lambda f, a, b, xt, mx: brent(f, a, b, xt, mx)), + ("brent, blend off (same code)", + lambda f, a, b, xt, mx: brent_blend(f, a, b, xt, mx, mode="off")), + ("brent + similarity blend", + lambda f, a, b, xt, mx: brent_blend(f, a, b, xt, mx, mode="blend")), + ("brent + projection onto the bound", + lambda f, a, b, xt, mx: brent_blend(f, a, b, xt, mx, + mode="project")), + ("chandrupatla, as published", + lambda f, a, b, xt, mx: chandrupatla(f, a, b, xt, mx)), + ("chandrupatla, blend off", + lambda f, a, b, xt, mx: chandrupatla_blend(f, a, b, xt, mx, + mode="off")), + ("chandrupatla + similarity blend", + lambda f, a, b, xt, mx: chandrupatla_blend(f, a, b, xt, mx, + mode="blend")), + ] + print(f"{'method':34s}{'APS':>8s}{'CHA':>8s}{'both':>8s}" + f"{'solved':>10s}{'worst':>8s}") + print("-" * 78) + base = {} + for name, m in rows: + t, ok, worst = measure(m, probs) + both = t["APS"] + t["CHA"] + base[name] = both + print(f"{name:34s}{t['APS']:>8d}{t['CHA']:>8d}{both:>8d}" + f"{ok['APS'] + ok['CHA']:>7d}/199{worst:>8d}", flush=True) + + print("\nThe two 'blend off' rows must reproduce the published methods -" + "\nif they do not, the blend is being compared against a different" + "\nalgorithm and the experiment is void.") + for pub, off, on in (("brent, as published", "brent, blend off (same code)", + "brent + similarity blend"), + ("chandrupatla, as published", "chandrupatla, blend off", + "chandrupatla + similarity blend")): + drift = abs(base[off] - base[pub]) / base[pub] + gain = (base[pub] - base[on]) / base[pub] + print(f"\n {pub.split(',')[0]:14s} control drift {drift * 100:5.2f}%" + f" blend changes the total by {gain * 100:+6.2f}%") + + +if __name__ == "__main__": + main() diff --git a/stage17_anc.py b/stage17_anc.py new file mode 100644 index 0000000..39e5468 --- /dev/null +++ b/stage17_anc.py @@ -0,0 +1,81 @@ +"""Stage 17 - the third domain: the step size of an adaptive noise canceller. + +Root finding: the method lands second behind Chandrupatla 1997. +ODE step control: level with a five-constant PI controller, behind the +three-constant classical one. +Softening somebody else's acceptance test: fails, three times over. + +Active noise control is the domain where the object we have - a step size +that is a safety factor on an exact step - is exactly the object the field +argues about, and where the standard answers are openly constant-ridden. + +The acoustic paths, the noise regimes and the scenarios come from our earlier +ANC benchmark (SEM repository, branch feature/sem-anc-benchmark), so the +environment is one that existed before this question was asked. + +Metric: noise reduction in dB on the second half of each run, so that the +adaptation transient is not counted. Higher is better. Ten seeds per cell. +""" +from __future__ import annotations + +import math + +import numpy as np + +from anc.bench import (FS, SCENARIOS, make_primary_path, make_secondary_path, + run_nlms) +from anc.rules import ALL + +N = 8000 # one second +SEEDS = 10 +SNRS = (30.0, 15.0) + + +def main(): + print(f"{len(SCENARIOS)} scenarios x {len(SNRS)} noise levels x {SEEDS} " + f"seeds, {N / FS:g} s each\n") + grand = {r.name: [] for r in ALL} + for snr in SNRS: + print("=" * 88) + print(f"reference SNR {snr:g} dB noise reduction, dB (higher is " + f"better)") + print("=" * 88) + print(f"{'scenario':22s}" + "".join(f"{r.name[:13]:>13s}" for r in ALL)) + print("-" * 88) + for sname, gen in SCENARIOS: + row = {r.name: [] for r in ALL} + for s in range(SEEDS): + rng = np.random.default_rng(1000 + s) + noise = gen(N, rng) + prim = make_primary_path(rng) + sec = make_secondary_path(rng) + for r in ALL: + nr = run_nlms(noise, prim, sec, r, snr_db=snr, seed=s) + if math.isfinite(nr): + row[r.name].append(nr) + grand[r.name].append(nr) + cells = [] + for r in ALL: + v = row[r.name] + cells.append(f"{(sum(v) / len(v)) if v else float('nan'):>13.2f}") + print(f"{sname:22s}" + "".join(cells), flush=True) + print() + + print("=" * 88) + print("OVERALL") + print("=" * 88) + print(f"{'rule':26s}{'constants':>11s}{'mean NR dB':>13s}" + f"{'worst cell':>13s}{'diverged':>11s}") + print("-" * 88) + for r in ALL: + v = grand[r.name] + n_bad = SEEDS * len(SCENARIOS) * len(SNRS) - len(v) + print(f"{r.name:26s}{r.constants:>11d}" + f"{(sum(v) / len(v)) if v else float('nan'):>13.2f}" + f"{min(v) if v else float('nan'):>13.2f}{n_bad:>11d}") + print("\n'diverged' counts runs whose residual power was not finite - the " + "failure mode\na step size that is too large actually produces.") + + +if __name__ == "__main__": + main() diff --git a/stage18_bulletproof.py b/stage18_bulletproof.py new file mode 100644 index 0000000..0b10214 --- /dev/null +++ b/stage18_bulletproof.py @@ -0,0 +1,228 @@ +"""Stage 18 - attack the two claims that look like wins. + +A claim is worth publishing only if it survives the objection a reader will +raise first. For each of the two candidate wins the objection is obvious, and +this file runs it rather than answering it in prose. + +CLAIM A. The credit safeguard rescues unsafe interpolation rules: regula +falsi goes from 133 solved and 18799 evaluations to 193 and 8056. + OBJECTION: nobody uses raw regula falsi. It has been fixed since 1971 - + Illinois, Pegasus, Anderson-Bjorck - and those fixes are the real + comparison. Beating the unfixed version proves nothing. + TEST: the same rule, the same driver, the same everything, with the + stale-endpoint correction swapped for each classical fix in turn and for + the credit projection. Only the repair differs. + +CLAIM B. In active noise control the measured step size beats Kwong-Johnston +by 7 dB. + OBJECTION: Kwong-Johnston's gains are scale-dependent, and yours are the + published defaults run on a signal they were not scaled for. Give it its + best constants and the gap will close. + TEST: an oracle over its (alpha, gamma) grid, chosen separately for every + scenario - not an achievable controller, exactly as the ITP oracle in the + root-finding work was not. +""" +from __future__ import annotations + +import math + +import numpy as np +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from anc.bench import SCENARIOS, make_primary_path, make_secondary_path, run_nlms +from anc.rules import Fixed, KwongJohnston, Measured, Rule +from simroot.baselines import Counter, _Budget +from simroot.pure import _Safeguard + +XTOL, MAXFEV, ACC = 1e-12, 200, 1e-6 + + +# ========================================================================== +# CLAIM A: the credit projection against the classical repairs of regula falsi +# ========================================================================== +def falsi_driver(f, a, b, xtol, maxfev, repair): + """Regula falsi with a pluggable repair for the stale endpoint. + + Everything is shared: the interpolation, the bracket update, the budget, + the duplicate handling. `repair` is the only difference, so a difference + in the result cannot come from anywhere else. + + "none" the unfixed rule + "illinois" halve the stale ordinate (Hafner/Dowell 1971) + "pegasus" f * fx / (fx + f_new) (Dowell/Jarratt 1972) + "anderson" f * (1 - f_new/f_moved) (Anderson/Bjorck 1973) + "credit" leave the ordinates alone; project the step onto the + interval the earned bisection budget allows + """ + g = Counter(f, maxfev) + x = 0.5 * (a + b) + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + if fa * fb > 0.0: + raise ValueError("no sign change") + sg = _Safeguard("credit", abs(b - a), xtol) + while abs(b - a) > xtol: + lo, hi = (a, b) if a < b else (b, a) + denom = fb - fa + x_new = 0.5 * (a + b) if denom == 0.0 else (a * fb - b * fa) / denom + if repair == "credit": + x_new = sg.project_credit(x_new, lo, hi) + if not math.isfinite(x_new) or not (lo < x_new < hi): + x_new = 0.5 * (a + b) + if x_new in (a, b): + x_new = 0.5 * (a + b) + if x_new in (a, b): + return x_new, g.n, abs(b - a) <= xtol + w_before = abs(b - a) + fx = g(x_new) + if fx == 0.0: + return x_new, g.n, True + if fa * fx < 0.0: + if repair == "illinois": + fa *= 0.5 + elif repair == "pegasus": + fa = fa * fb / (fb + fx) + elif repair == "anderson": + m = 1.0 - fx / fb + fa = fa * (m if m > 0.0 else 0.5) + b, fb = x_new, fx + else: + if repair == "illinois": + fb *= 0.5 + elif repair == "pegasus": + fb = fb * fa / (fa + fx) + elif repair == "anderson": + m = 1.0 - fx / fa + fb = fb * (m if m > 0.0 else 0.5) + a, fa = x_new, fx + if repair == "credit": + sg.note_shrink(w_before, abs(b - a)) + x = x_new + return 0.5 * (a + b), g.n, True + except _Budget: + return x, g.n, False + + +def load_roots(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(((lambda ff, aa: lambda t: ff(t, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(((lambda ff: lambda t: ff(t))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +def claim_a(): + probs = load_roots() + print("=" * 84) + print("CLAIM A - the credit projection against the classical repairs") + print("=" * 84) + print("same interpolation, same driver, same budget; only the repair " + "differs\n") + print(f"{'repair':16s}{'year':>7s}{'evals':>10s}{'solved':>10s}" + f"{'worst':>8s}{'over bisect+3':>15s}") + print("-" * 84) + rows = {} + for repair, year in (("none", "300 BC"), ("illinois", "1971"), + ("pegasus", "1972"), ("anderson", "1973"), + ("credit", "here")): + total = solved = worst = over = 0 + for f, a, b, root in probs: + try: + x, n, conv = falsi_driver(f, a, b, XTOL, MAXFEV, repair) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + total += n if ok else MAXFEV + solved += ok + if ok: + worst = max(worst, n) + if n > math.ceil(math.log2(abs(b - a) / XTOL)) + 4: + over += 1 + rows[repair] = (total, solved, worst, over) + print(f"{repair:16s}{year:>7s}{total:>10d}{solved:>7d}/199" + f"{worst:>8d}{over:>15d}", flush=True) + best_classical = min(rows[r][0] for r in ("illinois", "pegasus", + "anderson")) + c = rows["credit"][0] + print(f"\n best classical repair {best_classical}, credit {c} " + f"=> {'SURVIVES' if c < best_classical else 'FAILS'} the objection") + return rows + + +# ========================================================================== +# CLAIM B: the measured step size against a Kwong-Johnston oracle +# ========================================================================== +class KJTuned(KwongJohnston): + def __init__(self, a, g): + self.A, self.G = a, g + self.name = f"KJ a={a:g} g={g:g}" + self.constants = 4 + + +N, SEEDS, SNRS = 8000, 6, (30.0, 15.0) +KJ_GRID = [(a, g) for a in (0.9, 0.97, 0.99) + for g in (2e-4, 2e-3, 2e-2, 2e-1)] + + +def anc_score(rule, scen_gen, snr, seeds=SEEDS): + vals = [] + for s in range(seeds): + rng = np.random.default_rng(1000 + s) + noise = scen_gen(N, rng) + nr = run_nlms(noise, make_primary_path(rng), make_secondary_path(rng), + rule, snr_db=snr, seed=s) + if math.isfinite(nr): + vals.append(nr) + return (sum(vals) / len(vals)) if vals else float("nan") + + +def claim_b(): + print("\n" + "=" * 84) + print("CLAIM B - the measured step size against a Kwong-Johnston ORACLE") + print("=" * 84) + print(f"the oracle is given the best of {len(KJ_GRID)} (alpha, gamma) " + f"pairs for every scenario\nand noise level separately - not an " + f"achievable controller\n") + print(f"{'scenario':22s}{'SNR':>6s}{'KJ default':>12s}{'KJ oracle':>12s}" + f"{'measured':>11s}{'fixed 0.5':>11s}") + print("-" * 84) + tot = {"kj": 0.0, "orc": 0.0, "meas": 0.0, "fix": 0.0} + cells = 0 + for sname, gen in SCENARIOS: + for snr in SNRS: + kj = anc_score(KwongJohnston(), gen, snr) + orc = max(anc_score(KJTuned(a, g), gen, snr) for a, g in KJ_GRID) + meas = anc_score(Measured(), gen, snr) + fix = anc_score(Fixed(0.5), gen, snr) + tot["kj"] += kj + tot["orc"] += orc + tot["meas"] += meas + tot["fix"] += fix + cells += 1 + print(f"{sname:22s}{snr:>6.0f}{kj:>12.2f}{orc:>12.2f}" + f"{meas:>11.2f}{fix:>11.2f}", flush=True) + print("-" * 84) + print(f"{'mean':22s}{'':6s}{tot['kj'] / cells:>12.2f}" + f"{tot['orc'] / cells:>12.2f}{tot['meas'] / cells:>11.2f}" + f"{tot['fix'] / cells:>11.2f}") + survives = tot["meas"] > tot["orc"] + print(f"\n measured {tot['meas'] / cells:.2f} dB against the oracle " + f"{tot['orc'] / cells:.2f} dB => " + f"{'SURVIVES' if survives else 'FAILS'} the objection") + return survives + + +if __name__ == "__main__": + claim_a() + claim_b() diff --git a/stage19_modern.py b/stage19_modern.py new file mode 100644 index 0000000..9e36f50 --- /dev/null +++ b/stage19_modern.py @@ -0,0 +1,241 @@ +"""Stage 19 - the objection that the repairs compared against are from 1973. + +Claim A as it stood was: the credit projection repairs regula falsi better +than Illinois (1971), Pegasus (1972) and Anderson-Bjorck (1973). A reader +answers that the field has moved on, and is right to: TOMS 748 (1995), +Chandrupatla (1997) and ITP (2021) all beat credit-repaired regula falsi. +Repairing a three-century-old interpolation better than the 1970s did is not +a modern result. + +The credit projection is not tied to regula falsi, though. It is a safeguard +for ANY step rule. So the strong form of the claim is not "our repair of +their old rule beats their old repair" but + + take the best interpolation in the field and replace its own acceptance + test with the credit projection. + +Chandrupatla's method is exactly that pairing: an inverse quadratic +interpolation plus an acceptance test derived from where that interpolation +stays inside the bracket. Swapping the test for the credit projection, and +changing nothing else, is the sharpest test available of whether the +safeguard is worth anything against the modern state of the art. + +Two further modern repairs of the false-position family are included so that +the 1970s are not the only comparison: Ford's Illinois-type variant (1995) +and Galdino's (2011). +""" +from __future__ import annotations + +import math + +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from simroot.baselines import Counter, _Budget, chandrupatla +from simroot.pure import _Safeguard +from stage18_bulletproof import falsi_driver, load_roots + +XTOL, MAXFEV, ACC = 1e-12, 200, 1e-6 + + +def chandrupatla_guard(f, a, b, xtol, maxfev, guard="own"): + """Chandrupatla's method with its safeguard pluggable. + + guard="own" the published acceptance test on xi and phi + guard="credit" always interpolate, and project the result onto the + interval the earned bisection budget allows + guard="none" always interpolate, clamp to the bracket only + + Everything else - the interpolation, the bracket bookkeeping, the + termination test - is identical, so a difference can only be the guard. + """ + g = Counter(f, maxfev) + x1, x2 = b, a + f1 = f2 = 0.0 + try: + f1, f2 = g(x1), g(x2) + if f1 == 0.0: + return x1, g.n, True + if f2 == 0.0: + return x2, g.n, True + x3, f3 = x2, f2 + t = 0.5 + sg = _Safeguard("credit", abs(b - a), xtol) + while True: + x = x1 + t * (x2 - x1) + w_before = abs(x2 - x1) + fx = g(x) + if (fx > 0.0) == (f1 > 0.0): + x3, f3 = x1, f1 + x1, f1 = x, fx + else: + x3, f3 = x2, f2 + x2, f2 = x1, f1 + x1, f1 = x, fx + if guard == "credit": + sg.note_shrink(w_before, abs(x2 - x1)) + xm, fm = (x1, f1) if abs(f1) < abs(f2) else (x2, f2) + if fm == 0.0: + return xm, g.n, True + tol = 2.0 * 2.22e-16 * abs(xm) + xtol + span = abs(x2 - x1) + if span == 0.0: + return xm, g.n, True + tl = tol / span + if tl > 0.5: + return xm, g.n, True + + t = 0.5 + if x3 != x2 and f3 != f2: + xi = (x1 - x2) / (x3 - x2) + ph = (f1 - f2) / (f3 - f2) + d1, d2, d3 = f1 - f2, f1 - f3, f2 - f3 + usable = d1 != 0.0 and d2 != 0.0 and d3 != 0.0 + if usable: + t_iqi = ((f1 / d1) * (f3 / (-d3)) + + ((x3 - x1) / (x2 - x1)) * (f1 / d2) * (f2 / d3)) + if guard == "own": + if (0.0 < xi < 1.0 + and 1.0 - math.sqrt(1.0 - xi) < ph + < math.sqrt(xi)): + t = t_iqi + else: + t = t_iqi + if guard == "credit" and math.isfinite(t): + lo = min(x1, x2) + hi = max(x1, x2) + cand = x1 + t * (x2 - x1) + proj = sg.project_credit(cand, lo, hi) + if x2 != x1: + t = (proj - x1) / (x2 - x1) + if not math.isfinite(t): + t = 0.5 + t = min(max(t, tl), 1.0 - tl) + except _Budget: + return (x1 if abs(f1) < abs(f2) else x2), g.n, False + + +# -------------------------------------------------------------------------- +# two modern repairs of the false-position family, so the 1970s are not the +# only comparison +# -------------------------------------------------------------------------- +def falsi_modern(f, a, b, xtol, maxfev, variant): + """variant="ford" Ford 1995, Illinois-type with the Anderson-Bjorck + factor bounded away from zero + variant="galdino" Galdino 2011, the factor f_moved/(f_moved + fx) + applied to both ordinates + """ + g = Counter(f, maxfev) + x = 0.5 * (a + b) + try: + fa, fb = g(a), g(b) + if fa == 0.0: + return a, g.n, True + if fb == 0.0: + return b, g.n, True + if fa * fb > 0.0: + raise ValueError("no sign change") + while abs(b - a) > xtol: + lo, hi = (a, b) if a < b else (b, a) + denom = fb - fa + x_new = 0.5 * (a + b) if denom == 0.0 else (a * fb - b * fa) / denom + if not math.isfinite(x_new) or not (lo < x_new < hi): + x_new = 0.5 * (a + b) + if x_new in (a, b): + x_new = 0.5 * (a + b) + if x_new in (a, b): + return x_new, g.n, abs(b - a) <= xtol + fx = g(x_new) + if fx == 0.0: + return x_new, g.n, True + + def factor(f_stale, f_moved): + if variant == "ford": + m = 1.0 - fx / f_moved if f_moved != 0.0 else 0.5 + return m if m > 1e-3 else 0.5 + m = f_moved / (f_moved + fx) if (f_moved + fx) != 0.0 else 0.5 + return m if 0.0 < m < 1.0 else 0.5 + + if fa * fx < 0.0: + fa *= factor(fa, fb) + b, fb = x_new, fx + else: + fb *= factor(fb, fa) + a, fa = x_new, fx + x = x_new + return 0.5 * (a + b), g.n, True + except _Budget: + return x, g.n, False + + +def score(method, probs): + total = solved = worst = 0 + for f, a, b, root in probs: + try: + x, n, conv = method(f, a, b, XTOL, MAXFEV) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + total += n if ok else MAXFEV + solved += ok + if ok: + worst = max(worst, n) + return total, solved, worst + + +def main(): + probs = load_roots() + print("=" * 82) + print("A. the false-position family, 1971 to 2011, plus the credit " + "projection") + print("=" * 82) + print(f"{'repair':22s}{'year':>7s}{'evals':>10s}{'solved':>10s}" + f"{'worst':>8s}") + print("-" * 82) + rows = [] + for label, year, m in ( + ("Illinois", "1971", + lambda f, a, b, xt, mx: falsi_driver(f, a, b, xt, mx, "illinois")), + ("Pegasus", "1972", + lambda f, a, b, xt, mx: falsi_driver(f, a, b, xt, mx, "pegasus")), + ("Anderson-Bjorck", "1973", + lambda f, a, b, xt, mx: falsi_driver(f, a, b, xt, mx, "anderson")), + ("Ford (Illinois-type)", "1995", + lambda f, a, b, xt, mx: falsi_modern(f, a, b, xt, mx, "ford")), + ("Galdino", "2011", + lambda f, a, b, xt, mx: falsi_modern(f, a, b, xt, mx, "galdino")), + ("credit projection", "here", + lambda f, a, b, xt, mx: falsi_driver(f, a, b, xt, mx, "credit"))): + t, s, w = score(m, probs) + rows.append((label, t, s)) + print(f"{label:22s}{year:>7s}{t:>10d}{s:>7d}/199{w:>8d}", flush=True) + + print("\n" + "=" * 82) + print("B. the sharp test: Chandrupatla's interpolation, its guard swapped") + print("=" * 82) + print("same interpolation, same bookkeeping, same termination; only the " + "guard differs\n") + print(f"{'guard':30s}{'evals':>10s}{'solved':>10s}{'worst':>8s}") + print("-" * 82) + res = {} + for label, guard in (("Chandrupatla's own test", "own"), + ("none (clamp to bracket only)", "none"), + ("the credit projection", "credit")): + t, s, w = score(lambda f, a, b, xt, mx, _g=guard: + chandrupatla_guard(f, a, b, xt, mx, _g), probs) + res[guard] = (t, s, w) + print(f"{label:30s}{t:>10d}{s:>7d}/199{w:>8d}", flush=True) + t_pub, s_pub, _w = score(lambda f, a, b, xt, mx: chandrupatla(f, a, b, xt, + mx), probs) + print(f"{'(published implementation)':30s}{t_pub:>10d}{s_pub:>7d}/199") + drift = abs(res['own'][0] - t_pub) / t_pub + print(f"\n control drift {drift * 100:.2f}% - the pluggable version " + f"must reproduce the published one") + better = res["credit"][0] < res["own"][0] + print(f" credit {res['credit'][0]} against its own guard " + f"{res['own'][0]} => " + f"{'the safeguard beats the state of the art' if better else 'IT DOES NOT'}") + + +if __name__ == "__main__": + main() diff --git a/stage1_sim_variants.py b/stage1_sim_variants.py new file mode 100644 index 0000000..4ce6ce6 --- /dev/null +++ b/stage1_sim_variants.py @@ -0,0 +1,70 @@ +"""Stage 1 - does the SIM formulation repair the failures found in Stage 0? + +Stage 0 showed the raw similarity-proportional step (= regula falsi) beats +bisection on smooth problems by 2-3x but fails catastrophically when one end +of the bracket goes stale. Stage 1 asks whether the article's actual +machinery - prototype memory + softmax aggregation - removes that failure +WITHOUT introducing a tuning parameter. + +Same 8 problems as Stage 0, plus bisection and Brent for orientation. +""" +from __future__ import annotations + +import math + +from simroot.baselines import bisection, brent, regula_falsi +from simroot.sim import SIMILARITIES, sim_root + +XTOL = 1e-12 +MAXFEV = 200 + +PROBLEMS = [ + ("x^2 - 2", lambda x: x * x - 2.0, 0.0, 2.0, math.sqrt(2.0)), + ("cos(x) - x", lambda x: math.cos(x) - x, 0.0, 1.0, 0.7390851332151607), + ("exp(x) - 2", lambda x: math.exp(x) - 2.0, 0.0, 2.0, math.log(2.0)), + ("x^3 - x - 2", lambda x: x ** 3 - x - 2.0, 1.0, 2.0, 1.5213797068045676), + ("sin(x) - 0.5", lambda x: math.sin(x) - 0.5, 0.0, 1.5, math.asin(0.5)), + ("x^10 - 1 STALL", lambda x: x ** 10 - 1.0, 0.0, 1.3, 1.0), + ("exp(-x)(x-1) FLAT", lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0, 1.0), + ("atan(x)", lambda x: math.atan(x), -1.0, 3.0, 0.0), +] + +METHODS = [ + ("bisection", lambda f, a, b: bisection(f, a, b, XTOL, MAXFEV)), + ("regula_falsi", lambda f, a, b: regula_falsi(f, a, b, XTOL, MAXFEV)), + ("brent", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV)), +] +for _s in SIMILARITIES: + for _p in ("point", "pair", "pair2d"): + for _g in (False, True): + METHODS.append(( + f"SIM.{_p}.{_s}" + (".guard" if _g else ""), + (lambda s, p, gu: lambda f, a, b: sim_root( + f, a, b, XTOL, MAXFEV, similarity=s, prototypes=p, + guard=gu))(_s, _p, _g), + )) + + +def run(): + names = [n for n, _ in METHODS] + width = max(len(n) for n in names) + 1 + header = f"{'method':{width}s}" + "".join(f"{p[0][:13]:>15s}" for p in PROBLEMS) + f"{'TOTAL':>8s}{'FAIL':>6s}" + print(header) + print("-" * len(header)) + for name, fn in METHODS: + cells, total, fails = [], 0, 0 + for pname, f, a, b, root in PROBLEMS: + x, n, conv = fn(f, a, b) + err = abs(x - root) + ok = conv and err <= 1e-8 + if not ok: + fails += 1 + cells.append(f"{'FAIL(' + str(n) + ')':>15s}") + else: + cells.append(f"{n:>15d}") + total += n + print(f"{name:{width}s}" + "".join(cells) + f"{total:>8d}{fails:>6d}") + + +if __name__ == "__main__": + run() diff --git a/stage20_prediction.py b/stage20_prediction.py new file mode 100644 index 0000000..c1e4f49 --- /dev/null +++ b/stage20_prediction.py @@ -0,0 +1,204 @@ +"""Stage 20 - a prediction registered before the run, then the run. + +The request was to find the domain where the method wins unambiguously. The +way to get that wrong is to try domains until one of them comes out ahead; +that is fitting, spread over time. So this file states the prediction and the +falsification condition FIRST, from what the quantity does, and then measures. + +WHAT MU IS. In NLMS the update w <- w + mu * e * x / ||x||^2 with mu = 1 +drives the a posteriori error of the current sample to exactly zero. Every +practical system uses mu < 1 because part of e is measurement noise the filter +cannot cancel, and fitting it is harmful. So mu is the SIGNAL FRACTION of the +error, and its correct value is + + mu* = 1 - p_noise / p_error. + +THE PREDICTION. mu* is a property of the noise level. Therefore: + + (A) CONTROL - when the noise level is constant, a constant mu can be exactly + right. An oracle that picks the best fixed mu for that scenario should + MATCH OR BEAT the measured rule. If the measured rule wins here, the + reasoning is wrong and everything below is suspect. + + (B) PREDICTION - when the noise level CHANGES during the run, no constant is + right throughout, while a measured quantity tracks. The measured rule + should BEAT the oracle fixed mu, and the margin should grow with the size + of the change. + +FALSIFICATION. If (B) fails - if an oracle constant matches the measured rule +even when the noise level swings by 25 dB within a single run - then there is +no such domain on this evidence, and that is the finding. + +The oracle is the strongest competitor available: the best of a mu grid chosen +separately for every scenario, with knowledge of that scenario, which no +deployable controller has. Kwong-Johnston is given the same treatment. +""" +from __future__ import annotations + +import math + +import numpy as np + +from anc.bench import (FS, gen_broadband, gen_impulse_train, gen_multitonal, + gen_tonal, make_primary_path, make_secondary_path) +from anc.rules import Fixed, KwongJohnston, Measured, Rule + +N = 16000 # two seconds +SEEDS = 8 +MU_GRID = (0.05, 0.1, 0.2, 0.3, 0.5, 0.7, 0.85, 1.0) +KJ_GRID = [(a, g) for a in (0.9, 0.97, 0.99) + for g in (2e-4, 2e-3, 2e-2, 2e-1)] +FILTER_LEN = 64 + + +class KJTuned(KwongJohnston): + def __init__(self, a, g): + self.A, self.G = a, g + self.name = f"KJ({a:g},{g:g})" + + +def run(noise, prim, sec, rule, snr_profile, seed=0): + """One run. snr_profile(i) gives the instantaneous SNR in dB, so the + stationary and the varying case go through exactly the same code.""" + rng = np.random.default_rng(seed) + n = len(noise) + d = np.convolve(noise, prim)[:n] + xf = np.convolve(noise, sec)[:n] + + # the disturbance is added with a time-varying power, which is the only + # thing that differs between the control and the prediction + p_sig = float(np.mean(d * d)) + 1e-30 + snr = np.array([snr_profile(i / n) for i in range(n)]) + amp = np.sqrt(p_sig / (10.0 ** (snr / 10.0))) + d = d + rng.standard_normal(n) * amp + + w = np.zeros(FILTER_LEN) + buf = np.zeros(FILTER_LEN) + err = np.zeros(n) + rule.reset() + for i in range(n): + buf[1:] = buf[:-1] + buf[0] = xf[i] + e = d[i] - float(np.dot(w, buf)) + err[i] = e + nrm = float(np.dot(buf, buf)) + 1e-6 + mu = rule.step(e, buf, nrm) + if mu != 0.0: + w += mu * e * buf / nrm + rule.observe(e, d[i] - float(np.dot(w, buf)), mu) + else: + rule.observe(e, e, 0.0) + # The measurement window matters, and the first version got it wrong. + # Scoring only the second half made the varying-noise scenarios + # indistinguishable from a constant run at their FINAL level - the ramp + # and the step have both arrived by then, so the metric never saw the + # transition and the prediction could not have been confirmed even if it + # were true. The window now excludes only the initial adaptation + # transient, which every controller pays alike. + warm = n // 10 + p_in = float(np.mean(d[warm:] ** 2)) + p_out = float(np.mean(err[warm:] ** 2)) + if p_out <= 0.0 or not math.isfinite(p_out): + return float("nan") + return 10.0 * math.log10(p_in / p_out) + + +def score(rule, gen, profile, seeds=SEEDS): + vals = [] + for s in range(seeds): + rng = np.random.default_rng(2000 + s) + noise = gen(N, rng) + nr = run(noise, make_primary_path(rng), make_secondary_path(rng), + rule, profile, seed=s) + if math.isfinite(nr): + vals.append(nr) + return (sum(vals) / len(vals)) if vals else float("nan") + + +def oracle_fixed(gen, profile): + """The ceiling of what any constant can do on this scenario: the best mu + of the grid, chosen WITH knowledge of the scenario.""" + best, arg = -1e30, None + for mu in MU_GRID: + v = score(Fixed(mu), gen, profile) + if math.isfinite(v) and v > best: + best, arg = v, mu + return best, arg + + +def oracle_kj(gen, profile): + best, arg = -1e30, None + for a, g in KJ_GRID: + v = score(KJTuned(a, g), gen, profile) + if math.isfinite(v) and v > best: + best, arg = v, (a, g) + return best, arg + + +# --------------------------------------------------------------- scenarios -- +def sig_tonal(n, rng): + return gen_tonal(n, rng) + + +def sig_cabin(n, rng): + s = gen_multitonal(n, rng, f0=80.0) + 0.6 * gen_broadband(n, rng) \ + + 0.4 * gen_impulse_train(n, rng) + return s / (np.max(np.abs(s)) + 1e-12) + + +SIGNALS = [("tonal", sig_tonal), ("car cabin", sig_cabin)] + +# noise-level profiles, as functions of the fraction of the run elapsed +FLAT_30 = lambda u: 30.0 +FLAT_15 = lambda u: 15.0 +FLAT_5 = lambda u: 5.0 +SWING_10 = lambda u: 25.0 - 10.0 * u +SWING_25 = lambda u: 30.0 - 25.0 * u +STEP_25 = lambda u: 30.0 if u < 0.5 else 5.0 + +PROFILES = [("flat 30 dB", FLAT_30, "control"), + ("flat 15 dB", FLAT_15, "control"), + ("flat 5 dB", FLAT_5, "control"), + ("ramp 25->15 dB", SWING_10, "prediction"), + ("ramp 30->5 dB", SWING_25, "prediction"), + ("step 30->5 dB", STEP_25, "prediction")] + + +def main(): + print(__doc__.split("The oracle is")[0]) + print("=" * 92) + print("THE RUN") + print("=" * 92) + print(f"{'signal':11s}{'noise profile':17s}{'kind':12s}" + f"{'oracle mu':>11s}{'best mu':>9s}{'oracle KJ':>11s}" + f"{'measured':>10s}{'verdict':>12s}") + print("-" * 92) + control_wins = pred_wins = control_n = pred_n = 0 + for signame, gen in SIGNALS: + for pname, prof, kind in PROFILES: + om, arg = oracle_fixed(gen, prof) + okj, _a = oracle_kj(gen, prof) + ms = score(Measured(), gen, prof) + beats = ms > max(om, okj) + if kind == "control": + control_n += 1 + control_wins += beats + else: + pred_n += 1 + pred_wins += beats + print(f"{signame:11s}{pname:17s}{kind:12s}{om:>11.2f}" + f"{arg:>9.2f}{okj:>11.2f}{ms:>10.2f}" + f"{'MEASURED' if beats else 'oracle':>12s}", flush=True) + print("-" * 92) + print(f"\n control cells (constant noise): measured wins " + f"{control_wins} of {control_n}") + print(f" predicted cells (varying noise): measured wins " + f"{pred_wins} of {pred_n}") + ok = control_wins == 0 and pred_wins == pred_n + print(f"\n the prediction is {'CONFIRMED' if ok else 'NOT confirmed'}: " + f"it required the measured rule to lose every\n control cell and " + f"win every predicted one.") + + +if __name__ == "__main__": + main() diff --git a/stage21_cosine_vs_oracle.py b/stage21_cosine_vs_oracle.py new file mode 100644 index 0000000..4961173 --- /dev/null +++ b/stage21_cosine_vs_oracle.py @@ -0,0 +1,131 @@ +"""Stage 21 - the WHOLE similarity family for mu, against the oracle constant. + +Why this is not another throw of the dice. The first two constant-free rules +estimated mu from VARIANCES - a noise floor, a model discrepancy. Neither is +a similarity, and this project is about similarity. The formulation the +thesis dictates asks how much the error RESEMBLES what the filter can remove, +and the filter can only remove what correlates with its input. With + + d = 1 - || / (||e|| ||x||) the dissimilarity, 0 = removable + +the family is mu = S(d) over the same nine similarity functions the +root-finding work used. Testing one member would be as incomplete here as it +would have been there. + +A PREDICTION, FROM THE LAW OF THE FIRST DOMAIN. The contraction law found in +root finding says the shape of S is nearly irrelevant and the slope of (1 - S) +at the origin decides everything: functions approaching 1 linearly work, +functions approaching it quadratically do not. If that law is a property of +similarity rules and not of root finding, it must order this family too: + + predicted strong 1 - d, e^-d, 1/(1+d) slope 1 + predicted middle (1+d)^-2, 1 - sqrt(d), 1 - d^(1/3) + predicted weak 1/(1+d^2), e^-(d^2), 1/sqrt(1+d^2) slope 0 + +THE BAR FOR THE METHOD, STATED BEFORE THE RUN. The competitor is the +strongest a constant can be: the best mu of a grid chosen with knowledge of +the scenario and the noise profile, which no deployable controller has. For +the claim to be bullet-proof the best similarity must beat that oracle on a +MAJORITY of the twelve cells, stationary cells included, where a constant is +ideal by construction. +""" +from __future__ import annotations + +import math + +from anc.rules import CosineSimilarity, Fixed, Measured +from simroot.pure import PURE_SIMS +from stage20_prediction import MU_GRID, PROFILES, SIGNALS, score + +# the nine functions of the paper, applied to the dissimilarity d = 1 - |cos|, +# plus the identity S(d) = 1 - d which is the raw cosine +FAMILY = [("1 - d (raw cosine)", None, 1.0)] +_SLOPE = {"ratio": 1.0, "exp_abs": 1.0, "rational": 1.0, "ratio_soft": 2.0, + "sqrt": math.inf, "cbrt": math.inf, "rat_sq": 0.0, "exp_sq": 0.0, + "cosine": 0.0} +for _name in ("ratio", "exp_abs", "rational", "ratio_soft", "sqrt", "cbrt", + "rat_sq", "exp_sq", "cosine"): + FAMILY.append((f"S = {_name}", PURE_SIMS[_name], _SLOPE[_name])) + + +def make(S): + r = CosineSimilarity() + r.S = S + return r + + +def main(): + print(__doc__.split("THE BAR")[0]) + + # ---------------- part 1: does the law order this family too? ---------- + print("=" * 88) + print("1. THE FAMILY, ranked - the law of the first domain predicts the " + "order") + print("=" * 88) + print(f"{'similarity':22s}{'slope of (1-S) at 0':>21s}" + f"{'mean NR over 12 cells':>24s}") + print("-" * 88) + scores = [] + for label, S, slope in FAMILY: + vals = [] + for _sig, gen in SIGNALS: + for _pn, prof, _k in PROFILES: + v = score(make(S), gen, prof) + if math.isfinite(v): + vals.append(v) + m = sum(vals) / len(vals) + scores.append((label, slope, m)) + print(f"{label:22s}{slope:>21.3g}{m:>24.2f}", flush=True) + print("-" * 88) + ranked = sorted(scores, key=lambda t: t[2], reverse=True) + print("\n ranked best first:") + for label, slope, m in ranked: + print(f" {label:22s} slope {slope:>8.3g} {m:6.2f} dB") + lin = [m for _l, s, m in scores if s == 1.0] + quad = [m for _l, s, m in scores if s == 0.0] + print(f"\n slope 1 mean {sum(lin) / len(lin):.2f} dB, " + f"slope 0 mean {sum(quad) / len(quad):.2f} dB => the law " + f"{'HOLDS' if min(lin) > max(quad) else 'does NOT hold'} here") + + # ---------------- part 2: the best member against the oracle ----------- + best_label, _s, _m = ranked[0] + best_S = dict((l, S) for l, S, _sl in FAMILY)[best_label] + print("\n" + "=" * 88) + print(f"2. {best_label} against the per-scenario oracle constant") + print("=" * 88) + print(f"{'signal':11s}{'noise profile':17s}{'kind':12s}" + f"{'oracle mu':>11s}{'best mu':>9s}{'variance':>10s}" + f"{'similarity':>12s}{'verdict':>10s}") + print("-" * 88) + wins = {"control": 0, "prediction": 0} + cells = {"control": 0, "prediction": 0} + margins = [] + for signame, gen in SIGNALS: + for pname, prof, kind in PROFILES: + best, arg = -1e30, None + for mu in MU_GRID: + v = score(Fixed(mu), gen, prof) + if math.isfinite(v) and v > best: + best, arg = v, mu + var = score(Measured(), gen, prof) + sim = score(make(best_S), gen, prof) + beats = sim > best + cells[kind] += 1 + wins[kind] += beats + margins.append(sim - best) + print(f"{signame:11s}{pname:17s}{kind:12s}{best:>11.2f}" + f"{arg:>9.2f}{var:>10.2f}{sim:>12.2f}" + f"{'SIMILARITY' if beats else 'oracle':>10s}", flush=True) + tot_w = wins["control"] + wins["prediction"] + tot_c = cells["control"] + cells["prediction"] + print("-" * 88) + print(f"\n beats the per-scenario oracle on {tot_w} of {tot_c} cells" + f" (stationary {wins['control']}/{cells['control']}, " + f"varying {wins['prediction']}/{cells['prediction']})") + print(f" mean margin {sum(margins) / len(margins):+.2f} dB") + print(f"\n the bar was a majority of the twelve. " + f"{'MET' if tot_w > tot_c / 2 else 'NOT MET'}") + + +if __name__ == "__main__": + main() diff --git a/stage22_untuned.py b/stage22_untuned.py new file mode 100644 index 0000000..1df40a4 --- /dev/null +++ b/stage22_untuned.py @@ -0,0 +1,99 @@ +"""Stage 22 - the comparison a practitioner actually faces. + +Every comparison so far gave the constant an oracle: the best mu of a grid, +chosen with knowledge of the scenario and the noise profile. That is the +right bar for "can measurement beat perfect tuning?", and the answer is no, +0 of 12. + +But reporting only that bar is its own distortion, the mirror image of +reporting only a bar we pass. A deployable controller does not know the +scenario. The question a practitioner faces is: I must pick mu once, for a +device that will meet conditions I have not seen - how does a fixed choice +compare with measuring? + +So this file asks the same twelve cells a different, and equally +pre-registered, question: + + a single mu, fixed across ALL cells (as a shipped device would have), + against the similarity rule, which is fixed across all cells too because + it has nothing to fix. + +The constant is still given an advantage: it is the best single value over +the whole grid, chosen with hindsight over all twelve cells - a device maker +who guessed perfectly on the first try. What it is not given is a different +value per scenario. + +Both bars are reported together. Neither alone is the answer. +""" +from __future__ import annotations + +import math + +from anc.rules import CosineSimilarity, Fixed, KwongJohnston, Measured +from simroot.pure import PURE_SIMS +from stage20_prediction import MU_GRID, PROFILES, SIGNALS, score + +CELLS = [(sig, gen, pn, prof, kind) + for sig, gen in SIGNALS for pn, prof, kind in PROFILES] + + +def member(name): + r = CosineSimilarity() + r.S = None if name is None else PURE_SIMS[name] + return r + + +def per_cell(rule): + return [score(rule, gen, prof) for _s, gen, _pn, prof, _k in CELLS] + + +def main(): + print(__doc__.split("Both bars")[0]) + print("=" * 90) + + sim = per_cell(member("cbrt")) + var = per_cell(Measured()) + kj = per_cell(KwongJohnston()) + fixed = {mu: per_cell(Fixed(mu)) for mu in MU_GRID} + + # bar 1: the per-cell oracle - a different constant for every scenario + oracle_cell = [max(fixed[mu][i] for mu in MU_GRID) for i in range(len(CELLS))] + # bar 2: the best SINGLE constant across all cells, chosen with hindsight + best_single_mu = max(MU_GRID, key=lambda mu: sum(fixed[mu])) + single = fixed[best_single_mu] + + print(f"{'signal':11s}{'profile':17s}{'per-cell oracle':>17s}" + f"{'best single mu':>16s}{'similarity':>12s}{'KJ':>8s}") + print("-" * 90) + for i, (s, _g, pn, _p, _k) in enumerate(CELLS): + print(f"{s:11s}{pn:17s}{oracle_cell[i]:>17.2f}{single[i]:>16.2f}" + f"{sim[i]:>12.2f}{kj[i]:>8.2f}", flush=True) + print("-" * 90) + n = len(CELLS) + print(f"{'mean':28s}{sum(oracle_cell) / n:>17.2f}{sum(single) / n:>16.2f}" + f"{sum(sim) / n:>12.2f}{sum(kj) / n:>8.2f}") + print(f"\n the best single constant over all twelve cells is " + f"mu = {best_single_mu:g}") + + w_oracle = sum(1 for i in range(n) if sim[i] > oracle_cell[i]) + w_single = sum(1 for i in range(n) if sim[i] > single[i]) + w_kj = sum(1 for i in range(n) if sim[i] > kj[i]) + w_var = sum(1 for i in range(n) if sim[i] > var[i]) + print(f"\n similarity beats the per-cell oracle on {w_oracle:>2d}/{n}" + f" (mean margin {sum(sim[i] - oracle_cell[i] for i in range(n)) / n:+.2f} dB)") + print(f" similarity beats the best single constant on {w_single:>2d}/{n}" + f" (mean margin {sum(sim[i] - single[i] for i in range(n)) / n:+.2f} dB)") + print(f" similarity beats Kwong-Johnston on {w_kj:>2d}/{n}" + f" (mean margin {sum(sim[i] - kj[i] for i in range(n)) / n:+.2f} dB)") + print(f" similarity beats the variance rule on {w_var:>2d}/{n}" + f" (mean margin {sum(sim[i] - var[i] for i in range(n)) / n:+.2f} dB)") + + print("\n Every arbitrary constant, cell by cell:") + print(f" {'mu':>6s}{'mean dB':>10s}{'cells where similarity wins':>30s}") + for mu in MU_GRID: + w = sum(1 for i in range(n) if sim[i] > fixed[mu][i]) + print(f" {mu:>6g}{sum(fixed[mu]) / n:>10.2f}{w:>25d}/{n}") + + +if __name__ == "__main__": + main() diff --git a/stage23_relaxation.py b/stage23_relaxation.py new file mode 100644 index 0000000..c168f0e --- /dev/null +++ b/stage23_relaxation.py @@ -0,0 +1,145 @@ +"""Stage 23 - the relaxation parameter, which is where this principle belongs. + +The step rule was stuck on equations that bisection also solves. The wider +statement is: wherever an iterative method has a step length, and there is a +current result and a required one, the step should follow how SIMILAR the two +are. The oldest hand-tuned step length in numerical computing is the +relaxation factor omega of SOR. + + convergence needs 0 < omega < 2 + the optimum known in closed form only for model problems + everywhere else guessed, swept, or left at folklore values + +The similarity form. SOR over-relaxes because the Gauss-Seidel correction +under-shoots consistently in the same direction. How consistent that +direction is, is the cosine between successive corrections, and + + omega = 1 + max(0, cos(d_k, d_{k-1})) lands exactly in [1, 2] + +so the range of the similarity and the admissible interval of the theory +coincide. No constant is chosen. + +The instrument is checked first: on the model Poisson problem the SOR spectral +radius is exactly omega* - 1, so the measured contraction of the oracle must +reproduce it. If it does not, the sweep is wrong and nothing below counts. + +Then three problem classes, in increasing order of how unavailable the optimum +is: + + model Poisson omega* is a theorem - we should LOSE + anisotropic omega* has no closed form - open + variable coefficient / convection - no theory at all - open +""" +from __future__ import annotations + +import math + +import numpy as np + +from relax.sor import (Fixed, OptimalPoisson, SimilarityOmega, poisson_rhs, + residual, solve, sweep_gs) + +TOL = 1e-8 + + +def theory_check(n=16): + """The SOR spectral radius for the model problem is omega* - 1.""" + w = 2.0 / (1.0 + math.sin(math.pi / (n + 1))) + f = poisson_rhs(n) + h2 = 1.0 / (n + 1) ** 2 + u = np.zeros_like(f) + rs = [] + for _ in range(60): + sweep_gs(u, f, h2, w) + rs.append(float(np.linalg.norm(residual(u, f, h2)))) + ratios = [rs[i + 1] / rs[i] for i in range(30, len(rs) - 1) if rs[i] > 0] + measured = sum(ratios) / len(ratios) if ratios else float("nan") + return w, w - 1.0, measured + + +def anisotropic(n, eps): + """-u_xx - eps*u_yy: the classic problem where a single omega is wrong.""" + cw = np.full((n, n), 1.0) + ce = np.full((n, n), 1.0) + cs = np.full((n, n), eps) + cn = np.full((n, n), eps) + cc = np.full((n, n), 2.0 + 2.0 * eps) + return (cw, ce, cs, cn, cc) + + +def variable(n, rng): + """A jumping diffusion coefficient - no closed-form optimum exists.""" + a = np.exp(rng.uniform(-2.0, 2.0, (n, n))) + cw = np.roll(a, 1, 0) * 0.5 + a * 0.5 + ce = np.roll(a, -1, 0) * 0.5 + a * 0.5 + cs = np.roll(a, 1, 1) * 0.5 + a * 0.5 + cn = np.roll(a, -1, 1) * 0.5 + a * 0.5 + cc = cw + ce + cs + cn + return (cw, ce, cs, cn, cc) + + +def convection(n, pe): + """Convection-diffusion, upwind: non-symmetric, and the SOR theory for + symmetric problems does not apply at all.""" + cw = np.full((n, n), 1.0 + pe) + ce = np.full((n, n), 1.0) + cs = np.full((n, n), 1.0) + cn = np.full((n, n), 1.0) + cc = np.full((n, n), 4.0 + pe) + return (cw, ce, cs, cn, cc) + + +def main(): + n = 24 + w_opt, rho_theory, rho_measured = theory_check(n) + print("instrument check on the model Poisson problem") + print(f" omega* = {w_opt:.6f} spectral radius: theory " + f"{rho_theory:.6f}, measured {rho_measured:.6f}") + if abs(rho_theory - rho_measured) > 0.02: + print(" the sweep does NOT reproduce the theory - stopping") + return + print(" the sweep reproduces the theory\n") + + rng = np.random.default_rng(7) + f = poisson_rhs(n, rng) + grid = [ + ("model Poisson", None, "omega* is a theorem"), + ("anisotropic eps=0.1", anisotropic(n, 0.1), "no closed form"), + ("anisotropic eps=0.01", anisotropic(n, 0.01), "no closed form"), + ("variable coefficient", variable(n, np.random.default_rng(3)), + "no theory"), + ("convection Pe=2", convection(n, 2.0), "non-symmetric"), + ("convection Pe=10", convection(n, 10.0), "non-symmetric"), + ] + sweep_grid = (1.0, 1.2, 1.4, 1.6, 1.8, 1.9, w_opt) + + print("=" * 96) + print("sweeps to ||r|| <= 1e-8 ||r0|| (lower is better; 20000 = did " + "not converge)") + print("=" * 96) + print(f"{'problem':24s}{'why':16s}{'Gauss-Seidel':>14s}" + f"{'best fixed w':>14s}{'(that w)':>10s}{'similarity':>12s}" + f"{'mean w':>8s}") + print("-" * 96) + wins = total = 0 + for label, coeff, why in grid: + gs, _ = solve(f, Fixed(1.0), tol=TOL, coeff=coeff) + best, bw = 10 ** 9, None + for w in sweep_grid: + k, _ = solve(f, Fixed(w), tol=TOL, coeff=coeff) + if k < best: + best, bw = k, w + sim, mw = solve(f, SimilarityOmega(), tol=TOL, coeff=coeff) + total += 1 + wins += sim < best + print(f"{label:24s}{why:16s}{gs:>14d}{best:>14d}{bw:>10.3f}" + f"{sim:>12d}{mw:>8.3f}", flush=True) + print("-" * 96) + print(f"\n similarity beats the best swept omega on {wins} of {total} " + f"problems") + print(" the swept omega is an oracle: it costs seven full solves to " + "find,\n and the similarity rule costs none.") + + +if __name__ == "__main__": + main() diff --git a/stage2_guard_modes.py b/stage2_guard_modes.py new file mode 100644 index 0000000..55e356f --- /dev/null +++ b/stage2_guard_modes.py @@ -0,0 +1,71 @@ +"""Stage 2 - the step guard against the bracket guard, and against no guard. + +The bracket guard costs 64 extra evaluations over the eight stage-0 problems +(150 vs 86) because a secant step collapses the ERROR while barely moving the +proven BRACKET. The step guard tests the thing that is actually converging - +the step length - and should cost close to nothing while keeping the +worst-case bound. +""" +from __future__ import annotations + +import math + +from simroot.baselines import bisection, brent, itp, ridders, toms748 +from simroot.pure import GUARDS, PURE_SIMS, pure_root + +XTOL = 1e-12 +MAXFEV = 200 + +PROBLEMS = [ + ("x^2 - 2", lambda x: x * x - 2.0, 0.0, 2.0, math.sqrt(2.0)), + ("cos(x) - x", lambda x: math.cos(x) - x, 0.0, 1.0, 0.7390851332151607), + ("exp(x) - 2", lambda x: math.exp(x) - 2.0, 0.0, 2.0, math.log(2.0)), + ("x^3 - x - 2", lambda x: x ** 3 - x - 2.0, 1.0, 2.0, 1.5213797068045676), + ("sin(x) - 0.5", lambda x: math.sin(x) - 0.5, 0.0, 1.5, math.asin(0.5)), + ("x^10 - 1 STALL", lambda x: x ** 10 - 1.0, 0.0, 1.3, 1.0), + ("exp(-x)(x-1) FLAT", lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0, 1.0), + ("atan(x)", lambda x: math.atan(x), -1.0, 3.0, 0.0), +] + + +def table(methods, title): + print("\n" + title) + width = max(len(n) for n, _ in methods) + 1 + header = (f"{'method':{width}s}" + + "".join(f"{p[0][:13]:>15s}" for p in PROBLEMS) + + f"{'TOTAL':>8s}{'FAIL':>6s}") + print(header) + print("-" * len(header)) + for name, fn in methods: + cells, total, fails = [], 0, 0 + for _, f, a, b, root in PROBLEMS: + x, n, conv = fn(f, a, b) + ok = conv and abs(x - root) <= 1e-8 + cells.append(f"{n:>15d}" if ok else f"{'FAIL(' + str(n) + ')':>15s}") + total += n + fails += 0 if ok else 1 + print(f"{name:{width}s}" + "".join(cells) + f"{total:>8d}{fails:>6d}") + + +def main(): + ref = [("bisection", lambda f, a, b: bisection(f, a, b, XTOL, MAXFEV)), + ("brent", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV)), + ("ridders", lambda f, a, b: ridders(f, a, b, XTOL, MAXFEV)), + ("toms748", lambda f, a, b: toms748(f, a, b, XTOL, MAXFEV)), + ("itp (3 tuned consts)", lambda f, a, b: itp(f, a, b, XTOL, MAXFEV))] + + table(ref + [(f"pure.ratio.{gu}", + (lambda g: lambda f, a, b: pure_root( + f, a, b, XTOL, MAXFEV, similarity="ratio", + scale="derived", guard=g))(gu)) for gu in GUARDS], + "the three safeguards, similarity = ratio, scale = derived") + + table(ref + [(f"pure.{s}.step", + (lambda ss: lambda f, a, b: pure_root( + f, a, b, XTOL, MAXFEV, similarity=ss, + scale="derived", guard="step"))(s)) for s in PURE_SIMS], + "every similarity function, scale = derived, guard = step") + + +if __name__ == "__main__": + main() diff --git a/stage2b_itp_fairness.py b/stage2b_itp_fairness.py new file mode 100644 index 0000000..cdfb0e9 --- /dev/null +++ b/stage2b_itp_fairness.py @@ -0,0 +1,141 @@ +"""Stage 2b - is my ITP broken, or is that the method's constants? + +ITP scored 182 against Brent's 82 on the stage-0 set, which is close to +bisection. Before ITP is used as the state-of-the-art competitor it has to be +established which of the two explanations holds, because publishing a +benchmark against a crippled competitor would be worthless. + +Trace of the mechanism on sin(x) - 0.5 over [0, 1.5]: + + x_f = regula falsi point 0.7519 + x_half = 0.75 + delta = kappa1 * (b-a)^kappa2 = (0.2/1.5) * 1.5^2 = 0.300 + |x_half - x_f| = 0.0019 < delta => x_t := x_half + +so the TRUNCATION step discards the interpolation and bisects. Both delta and +|x_half - x_f| are O((b-a)^2), so the comparison does not resolve as the +bracket shrinks: whichever constant is larger wins for the whole run. For a +nearly symmetric f, kappa1 wins and ITP is bisection. + +That is the published rule, not a coding error - but it means the authors' +recommended kappa1 is not neutral across problems. The fair thing to do in +the benchmark is to give ITP its best kappa1, not its default one. This file +measures the sensitivity so the benchmark can be honest about it. +""" +from __future__ import annotations + +import math + +from simroot.baselines import bisection, brent, itp + +XTOL = 1e-12 +MAXFEV = 300 + +PROBLEMS = [ + ("x^2 - 2", lambda x: x * x - 2.0, 0.0, 2.0, math.sqrt(2.0)), + ("cos(x) - x", lambda x: math.cos(x) - x, 0.0, 1.0, 0.7390851332151607), + ("exp(x) - 2", lambda x: math.exp(x) - 2.0, 0.0, 2.0, math.log(2.0)), + ("x^3 - x - 2", lambda x: x ** 3 - x - 2.0, 1.0, 2.0, 1.5213797068045676), + ("sin(x) - 0.5", lambda x: math.sin(x) - 0.5, 0.0, 1.5, math.asin(0.5)), + ("x^10 - 1", lambda x: x ** 10 - 1.0, 0.0, 1.3, 1.0), + ("exp(-x)(x-1)", lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0, 1.0), + ("atan(x)", lambda x: math.atan(x), -1.0, 3.0, 0.0), +] + +# kappa1 as a multiple of the authors' recommended 0.2/(b-a) +FACTORS = (1.0, 0.1, 0.01, 1e-3, 1e-4, 1e-6) + + +def main(): + print("ITP sensitivity to kappa1 (kappa2 = 2, n0 = 1)\n") + head = (f"{'kappa1':>26s}" + "".join(f"{p[0][:12]:>14s}" for p in PROBLEMS) + + f"{'TOTAL':>8s}") + print(head) + print("-" * len(head)) + best_total = None + for fac in FACTORS: + cells, total = [], 0 + for _, f, a, b, root in PROBLEMS: + k1 = fac * 0.2 / (b - a) + x, n, conv = itp(f, a, b, XTOL, MAXFEV, kappa1=k1) + ok = conv and abs(x - root) <= 1e-8 + cells.append(f"{n:>14d}" if ok else f"{'FAIL(' + str(n) + ')':>14s}") + total += n + label = f"{fac:g} x 0.2/(b-a)" + print(f"{label:>26s}" + "".join(cells) + f"{total:>8d}") + best_total = total if best_total is None else min(best_total, total) + + # per-problem best over the sweep: the most generous possible ITP + per_problem_best, cells = 0, [] + for _, f, a, b, root in PROBLEMS: + best = None + for fac in FACTORS: + x, n, conv = itp(f, a, b, XTOL, MAXFEV, kappa1=fac * 0.2 / (b - a)) + if conv and abs(x - root) <= 1e-8: + best = n if best is None else min(best, n) + cells.append(f"{best:>14d}" if best else f"{'FAIL':>14s}") + per_problem_best += best or MAXFEV + print("-" * len(head)) + print(f"{'ITP oracle (best k1 per problem)':>26s}"[:26] + "".join(cells) + + f"{per_problem_best:>8d}") + + ref = [] + for name, m in (("bisection", bisection), ("brent", brent)): + cells, total = [], 0 + for _, f, a, b, root in PROBLEMS: + x, n, conv = m(f, a, b, XTOL, MAXFEV) + cells.append(f"{n:>14d}") + total += n + ref.append((name, cells, total)) + for name, cells, total in ref: + print(f"{name:>26s}" + "".join(cells) + f"{total:>8d}") + + # ------------------------------------------------------------------ + # n0 controls the slack in the projection step: r_j = 2^(n_max-j)*eps + # - (b-a)/2 with n_max = n_half + n0. A larger n0 lets the + # interpolation roam further before the minmax projection pulls it back + # to the midpoint. Both problems where the kappa1 sweep flatlined at the + # bisection count are exactly the ones where interpolation needs room. + # ------------------------------------------------------------------ + print("\nITP sensitivity to n0 (kappa1 = 0.1 x 0.2/(b-a), kappa2 = 2)\n") + print(head) + print("-" * len(head)) + for n0 in (0, 1, 2, 5, 10, 20): + cells, total = [], 0 + for _, f, a, b, root in PROBLEMS: + x, n, conv = itp(f, a, b, XTOL, MAXFEV, + kappa1=0.1 * 0.2 / (b - a), n0=n0) + ok = conv and abs(x - root) <= 1e-8 + cells.append(f"{n:>14d}" if ok else f"{'FAIL(' + str(n) + ')':>14s}") + total += n + print(f"{('n0 = ' + str(n0)):>26s}" + "".join(cells) + f"{total:>8d}") + + # the most generous ITP possible: best over the whole (kappa1, n0) grid, + # per problem. If SIM still matches this, the comparison is beyond doubt. + cells, oracle_total = [], 0 + for _, f, a, b, root in PROBLEMS: + best = None + for fac in FACTORS: + for n0 in (0, 1, 2, 5, 10, 20): + x, n, conv = itp(f, a, b, XTOL, MAXFEV, + kappa1=fac * 0.2 / (b - a), n0=n0) + if conv and abs(x - root) <= 1e-8: + best = n if best is None else min(best, n) + cells.append(f"{best:>14d}" if best else f"{'FAIL':>14s}") + oracle_total += best or MAXFEV + print("-" * len(head)) + print(f"{'ITP oracle over k1 AND n0':>26s}" + "".join(cells) + + f"{oracle_total:>8d}") + print(f"{'brent (no tuning)':>26s}" + + "".join(f"{n:>14d}" for n in (9, 8, 10, 9, 10, 10, 17, 9)) + + f"{82:>8d}") + + print("\nInterpretation: if the oracle row reaches brent, the " + "implementation is sound\nand ITP's performance is a function of " + "its three constants; the benchmark must\nthen report ITP at its " + "best, not at its defaults. If the oracle stays at the\nbisection " + "count, the implementation is wrong and must be fixed before use.") + + +if __name__ == "__main__": + main() diff --git a/stage3_bound_check.py b/stage3_bound_check.py new file mode 100644 index 0000000..c89359f --- /dev/null +++ b/stage3_bound_check.py @@ -0,0 +1,66 @@ +"""Stage 3 - the worst-case bound, checked against the runs that violate it. + +Claim made for guard="bracket": one bisection is forced for every similarity +step that failed to halve the bracket, so at least one evaluation in two is a +bisection, so the bracket halves every two evaluations, so + + nfev <= 2*ceil(log2(w/xtol)) + 4. + +The Chandrupatla run reports 19 SOLVED violations of exactly that bound, so +either the reasoning or the implementation is wrong. This prints the actual +numbers for the worst offenders so the answer comes from the run, not from +re-reading the proof. + +For orientation: Brent is NOT claimed to satisfy a 2x bound - his guarantee is +quadratic in the bisection count - so his violations are expected and are +printed only as a scale reference. +""" +from __future__ import annotations + +import math + +from scipy.optimize._tstutils import _CHANDRUPATLA_TESTS_DICTS + +from simroot.baselines import bisection, brent +from simroot.pure import pure_root + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 + + +def main(): + rows = [] + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + f, root, pid = d["f"], float(d["root"]), d["ID"] + w = abs(b - a) + bound = 2 * math.ceil(math.log2(w / XTOL)) + 4 + x_g, n_g, c_g = pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", + scale="derived", guard="bracket") + x_bi, n_bi, c_bi = bisection(f, a, b, XTOL, MAXFEV) + x_br, n_br, c_br = brent(f, a, b, XTOL, MAXFEV) + ok_g = c_g and abs(x_g - root) <= ACC + if ok_g and n_g > bound: + rows.append((pid, w, bound, n_g, n_bi if c_bi else -1, + n_br if c_br else -1)) + rows.sort(key=lambda r: r[3] - r[2], reverse=True) + print(f"{'problem':10s}{'width':>12s}{'2x bound':>10s}" + f"{'bracket guard':>15s}{'bisection':>11s}{'brent':>8s}{'excess':>8s}") + print("-" * 74) + for pid, w, bound, n_g, n_bi, n_br in rows: + print(f"{pid:10s}{w:12.3g}{bound:10d}{n_g:15d}{n_bi:11d}" + f"{n_br:8d}{n_g - bound:8d}") + print(f"\n{len(rows)} solved runs exceed the bound.") + if rows: + worst = rows[0] + print(f"worst: {worst[0]}, {worst[3]} evaluations against a bound of " + f"{worst[2]}, while plain bisection took {worst[4]}.") + print("\nIf bisection itself needs MORE than ceil(log2(w/xtol)) " + "evaluations, the\nbound is mis-stated rather than violated: the " + "bisection count includes the\ntwo initial endpoint " + "evaluations, and the guarded method pays them too.") + + +if __name__ == "__main__": + main() diff --git a/stage4_why.py b/stage4_why.py new file mode 100644 index 0000000..292a97c --- /dev/null +++ b/stage4_why.py @@ -0,0 +1,388 @@ +"""Stage 4 - WHERE the similarity method wins, and WHY. + +The totals say the parameter-free similarity rule loses to Brent and TOMS748 +on Alefeld-Potra-Shi and beats them on Chandrupatla. A total does not explain +anything, so this file takes the runs apart. + +Every root search has two phases with completely different economics: + + APPROACH getting from the initial bracket into the neighbourhood of the + root. Cost here is governed by how boldly a method is willing + to jump, and by how often its safeguard drags it back to the + midpoint. Bracket width drives this phase. + + ENDGAME going from the neighbourhood down to the tolerance. Cost here + is governed by the ORDER of convergence and nothing else: + secant 1.618, Brent's inverse quadratic 1.839, TOMS748's cubic + up to 2.7. + +Prediction, if the method is what the derivation says it is: + - its step is |f|/|f'| with a secant slope, so its order is ~1.618 and it + must LOSE the endgame to both Brent and TOMS748, by a roughly constant + number of evaluations per problem; + - its approach carries no cautious truncation, so it must WIN the + approach, by an amount that GROWS with the width of the bracket. + - therefore: narrow brackets -> the endgame dominates -> we lose; + wide brackets -> the approach dominates -> we win. + +All three are measured below. If the width correlation is absent, the +explanation is wrong and must not go into the paper. +""" +from __future__ import annotations + +import math + +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from simroot.baselines import bisection, brent, toms748 +from simroot.pure import pure_root + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 + +EPS = 2.220446049250313e-16 + + +def phase_boundary(width, scale=0.0, xtol=XTOL): + """Where the approach ends and the endgame begins. + + A fixed relative distance does not work: at 1e-4 of a bracket of width + 1e12 the boundary sits at 1e8, which the very first evaluation clears, so + every wide problem would report its entire cost as endgame. + + The boundary is the geometric mean of the initial width and the tolerance + that is actually ATTAINABLE. The attainable one is not xtol: near + abscissae of magnitude 1e12 the spacing of floating point is about 2e-4, + so no method can drive the bracket to 1e-12 there and the journey is + shorter than xtol suggests. Using xtol regardless put the boundary too + low and charged the whole tail to the approach - measured on a width of + 1e12, bisection split 40 / 15 instead of evenly. + + `scale` is the largest |abscissa| in the bracket; pass it whenever the + bracket is far from the origin.""" + attainable = max(xtol, EPS * abs(scale)) + return math.sqrt(width * attainable) + + +def ours(f, a, b, xtol, maxfev): + return pure_root(f, a, b, xtol, maxfev, similarity="ratio", + scale="derived", guard="step") + + +METHODS = [("OURS (similarity)", ours), ("brent", brent), + ("toms748", toms748), ("bisection", bisection)] + + +def traced(f): + """Wrap f so the sequence of abscissae it is asked about is recorded.""" + xs = [] + + def g(x): + xs.append(x) + return f(x) + + return g, xs + + +def phases(method, f, a, b, root): + """Split a run into approach and endgame evaluations.""" + g, xs = traced(f) + try: + x, n, conv = method(g, a, b, XTOL, MAXFEV) + except Exception: + return None + if not conv or abs(x - root) > ACC: + return None + target = phase_boundary(abs(b - a), max(abs(a), abs(b))) + approach = len(xs) + for i, xi in enumerate(xs): + if abs(xi - root) <= target: + approach = i + 1 + break + return approach, len(xs) - approach, len(xs) + + +def observed_order(method, f, a, b, root): + """Order p from the tail of the running-best error sequence: + e_{n+1} ~ C e_n^p => p = log(e_{n+1}/e_n) / log(e_n/e_{n-1}).""" + g, xs = traced(f) + try: + method(g, a, b, XTOL, MAXFEV) + except Exception: + return float("nan") + best, errs = float("inf"), [] + for xi in xs: + e = abs(xi - root) + if e < best: + best = e + errs.append(e) + errs = [e for e in errs if e > 1e-14] + if len(errs) < 4: + return float("nan") + ps = [] + for i in range(1, len(errs) - 1): + d1, d2 = errs[i] / errs[i - 1], errs[i + 1] / errs[i] + if 0 < d1 < 1 and 0 < d2 < 1: + ps.append(math.log(d2) / math.log(d1)) + if not ps: + return float("nan") + return sorted(ps)[len(ps) // 2] + + +def replay_bracket(f, a, b, xs): + """Reconstruct the bracket a bracketing method maintained, from the + sequence of abscissae it probed, and score every probe against it. + + Returns (positions, shrinks, skipped) where + positions[i] where probe i fell inside the bracket, 0..1 + (0.5 is the midpoint, i.e. a bisection step) + shrinks[i] the fraction of the bracket that probe i removed + skipped probes that fell outside the proven bracket and so + cannot be scored against it. Counting them matters: + dropping them silently would flatter any method that + probes outside, and scipy's toms748 does. + + The reconstruction is exact for a bracketing method because the bracket + is determined by the signs of f, which are recomputed here. + """ + lo, hi = (a, b) if a < b else (b, a) + flo = f(lo) + positions, shrinks, skipped = [], [], 0 + for xi in xs: + if not (lo < xi < hi): + skipped += 1 + continue + w0 = hi - lo + positions.append((xi - lo) / w0) + fi = f(xi) + if flo * fi < 0.0: + hi = xi + else: + lo, flo = xi, fi + shrinks.append(1.0 - (hi - lo) / w0) + return positions, shrinks, skipped + + +def load(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(("APS", d["ID"], (lambda ff, aa: lambda x: ff(x, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(("CHA", d["ID"], (lambda ff: lambda x: ff(x))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +def main(): + probs = load() + + # ------------------------------------------------------------------ + # 1. approach vs endgame, summed over the problems every method solves + # ------------------------------------------------------------------ + print("=" * 78) + print("1. WHERE THE EVALUATIONS GO (only problems all four methods solve)") + print("=" * 78) + for setname in ("APS", "CHA"): + rows = {} + common = [] + for s, pid, f, a, b, root in probs: + if s != setname: + continue + r = {nm: phases(m, f, a, b, root) for nm, m in METHODS} + if all(v is not None for v in r.values()): + common.append((pid, abs(b - a), r)) + for nm, _m in METHODS: + app = sum(c[2][nm][0] for c in common) + end = sum(c[2][nm][1] for c in common) + rows[nm] = (app, end, app + end) + print(f"\n{setname}: {len(common)} problems solved by all four") + print(f"{'method':22s}{'approach':>11s}{'endgame':>10s}{'total':>9s}" + f"{'approach %':>12s}") + print("-" * 64) + for nm, _m in METHODS: + app, end, tot = rows[nm] + print(f"{nm:22s}{app:>11d}{end:>10d}{tot:>9d}" + f"{100.0 * app / tot:>11.1f}%") + + # ------------------------------------------------------------------ + # 2. observed order of convergence + # ------------------------------------------------------------------ + print("\n" + "=" * 78) + print("2. OBSERVED ORDER OF CONVERGENCE (median over solved problems)") + print("=" * 78) + print(f"{'method':22s}{'median order':>14s}{'problems':>11s} theory") + print("-" * 66) + theory = {"OURS (similarity)": "1.618 (secant step |f|/|f'|)", + "brent": "1.839 (inverse quadratic)", + "toms748": "up to 2.7 (cubic)", + "bisection": "1.0 (linear, rate 1/2)"} + for nm, m in METHODS: + ps = [observed_order(m, f, a, b, root) for _s, _pid, f, a, b, root in probs] + ps = [p for p in ps if math.isfinite(p) and 0.5 < p < 5.0] + med = sorted(ps)[len(ps) // 2] if ps else float("nan") + print(f"{nm:22s}{med:>14.3f}{len(ps):>11d} {theory[nm]}") + + # ------------------------------------------------------------------ + # 3. the prediction: our margin over brent grows with bracket width + # ------------------------------------------------------------------ + print("\n" + "=" * 78) + print("3. MARGIN OVER BRENT BY BRACKET WIDTH (negative = we spend fewer)") + print("=" * 78) + buckets = [(0, 1e1), (1e1, 1e3), (1e3, 1e6), (1e6, 1e15)] + labels = ["width < 10", "10 - 1e3", "1e3 - 1e6", "> 1e6"] + print(f"{'bracket width':16s}{'problems':>10s}{'OURS':>9s}{'brent':>8s}" + f"{'diff':>8s}{'diff/problem':>14s}") + print("-" * 66) + for (lo, hi), lab in zip(buckets, labels): + n_ours = n_brent = cnt = 0 + for _s, _pid, f, a, b, root in probs: + w = abs(b - a) + if not (lo <= w < hi): + continue + ro = phases(ours, f, a, b, root) + rb = phases(brent, f, a, b, root) + if ro is None or rb is None: + continue + cnt += 1 + n_ours += ro[2] + n_brent += rb[2] + if cnt: + d = n_ours - n_brent + print(f"{lab:16s}{cnt:>10d}{n_ours:>9d}{n_brent:>8d}{d:>8d}" + f"{d / cnt:>14.2f}") + print("\nThe trend is not monotone, so bracket width is a correlate and " + "not the cause.\nSection 4 tests the mechanism directly.") + + # ------------------------------------------------------------------ + # 4. the mechanism: how often does each method's safeguard fire? + # An interpolation step that gets thrown away and replaced by a + # midpoint is a wasted evaluation. If our advantage is real, our + # safeguard must fire LESS often than Brent's exactly on the set + # where we win, and not much less where we lose. + # ------------------------------------------------------------------ + print("\n" + "=" * 78) + print("4. HOW OFTEN THE SAFEGUARD THROWS AN INTERPOLATION AWAY") + print("=" * 78) + print(f"{'set':6s}{'method':22s}{'steps':>9s}{'forced to midpoint':>21s}" + f"{'share':>9s}") + print("-" * 68) + for setname in ("APS", "CHA"): + for nm in ("OURS (similarity)", "brent"): + steps = forced = 0 + for s, _pid, f, a, b, root in probs: + if s != setname: + continue + st = {} + if nm == "brent": + x, n, conv = brent(f, a, b, XTOL, MAXFEV, stats=st) + fired = st.get("bisect", 0) + else: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, + similarity="ratio", scale="derived", + guard="step", stats=st) + fired = st.get("forced", 0) + if not conv or abs(x - root) > ACC: + continue + steps += n - 2 # the two endpoint evaluations are free + forced += fired + share = 100.0 * forced / steps if steps else float("nan") + print(f"{setname:6s}{nm:22s}{steps:>9d}{forced:>21d}" + f"{share:>8.1f}%") + print("\nREFUTED: Brent throws away 53% of its interpolations on APS, " + "where it WINS,\nand only 34% on Chandrupatla, where it LOSES. " + "The safeguard rate is not the\nmechanism. Section 5 tests the " + "next candidate.") + + # ------------------------------------------------------------------ + # 5. how BOLD are the steps? + # + # Brent accepts an interpolation only if 2|p| < 3*xm*q, i.e. only if + # it lands within three quarters of the way to the far end; otherwise + # the midpoint is used. The similarity rule has no such cap - its step + # is |f|/|f'| and may cross almost the whole bracket in one go. On a + # wide bracket whose root sits far from the middle, that cap is the + # difference between arriving in one step and bisecting towards it. + # + # Measured as the position t of each probe inside the bracket it was + # proposed in, t = (x - lo)/(hi - lo). t near 0 or 1 is a bold step; + # t = 0.5 is bisection. The bracket is reconstructed from the sign of + # f at each probe, which is exact for a bracketing method. + # ------------------------------------------------------------------ + print("\n" + "=" * 78) + print("5. HOW BOLD IS EACH STEP (position inside the bracket it was " + "proposed in)") + print("=" * 78) + print(f"{'set':6s}{'method':22s}{'probes':>9s}{'bold (t<.1 or t>.9)':>22s}" + f"{'share':>9s}") + print("-" * 70) + for setname in ("APS", "CHA"): + for nm, m in (("OURS (similarity)", ours), ("brent", brent)): + probes = bold = 0 + for s, _pid, f, a, b, root in probs: + if s != setname: + continue + g, xs = traced(f) + try: + x, _n, conv = m(g, a, b, XTOL, MAXFEV) + except Exception: + continue + if not conv or abs(x - root) > ACC: + continue + positions, _shrinks, _skipped = replay_bracket(f, a, b, xs[2:]) + probes += len(positions) + bold += sum(1 for t in positions if t < 0.1 or t > 0.9) + share = 100.0 * bold / probes if probes else float("nan") + print(f"{setname:6s}{nm:22s}{probes:>9d}{bold:>22d}{share:>8.1f}%") + print("\nREFUTED: on CHA Brent is BOLDER than we are (56.3% vs 41.8%) and " + "still loses.\nBoldness is not the mechanism either. Section 6 " + "measures step QUALITY rather\nthan step size.") + + # ------------------------------------------------------------------ + # 6. step quality: how much of the bracket does one probe remove? + # + # Boldness is how far a probe goes; quality is whether it went the + # right way. A probe at t = 0.95 that lands on the wrong side of the + # root removes 5% of the bracket; the same probe on the right side + # removes 95%. This is the one quantity that must differ if a method + # with a LOWER order of convergence nevertheless needs fewer probes. + # ------------------------------------------------------------------ + print("\n" + "=" * 78) + print("6. STEP QUALITY (fraction of the bracket removed per probe)") + print("=" * 78) + print(f"{'set':6s}{'method':22s}{'probes':>9s}{'median removed':>17s}" + f"{'mean removed':>15s}{'probes skipped':>16s}") + print("-" * 86) + for setname in ("APS", "CHA"): + for nm, m in (("OURS (similarity)", ours), ("brent", brent), + ("toms748", toms748), ("bisection", bisection)): + shrinks, skipped = [], 0 + for s, _pid, f, a, b, root in probs: + if s != setname: + continue + g, xs = traced(f) + try: + x, _n, conv = m(g, a, b, XTOL, MAXFEV) + except Exception: + continue + if not conv or abs(x - root) > ACC: + continue + _pos, sh, sk = replay_bracket(f, a, b, xs[2:]) + shrinks.extend(sh) + skipped += sk + if shrinks: + srt = sorted(shrinks) + med = srt[len(srt) // 2] + print(f"{setname:6s}{nm:22s}{len(shrinks):>9d}{med:>17.3f}" + f"{sum(shrinks) / len(shrinks):>15.3f}{skipped:>16d}") + print("\nBisection removes exactly 0.500 by construction and is the " + "reference row.") + + +if __name__ == "__main__": + main() diff --git a/stage5_three_point.py b/stage5_three_point.py new file mode 100644 index 0000000..08cf3c6 --- /dev/null +++ b/stage5_three_point.py @@ -0,0 +1,112 @@ +"""Stage 5 - does a three-point scale lift the order from 1.618 to 1.84? + +Stage 4 measured the entire deficit against Brent as the ENDGAME, and the +endgame as nothing but the order of convergence: ours 1.584, Brent 1.809, +TOMS748 2.654. The order follows from how the local scale of the value axis +is read: a two-point divided difference has slope error O(h), which gives the +secant order 1.618. A three-point divided difference has error O(h^2), which +should give ~1.84 - Brent's order - with no new constant, because a divided +difference is a computation, not a fitted coefficient. + +If that is right, `derived3` must (a) measure at order ~1.84, and (b) close +most of the APS gap. If the order does not move, the explanation from +stage 4 was wrong and the paper must not carry it. + +This is the SMOKE run: eight problems, before anything goes to the server. +""" +from __future__ import annotations + +import math + +from simroot.baselines import bisection, brent, toms748 +from simroot.pure import pure_root + +XTOL = 1e-12 +MAXFEV = 200 + +PROBLEMS = [ + ("x^2 - 2", lambda x: x * x - 2.0, 0.0, 2.0, math.sqrt(2.0)), + ("cos(x) - x", lambda x: math.cos(x) - x, 0.0, 1.0, 0.7390851332151607), + ("exp(x) - 2", lambda x: math.exp(x) - 2.0, 0.0, 2.0, math.log(2.0)), + ("x^3 - x - 2", lambda x: x ** 3 - x - 2.0, 1.0, 2.0, 1.5213797068045676), + ("sin(x) - 0.5", lambda x: math.sin(x) - 0.5, 0.0, 1.5, math.asin(0.5)), + ("x^10 - 1 STALL", lambda x: x ** 10 - 1.0, 0.0, 1.3, 1.0), + ("exp(-x)(x-1) FLAT", lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0, 1.0), + ("atan(x)", lambda x: math.atan(x), -1.0, 3.0, 0.0), +] + + +def order_of(method, f, a, b, root): + """Observed order from the running-best error sequence.""" + xs = [] + + def g(x): + xs.append(x) + return f(x) + + try: + method(g, a, b, XTOL, MAXFEV) + except Exception: + return float("nan") + best, errs = float("inf"), [] + for xi in xs: + e = abs(xi - root) + if e < best: + best = e + errs.append(e) + errs = [e for e in errs if e > 1e-14] + if len(errs) < 4: + return float("nan") + ps = [] + for i in range(1, len(errs) - 1): + d1, d2 = errs[i] / errs[i - 1], errs[i + 1] / errs[i] + if 0 < d1 < 1 and 0 < d2 < 1: + ps.append(math.log(d2) / math.log(d1)) + return sorted(ps)[len(ps) // 2] if ps else float("nan") + + +def main(): + methods = [ + ("bisection", lambda f, a, b: bisection(f, a, b, XTOL, MAXFEV)), + ("brent", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV)), + ("toms748", lambda f, a, b: toms748(f, a, b, XTOL, MAXFEV)), + ("OURS 2-point .step", lambda f, a, b: pure_root( + f, a, b, XTOL, MAXFEV, scale="derived", guard="step")), + ("OURS 3-point .step", lambda f, a, b: pure_root( + f, a, b, XTOL, MAXFEV, scale="derived3", guard="step")), + ("OURS 3-point .both", lambda f, a, b: pure_root( + f, a, b, XTOL, MAXFEV, scale="derived3", guard="both")), + ] + width = max(len(n) for n, _ in methods) + 1 + header = (f"{'method':{width}s}" + + "".join(f"{p[0][:13]:>15s}" for p in PROBLEMS) + + f"{'TOTAL':>8s}{'FAIL':>6s}") + print(header) + print("-" * len(header)) + for name, fn in methods: + cells, total, fails = [], 0, 0 + for _, f, a, b, root in PROBLEMS: + x, n, conv = fn(f, a, b) + ok = conv and abs(x - root) <= 1e-8 + cells.append(f"{n:>15d}" if ok else f"{'FAIL(' + str(n) + ')':>15s}") + total += n + fails += 0 if ok else 1 + print(f"{name:{width}s}" + "".join(cells) + f"{total:>8d}{fails:>6d}") + + print("\nobserved order (median over the eight problems)") + print(f"{'method':22s}{'order':>9s} expected") + print("-" * 56) + exp = {"bisection": "1.0", "brent": "1.839", "toms748": "up to 2.7", + "OURS 2-point .step": "1.618", "OURS 3-point .step": "~1.84", + "OURS 3-point .both": "~1.84"} + for name, fn in methods: + ps = [order_of(lambda f_, a_, b_, xt, mx, _fn=fn: _fn(f_, a_, b_), + f, a, b, root) + for _, f, a, b, root in PROBLEMS] + ps = [p for p in ps if math.isfinite(p) and 0.5 < p < 5.0] + med = sorted(ps)[len(ps) // 2] if ps else float("nan") + print(f"{name:22s}{med:>9.3f} {exp[name]}") + + +if __name__ == "__main__": + main() diff --git a/stage6_projection.py b/stage6_projection.py new file mode 100644 index 0000000..5feb34b --- /dev/null +++ b/stage6_projection.py @@ -0,0 +1,88 @@ +"""Stage 6 - the projection safeguard: guarantee AND order, or neither? + +The paper's weak point: the configuration that tops the Alefeld-Potra-Shi +ranking carries no worst-case bound, and the best configuration that does is +14th, 18% behind Brent. Comparing an unguaranteed method's average against +guaranteed ones is not a comparison a reader will accept. + +The three earlier safeguards all REPLACE the computed step with a midpoint, +which throws the computation away and, with the three-point scale, collapses +the order from 1.94 to 1.00. The projection guard instead keeps as much of +the step as the bisection budget allows: + + r_j = 2^(n_half - j) * (xtol/2) - (b-a)/2 + x = x_sim if |x_sim - x_mid| <= r_j + = x_mid + sign(d) * r_j otherwise + +Because the bracket after a step is at most (b-a)/2 + r_j = 2^(n_half-j)*eps, +induction bounds the run by n_half steps: the worst case is EXACTLY bisection. +No constant is introduced - ITP's kappa1, kappa2 and n0 all belong to its +truncation stage, which repairs regula falsi and which the similarity step +does not need. + +What must be true for this to be worth putting in the paper: + (1) zero runs exceed the bisection bound, on all 199 problems; + (2) the order stays near 1.94, not 1.00; + (3) the total is close to the unguarded configuration's. +Each is checked below. This is the SMOKE run. +""" +from __future__ import annotations + +import math + +from simroot.baselines import bisection, brent, itp, toms748 +from simroot.pure import GUARDS, pure_root +from stage5_three_point import PROBLEMS, order_of + +XTOL = 1e-12 +MAXFEV = 200 + + +def main(): + methods = [ + ("bisection", lambda f, a, b: bisection(f, a, b, XTOL, MAXFEV)), + ("brent", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV)), + ("toms748", lambda f, a, b: toms748(f, a, b, XTOL, MAXFEV)), + ("itp (3 constants)", lambda f, a, b: itp(f, a, b, XTOL, MAXFEV)), + ] + for gu in GUARDS: + methods.append((f"OURS 3pt .{gu}", + (lambda g: lambda f, a, b: pure_root( + f, a, b, XTOL, MAXFEV, scale="derived3", + guard=g))(gu))) + + width = max(len(n) for n, _ in methods) + 1 + header = (f"{'method':{width}s}" + + "".join(f"{p[0][:13]:>15s}" for p in PROBLEMS) + + f"{'TOTAL':>8s}{'FAIL':>6s}{'>bisect bound':>15s}") + print(header) + print("-" * len(header)) + for name, fn in methods: + cells, total, fails, over = [], 0, 0, 0 + for _, f, a, b, root in PROBLEMS: + x, n, conv = fn(f, a, b) + ok = conv and abs(x - root) <= 1e-8 + cells.append(f"{n:>15d}" if ok else f"{'FAIL(' + str(n) + ')':>15s}") + total += n + fails += 0 if ok else 1 + # the bisection bound itself, not twice it: 2 endpoint evaluations + # plus ceil(log2(w/xtol)) steps + if ok and n > math.ceil(math.log2(abs(b - a) / XTOL)) + 2: + over += 1 + print(f"{name:{width}s}" + "".join(cells) + + f"{total:>8d}{fails:>6d}{over:>15d}") + + print("\nobserved order (median over the eight problems)") + print(f"{'method':22s}{'order':>9s}") + print("-" * 33) + for gu in GUARDS: + ps = [order_of((lambda g: lambda f_, a_, b_, xt, mx: pure_root( + f_, a_, b_, XTOL, MAXFEV, scale="derived3", guard=g))(gu), + f, a, b, root) for _, f, a, b, root in PROBLEMS] + ps = [p for p in ps if math.isfinite(p) and 0.5 < p < 5.0] + med = sorted(ps)[len(ps) // 2] if ps else float("nan") + print(f"{'OURS 3pt .' + gu:22s}{med:>9.3f}") + + +if __name__ == "__main__": + main() diff --git a/stage6b_invariant.py b/stage6b_invariant.py new file mode 100644 index 0000000..4fafb2b --- /dev/null +++ b/stage6b_invariant.py @@ -0,0 +1,131 @@ +"""Stage 6b - is the projection invariant actually holding? + +The bound test overshoots by exactly one evaluation on the Chandrupatla +problems. Two possible causes, and they need different fixes: + + (a) the INVARIANT w_{j+1} <= 2^(n_max - j) * eps is violated somewhere - + then the implementation is wrong and the guarantee is false; + (b) the invariant holds and the stated BOUND is off by one - then the + guarantee is true and the statement of it needs correcting. + +Guessing between them is not allowed, so the invariant is instrumented +directly on the worst offenders. +""" +from __future__ import annotations + +import math + +from scipy.optimize._tstutils import _CHANDRUPATLA_TESTS_DICTS + +from simroot.pure import PURE_SIMS + +XTOL = 1e-12 +MAXFEV = 200 +EPS = 0.5 * XTOL + + +def replay(f, a, b, similarity="ratio"): + """Re-run the projection rule with the invariant checked at every step. + Mirrors simroot.pure exactly for scale='derived3', guard='project'.""" + S = PURE_SIMS[similarity] + half = math.ceil(math.log2(abs(b - a) / XTOL)) + n_max = 2 * half + fa, fb = f(a), f(b) + A, FA, B, FB = a, fa, b, fb + if abs(fa) <= abs(fb): + x, fx, xp, fp = a, fa, b, fb + else: + x, fx, xp, fp = b, fb, a, fa + xp2 = fp2 = None + j, nfev, worst = 0, 2, 0.0 + violations = [] + while abs(B - A) > XTOL and nfev < MAXFEV: + w = abs(B - A) + lo, hi = min(A, B), max(A, B) + far = B if abs(B - x) >= abs(A - x) else A + if x == xp: + slope = 0.0 + else: + d12 = (fx - fp) / (x - xp) + if xp2 is None or xp2 in (x, xp): + slope = d12 + else: + d01 = (fp - fp2) / (xp - xp2) + slope = d12 + (d12 - d01) / (x - xp2) * (x - xp) + sc = abs(slope) * abs(far - x) + if sc == 0.0 or not math.isfinite(sc): + x_new = 0.5 * (A + B) + else: + x_new = x + (1.0 - S(abs(fx) / sc)) * (far - x) + # The CLAMPED form, matching simroot.pure exactly. The earlier + # radius form r = allowed - w/2 is a difference of two nearly + # equal numbers, and the cancellation admitted points that broke + # the invariant by a relative 8.9e-5 on eleven of these problems. + allowed = 2.0 ** (n_max - j) * EPS + if math.isfinite(allowed): + left, right = hi - allowed, lo + allowed + x_new = (0.5 * (A + B) if left > right + else min(max(x_new, left), right)) + if not math.isfinite(x_new) or not (lo < x_new < hi): + x_new = 0.5 * (A + B) + if x_new in (x, xp): + x_new = 0.5 * (A + B) + if x_new in (x, xp): + break + fn = f(x_new) + nfev += 1 + j += 1 + xp2, fp2, xp, fp, x, fx = xp, fp, x, fx, x_new, fn + if fn == 0.0: + break + if FA * fn < 0.0: + B, FB = x_new, fn + else: + A, FA = x_new, fn + allowed = 2.0 ** (n_max - (j - 1)) * EPS + got = abs(B - A) + worst = max(worst, got / allowed) + # The clamp bound hi - allowed is not representable when the endpoints + # are far larger than the allowance: at |hi| ~ 1e10 the spacing of + # doubles is ~2e-6, so the bound itself is only known to that + # accuracy. This is not a property of the method - bisection's own + # halving is exact only to the same order - so the invariant is + # checked to the representation error of the endpoints rather than to + # the last bit. The operative guarantee, the EVALUATION COUNT, is + # checked exactly and separately in tests/test_projection.py. + slack = 4.0 * math.ulp(max(abs(A), abs(B), 1.0)) + if got > allowed + slack: + violations.append((j, got, allowed)) + return nfev, j, n_max, worst, violations + + +def main(): + print("projection invariant w_{j+1} <= 2^(n_max - j) * eps\n") + print(f"{'problem':10s}{'nfev':>7s}{'steps j':>9s}{'n_max':>8s}" + f"{'worst w/allowed':>18s}{'violations':>12s}") + print("-" * 66) + any_viol = 0 + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + try: + nfev, j, n_max, worst, viol = replay(d["f"], a, b) + except Exception as exc: + print(f"{d['ID']:10s} skipped: {exc}") + continue + if viol or j > n_max: + print(f"{d['ID']:10s}{nfev:>7d}{j:>9d}{n_max:>8d}" + f"{worst:>18.6f}{len(viol):>12d}") + any_viol += len(viol) + print(f"\ntotal invariant violations across the set: {any_viol}") + print("steps j never exceeding n_max is the other half of the claim; " + "rows above\nare the only ones where either could fail.") + if any_viol == 0: + print("\nThe invariant holds. The overshoot is therefore in the " + "STATED bound:\nthe run terminates at step j = n_max, and steps " + "are counted j = 0..n_max,\nso the count is n_max + 1 steps plus " + "the two endpoint evaluations,\ni.e. 2*ceil(log2(w/xtol)) + 3, " + "not + 2.") + + +if __name__ == "__main__": + main() diff --git a/stage7_regimes.py b/stage7_regimes.py new file mode 100644 index 0000000..890aeea --- /dev/null +++ b/stage7_regimes.py @@ -0,0 +1,275 @@ +"""Stage 7 - how many regimes are there? + +On Chandrupatla the bracket scale wins where the three-point derived scale is +the right choice on Alefeld-Potra-Shi. That could mean two regimes. It could +equally mean more than two, in which case a rule that recognises them would +win on problems we currently lose everywhere - not only on Chandrupatla. + +The question is answered in three steps, and the first two need no new runs: +the sweep already recorded the evaluation count of every configuration on +every problem. + + 1. HOW MUCH IS ON THE TABLE. Compare our single fixed choice against an + oracle that is handed the best scale for each problem separately. If the + gap is small there is no regime worth finding and the line stops here. + 2. HOW MANY REGIMES. Count how often each scale is the per-problem winner, + and by how much it wins. A scale that wins often but only by a hair is + not a regime; one that wins rarely but by a landslide is. + 3. ARE THEY RECOGNISABLE. A regime is only useful if it can be told apart + from the inside, from quantities the method can see before it commits - + never from the answer. Step 3 reports what distinguishes them. + +Nothing here selects a configuration for the paper. An oracle is an upper +bound on what regime detection could buy, not a method. +""" +from __future__ import annotations + +import json +import math +from collections import Counter, defaultdict + +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +SCALES = ("start", "bracket", "derived", "derived3") +SIMS = ("ratio", "sqrt", "cbrt", "rational", "ratio_soft", "exp_abs", + "rat_sq", "exp_sq", "cosine") +GUARD = "project" # the safeguard the paper proposes +SIM = "ratio" # the similarity the paper proposes +MAXFEV = 200 + + +def problem_facts(): + """Properties of each problem that a method could in principle see, plus + the bracket width. Nothing here uses the root.""" + out = {} + for d in _APS_TESTS_DICTS: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + args = d.get("args", ()) + f = d["f"] + out[d["ID"]] = dict(set="APS", a=a, b=b, w=abs(b - a), + fa=f(a, *args), fb=f(b, *args)) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + f = d["f"] + out[d["ID"]] = dict(set="CHA", a=a, b=b, w=abs(b - a), + fa=f(a), fb=f(b)) + return out + + +def main(): + rows = json.load(open("sweep_full.json", encoding="utf8")) + by_label = {r["label"]: r for r in rows} + facts = problem_facts() + + def cost(sim, scale, pid): + """Evaluations on one problem, or the full budget if unsolved.""" + r = by_label[f"pure.{sim}.{scale}.{GUARD}"] + d = r["APS"]["per"].get(pid) or r["CHA"]["per"].get(pid) + return d[0] if d[1] else MAXFEV + + pids = list(facts) + + # ------------------------------------------------------------------ + print("=" * 78) + print("1. HOW MUCH IS ON THE TABLE") + print("=" * 78) + print(f" similarity fixed at '{SIM}', safeguard '{GUARD}'; " + f"only the scale varies\n") + print(f"{'':26s}{'APS':>10s}{'CHA':>10s}{'both':>10s}") + print("-" * 56) + for scale in SCALES: + tots = {"APS": 0, "CHA": 0} + for pid in pids: + tots[facts[pid]["set"]] += cost(SIM, scale, pid) + mark = " <- ours" if scale == "derived3" else "" + print(f"{'fixed: ' + scale:26s}{tots['APS']:>10d}{tots['CHA']:>10d}" + f"{tots['APS'] + tots['CHA']:>10d}{mark}") + orc = {"APS": 0, "CHA": 0} + for pid in pids: + orc[facts[pid]["set"]] += min(cost(SIM, s, pid) for s in SCALES) + print(f"{'ORACLE over the 4 scales':26s}{orc['APS']:>10d}{orc['CHA']:>10d}" + f"{orc['APS'] + orc['CHA']:>10d}") + ours = sum(cost(SIM, "derived3", pid) for pid in pids) + tot_orc = orc["APS"] + orc["CHA"] + print(f"\n headroom if the regime were always recognised: " + f"{ours - tot_orc} evaluations " + f"({100.0 * (ours - tot_orc) / ours:.1f}% of ours)") + + orc_all = 0 + for pid in pids: + orc_all += min(cost(s, sc, pid) for s in SIMS for sc in SCALES) + print(f" headroom if the SIMILARITY could also vary: " + f"{ours - orc_all} evaluations " + f"({100.0 * (ours - orc_all) / ours:.1f}%)") + + # ------------------------------------------------------------------ + print() + print("=" * 78) + print("2. HOW MANY REGIMES (per-problem winner among the four scales)") + print("=" * 78) + wins = Counter() + margins = defaultdict(list) + detail = [] + for pid in pids: + c = {s: cost(SIM, s, pid) for s in SCALES} + best = min(c, key=lambda s: c[s]) + runner = min((v for s, v in c.items() if s != best), default=c[best]) + wins[(facts[pid]["set"], best)] += 1 + margins[best].append(c["derived3"] - c[best]) + detail.append((pid, facts[pid], c, best, c["derived3"] - c[best])) + print(f"{'scale':12s}{'APS wins':>10s}{'CHA wins':>10s}" + f"{'evals it saves over ours':>28s}") + print("-" * 62) + for s in SCALES: + saved = sum(m for m in margins[s]) + print(f"{s:12s}{wins[('APS', s)]:>10d}{wins[('CHA', s)]:>10d}" + f"{saved:>28d}") + print("\n ties are credited to the first scale in the list order, so " + "'start'\n is over-credited and the others under-credited; the " + "saving column is\n the honest one.") + + # where does the saving actually live? + detail.sort(key=lambda t: t[4], reverse=True) + print(f"\n the 12 problems with the most to gain:") + print(f" {'problem':12s}{'set':>5s}{'width':>12s}" + f"{'|fa/fb|':>12s}{'ours':>7s}{'best':>7s} best scale") + print(" " + "-" * 72) + for pid, fct, c, best, gain in detail[:12]: + fa, fb = abs(fct["fa"]), abs(fct["fb"]) + ratio = fa / fb if fb else float("inf") + print(f" {pid:12s}{fct['set']:>5s}{fct['w']:>12.3g}" + f"{ratio:>12.3g}{c['derived3']:>7d}{c[best]:>7d} {best}") + + # ------------------------------------------------------------------ + print() + print("=" * 78) + print("3. ARE THE REGIMES RECOGNISABLE FROM THE INSIDE?") + print("=" * 78) + print(" Two quantities a method can see before it commits: the bracket") + print(" width, and how lopsided the two end values are. If the winners") + print(" separate along either, a regime test exists; if they overlap,") + print(" there is nothing to detect and the line closes.\n") + # NB the column below is min/max, not fa/fb as printed in section 2: + # min/max is symmetric and lives in [0,1], which is what a separation + # test would use. Labelled accordingly so the two are not compared. + print(f" {'best scale':12s}{'n':>5s}{'width: median':>16s}" + f"{'min|f|/max|f|: med':>20s}{'log10 range of width':>24s}") + print(" " + "-" * 74) + for s in SCALES: + grp = [d for d in detail if d[3] == s] + if not grp: + continue + ws = sorted(g[1]["w"] for g in grp) + rs = sorted(min(abs(g[1]["fa"]), abs(g[1]["fb"])) / + max(abs(g[1]["fa"]), abs(g[1]["fb"]), 1e-300) + for g in grp) + lo = math.log10(ws[0]) if ws[0] > 0 else float("-inf") + hi = math.log10(ws[-1]) if ws[-1] > 0 else float("-inf") + print(f" {s:12s}{len(grp):>5d}{ws[len(ws) // 2]:>16.3g}" + f"{rs[len(rs) // 2]:>20.3g}{f'{lo:.1f} .. {hi:.1f}':>24s}") + print("\n Overlapping ranges mean the winners are NOT separated by these") + print(" quantities, and a regime test built on them would be a guess.") + + # ------------------------------------------------------------------ + # 4. The scale axis is worth 5.3%; the similarity axis is worth 25.9%. + # So the regimes, if any, live in the similarity - which is the + # opposite of where the Chandrupatla observation pointed. + # + # An oracle over nine similarities on 199 problems will find a gain + # by luck alone, so the gain is not the evidence. The evidence is + # STABILITY: the APS problems come in families (aps.NN.xx are the same + # function at different parameters). If one similarity wins across a + # whole family, that is structure a rule could find. If the winner + # jumps about inside a family, the oracle is fitting noise and the + # line closes. + # ------------------------------------------------------------------ + print() + print("=" * 78) + print("4. THE SIMILARITY AXIS (scale fixed at derived3)") + print("=" * 78) + swins = Counter() + sgain = defaultdict(int) + per_pid_best = {} + for pid in pids: + c = {s: cost(s, "derived3", pid) for s in SIMS} + best = min(c, key=lambda s: c[s]) + per_pid_best[pid] = best + swins[best] += 1 + sgain[best] += c[SIM] - c[best] + print(f"{'similarity':14s}{'problems won':>14s}{'evals saved over ratio':>26s}") + print("-" * 56) + for s, n in swins.most_common(): + print(f"{s:14s}{n:>14d}{sgain[s]:>26d}") + + print("\n STABILITY WITHIN A FAMILY (aps.NN.* is one function, " + "many parameters)") + fam = defaultdict(list) + for pid in pids: + if pid.startswith("aps."): + fam[pid.split(".")[1]].append(per_pid_best[pid]) + consistent = mixed = 0 + print(f" {'family':10s}{'members':>9s}{'distinct winners':>19s} winners") + print(" " + "-" * 68) + for k in sorted(fam): + v = fam[k] + if len(v) < 3: + continue + distinct = Counter(v) + if len(distinct) == 1: + consistent += 1 + else: + mixed += 1 + top = ", ".join(f"{s}x{n}" for s, n in distinct.most_common(3)) + print(f" aps.{k:<7s}{len(v):>9d}{len(distinct):>19d} {top}") + print(f"\n families with a single winner: {consistent} " + f"families with a mixed winner: {mixed}") + print(" A mixed family means the same function at a different parameter") + print(" wants a different similarity - which is not a regime but noise,") + print(" and no rule reading the problem could recover it.") + + # ------------------------------------------------------------------ + # 5. Two suspicions to settle before the line is closed. + # (a) cbrt wins only 15 problems but saves 678 evaluations, while + # being one of the worst similarities overall. A large saving + # from a bad method on few problems is the signature of a lucky + # escape on problems where everything flails, not of a regime. + # (b) the scale winner DID look family-consistent: every bracket-scale + # win in the top twelve was an aps.15.* problem. If one family + # accounts for the scale headroom, the regime is real but tiny. + # ------------------------------------------------------------------ + print() + print("=" * 78) + print("5. SETTLING THE TWO SUSPICIONS") + print("=" * 78) + print(" (a) where cbrt's saving comes from") + print(f" {'problem':12s}{'ours (ratio)':>14s}{'cbrt':>8s}{'saved':>8s}") + print(" " + "-" * 44) + cb = sorted(((pid, cost(SIM, "derived3", pid), cost("cbrt", "derived3", pid)) + for pid in pids if per_pid_best[pid] == "cbrt"), + key=lambda t: t[1] - t[2], reverse=True) + for pid, ours_c, cb_c in cb[:8]: + print(f" {pid:12s}{ours_c:>14d}{cb_c:>8d}{ours_c - cb_c:>8d}") + near_cap = sum(1 for _p, o, _c in cb if o >= 100) + print(f"\n of the {len(cb)} problems cbrt wins, {near_cap} are ones " + f"where our own run costs\n 100+ evaluations - i.e. problems on " + f"which every method is struggling.") + + print("\n (b) is the scale headroom one family?") + fam_gain = defaultdict(int) + for pid, fct, c, best, gain in detail: + key = pid.rsplit(".", 1)[0] if pid.startswith("aps.") else "CHA" + fam_gain[key] += gain + tot = sum(fam_gain.values()) + print(f" {'family':12s}{'evals gained by the oracle':>28s}{'share':>9s}") + print(" " + "-" * 50) + for k, v in sorted(fam_gain.items(), key=lambda kv: kv[1], reverse=True)[:6]: + if v == 0: + continue + print(f" {k:12s}{v:>28d}{100.0 * v / tot:>8.0f}%") + print(f"\n total scale headroom {tot} evaluations out of {ours} " + f"({100.0 * tot / ours:.1f}%)") + + +if __name__ == "__main__": + main() diff --git a/stage8_phase_detector.py b/stage8_phase_detector.py new file mode 100644 index 0000000..2ef6c1b --- /dev/null +++ b/stage8_phase_detector.py @@ -0,0 +1,126 @@ +"""Stage 8 - the phase detector, smoke run. + +Stage 7 found real regimes at the level of a function FAMILY: cbrt beats the +ratio similarity on all five members of Chandrupatla's fun4, by 2.6x, while +losing badly everywhere else. A switch chosen per benchmark makes things +worse (6905 against 6026), so the regime can only be exploited from inside a +run. + +The detector, derived from the contraction law rather than chosen: + + rho = 1 - |f_n| / |f_{n-1}| the fraction of its own promise the + previous step actually kept + sigma <- rho * sigma so the next step is 1/rho longer + +Near the root the local model is exact, rho -> 1 and the correction vanishes; +far from it rho is small and the step lengthens. No constant is introduced, +and because rho <= 1 the correction can only lengthen a step, never shorten +one below the Newton step. + +VERDICT: BOTH CORRECTIONS ARE REFUTED. Read this before the tables below, +which are easy to misread in favour of the second one. + + rho = 1 - |f_n|/|f_{n-1}| fails everything. Order 2.000 -> 0.904, the + eight standard problems 84 -> 161, and the families it was built for do + not move (1364 against 1367, where cbrt gets 677). The derivation was + wrong: near the root |f_n| and |f_{n-1}| are both negligible and their + ratio is noise, so the correction thrashes exactly where it must be + inert. + + m = 1/(1 - f.f''/(f')^2) derivation right, estimator wrong. It keeps the + order (2.001) and improves the eight standard problems (82 against 84), + which is precisely what makes it deceptive - on the full benchmark it + LOSES: 3079 against 2806 on Alefeld-Potra-Shi, 6304 against 6026 over + both sets. Diagnosis: on APS, where almost every root is simple and the + truth is m = 1, the estimator reports m > 1 on 27.9% of steps with + excursions to m = 34.8; on the flat fun3/4/5 families it fires on 35.8%. + 27.9 against 35.8 is no separation. + +What survives is the derivation itself: dropping the linearity assumption from +the contraction law does produce the march exponent, p = L/(L - ln m) with +L = ln(e/D), and it collapses to the multiplier m. What is missing is an +estimator of m robust to curvature noise; three points are not enough. + +The three criteria these were judged against, fixed before the runs: + (1) the fun4 family, where cbrt wins 2.6x, must improve; + (2) the order in the endgame must not move; + (3) the problems the plain rule already wins must not get worse. +""" +from __future__ import annotations + +import math + +from scipy.optimize._tstutils import _CHANDRUPATLA_TESTS_DICTS + +from simroot.baselines import bisection, brent, toms748 +from simroot.pure import pure_root +from stage5_three_point import PROBLEMS, order_of + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 + +VARIANTS = [ + ("ratio / 3-point", "ratio", "derived3"), + ("ratio / 3-point + rho", "ratio", "derived3_rho"), + ("ratio / 2-point", "ratio", "derived"), + ("ratio / 2-point + rho", "ratio", "derived_rho"), + ("ratio / 3-point + m", "ratio", "derived3_m"), + ("cbrt / 3-point", "cbrt", "derived3"), +] + + +def run(sim, scale, f, a, b): + return pure_root(f, a, b, XTOL, MAXFEV, similarity=sim, scale=scale, + guard="project") + + +def main(): + print("(1) the fun4 family - where stage 7 found the regime\n") + fam = [d for d in _CHANDRUPATLA_TESTS_DICTS + if d["ID"].startswith(("fun3.", "fun4.", "fun5."))] + head = f"{'variant':26s}" + "".join(f"{d['ID']:>9s}" for d in fam) + f"{'TOTAL':>9s}" + print(head) + print("-" * len(head)) + for name, sim, scale in VARIANTS: + cells, tot = [], 0 + for d in fam: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + x, n, conv = run(sim, scale, d["f"], a, b) + ok = conv and abs(x - float(d["root"])) <= ACC + cells.append(f"{n:>9d}" if ok else f"{'FAIL':>9s}") + tot += n if ok else MAXFEV + print(f"{name:26s}" + "".join(cells) + f"{tot:>9d}") + + print("\n(2) the eight standard problems - the endgame must not suffer\n") + head = (f"{'variant':26s}" + "".join(f"{p[0][:11]:>13s}" for p in PROBLEMS) + + f"{'TOTAL':>8s}{'FAIL':>6s}") + print(head) + print("-" * len(head)) + for label, fn in ([("bisection", lambda f, a, b: bisection(f, a, b, XTOL, MAXFEV)), + ("brent", lambda f, a, b: brent(f, a, b, XTOL, MAXFEV)), + ("toms748", lambda f, a, b: toms748(f, a, b, XTOL, MAXFEV))] + + [(n, (lambda s, sc: lambda f, a, b: run(s, sc, f, a, b))(s, sc)) + for n, s, sc in VARIANTS]): + cells, tot, fails = [], 0, 0 + for _n, f, a, b, root in PROBLEMS: + x, n, conv = fn(f, a, b) + ok = conv and abs(x - root) <= 1e-8 + cells.append(f"{n:>13d}" if ok else f"{'FAIL(' + str(n) + ')':>13s}") + tot += n + fails += 0 if ok else 1 + print(f"{label:26s}" + "".join(cells) + f"{tot:>8d}{fails:>6d}") + + print("\n(3) observed order - the correction must vanish near the root\n") + print(f"{'variant':26s}{'order':>9s}") + print("-" * 35) + for name, sim, scale in VARIANTS: + ps = [order_of((lambda s, sc: lambda f_, a_, b_, xt, mx: + run(s, sc, f_, a_, b_))(sim, scale), f, a, b, root) + for _n, f, a, b, root in PROBLEMS] + ps = [p for p in ps if math.isfinite(p) and 0.5 < p < 5.0] + print(f"{name:26s}{(sorted(ps)[len(ps) // 2] if ps else float('nan')):>9.3f}") + + +if __name__ == "__main__": + main() diff --git a/stage9_timing.py b/stage9_timing.py new file mode 100644 index 0000000..532a9ef --- /dev/null +++ b/stage9_timing.py @@ -0,0 +1,333 @@ +"""Stage 9 - wall-clock time, and what it is worth. + +Evaluations of f are the right cost model for a root finder because in any +real problem f is the expensive part. Wall-clock time measures something +different and narrower: the method's OWN arithmetic per step. It matters only +when f is cheap, and it is implementation- and language-bound, so a timing +comparison is evidence about this code rather than about the algorithms. + +Three measurements, in increasing order of usefulness to the paper: + + 1. TOTAL TIME over the 199 benchmark problems, whose f are all cheap. This + is the pessimal case for a method that does more arithmetic per step. + 2. OVERHEAD PER EVALUATION, i.e. total time divided by evaluations, with the + cost of f itself subtracted out. This is the machine-comparable number. + 3. BREAK-EVEN COST OF f: how expensive f must be before the difference in + evaluations outweighs the difference in overhead. This is the number a + practitioner actually needs, and it is the one worth publishing. + +Timing method: each configuration runs the whole set R times and the MINIMUM +is kept. The minimum is the right estimator here - noise from other processes +can only ever add time, never remove it - and it is not a summary statistic +standing in for a decision. + +Only pure-Python implementations are compared, so the arithmetic is +commensurable. scipy's toms748 is pure Python too and is included; a compiled +brentq would not be comparable and is excluded. +""" +from __future__ import annotations + +import math +import time + +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from simroot.baselines import bisection, brent, itp, ridders, toms748 +from simroot.pure import pure_root + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 +REPEATS = 5 + + +def ours(f, a, b, xtol, maxfev): + return pure_root(f, a, b, xtol, maxfev, similarity="ratio", + scale="derived3", guard="project") + + +def ours_inlined(f, a, b, xtol, maxfev): + """The SAME algorithm as pure_root(ratio, derived3, project), written as + one flat loop instead of a similarity callable plus three helper + functions. + + This exists only to answer one question: is our per-step cost algorithmic, + or is it Python call overhead in a modular implementation? It must return + exactly the same iterates and the same evaluation count as pure_root - the + caller checks that - so any time it saves is overhead, not arithmetic. + """ + n = 0 + x = 0.5 * (a + b) + try: + fa = f(a); fb = f(b); n = 2 + if fa == 0.0: + return a, n, True + if fb == 0.0: + return b, n, True + if fa * fb > 0.0: + raise ValueError("f(a) and f(b) must straddle zero") + A, FA, B = a, fa, b + if abs(fa) <= abs(fb): + x, fx, xp, fp = a, fa, b, fb + else: + x, fx, xp, fp = b, fb, a, fa + xp2 = fp2 = None + eps = 0.5 * xtol + w0 = abs(B - A) + n_max = 2 * (math.ceil(math.log2(w0 / xtol)) if w0 > xtol else 0) + allow = 2.0 ** n_max * eps + s2 = s1 = w0 + while abs(B - A) > xtol: + lo = A if A < B else B + hi = B if A < B else A + far = B if abs(B - x) >= abs(A - x) else A + # three-point divided difference, inline + if x == xp: + slope = 0.0 + else: + d12 = (fx - fp) / (x - xp) + if not math.isfinite(d12): + slope = 0.0 # as _slope3 does: no usable slope + elif xp2 is None or xp2 == xp or xp2 == x: + slope = d12 + else: + d01 = (fp - fp2) / (xp - xp2) + slope = d12 + (d12 - d01) / (x - xp2) * (x - xp) + if not math.isfinite(slope): + slope = d12 + sc = abs(slope) * abs(far - x) + if sc == 0.0 or not math.isfinite(sc): + xn = 0.5 * (A + B) + else: + z = abs(fx) / sc + step = (z if z < 1.0 else 1.0) * (far - x) # 1 - max(0,1-z) + # NB the proposed configuration is guard="project", which has + # NO step test - applying one here made this a different + # algorithm on 132 of the 199 problems, and the equality + # check above caught it. + xn = x + step + if allow == allow and allow != math.inf: # finite + left = hi - allow + right = lo + allow + if left > right: + xn = 0.5 * (lo + hi) + elif xn < left: + xn = left + elif xn > right: + xn = right + step = xn - x + s2 = s1 + s1 = abs(step) + if not math.isfinite(xn) or not (lo < xn < hi): + xn = 0.5 * (A + B) + if xn == x or xn == xp: + xn = 0.5 * (A + B) + if xn == x or xn == xp: + return xn, n, abs(B - A) <= xtol + if n >= maxfev: + return x, n, False + fn = f(xn); n += 1 + allow *= 0.5 + xp2, fp2, xp, fp, x, fx = xp, fp, x, fx, xn, fn + if fn == 0.0: + return xn, n, True + if FA * fn < 0.0: + B = xn + else: + A, FA = xn, fn + return 0.5 * (A + B), n, True + except ValueError: + raise + except Exception: + return x, n, False + + +METHODS = [ + ("OURS (similarity)", ours), + ("OURS, inlined", ours_inlined), + ("brent", brent), + ("toms748 (scipy)", toms748), + ("itp", itp), + ("ridders", ridders), + ("bisection", bisection), +] + + +def load(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(((lambda ff, aa: lambda x: ff(x, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(((lambda ff: lambda x: ff(x))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +def sweep_once(method, probs): + """One pass over every problem; returns (seconds, evaluations, solved).""" + t0 = time.perf_counter() + evals = solved = 0 + for f, a, b, root in probs: + try: + x, n, conv = method(f, a, b, XTOL, MAXFEV) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + evals += n + solved += bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + return time.perf_counter() - t0, evals, solved + + +def make_costly(f, work): + """f with a controlled amount of extra arithmetic per call, standing in + for an f that is expensive because it runs a simulation or reads a table.""" + if work <= 0: + return f + + def g(x): + s = 0.0 + for i in range(work): + s += (i + x) * 1.0000001 + return f(x) + s * 0.0 + + return g + + +def calibrate(probs, work): + """The wall-clock cost of one call at this work level, measured the same + way the solvers will pay it.""" + # calibrating on one problem's f measured that f's quirks, not the work + # level: the result came out non-monotonic in the work, which is proof + # the estimate was noise. Sample across the set instead. + sample = probs[::10] + pairs = [] + for f, a, b, _r in sample: + g = make_costly(f, work) + for k in range(10): + pairs.append((g, a + (b - a) * (k + 0.5) / 10.0)) + best = math.inf + for _ in range(REPEATS): + t0 = time.perf_counter() + for g, p in pairs: + g(p) + best = min(best, (time.perf_counter() - t0) / len(pairs)) + return best + + +def main(): + probs = load() + print(f"{len(probs)} problems, {REPEATS} repeats, minimum kept\n") + + + # the inlined variant is only admissible evidence if it is the same + # algorithm; anything else and its timing means nothing + mism = [] + for f, a, b, root in probs: + try: + r1 = ours(f, a, b, XTOL, MAXFEV) + except Exception: + r1 = None + try: + r2 = ours_inlined(f, a, b, XTOL, MAXFEV) + except Exception: + r2 = None + if (r1 is None) != (r2 is None) or (r1 and r2 and r1[1] != r2[1]): + mism.append((r1, r2)) + print(f"inlined variant vs pure_root: {len(mism)} of {len(probs)} " + f"problems where the evaluation count differs") + methods = list(METHODS) + if mism: + print(" NOT the same algorithm, so it is DROPPED from the tables") + print(" rather than shown with a caveat nobody reads. The question") + print(" it was meant to settle - whether our per-step cost is") + print(" arithmetic or Python call overhead - therefore stays open.") + print(f" first divergence: {mism[0]}") + methods = [(n, m) for n, m in methods if "inlined" not in n] + print() + + rows = [] + for name, m in methods: + secs, evals, solved = min(sweep_once(m, probs) for _ in range(REPEATS)) + rows.append((name, secs, evals, solved)) + + print("1. TOTAL TIME on the benchmark as it stands - every f here is") + print(" cheap, which is the worst case for a method that does more") + print(" arithmetic per step.") + print(f"{'method':22s}{'ms':>10s}{'evals':>9s}{'solved':>9s}" + f"{'vs ours':>10s}") + print("-" * 62) + base = next(r[1] for r in rows if r[0].startswith("OURS")) + for name, secs, evals, solved in rows: + print(f"{name:22s}{secs * 1e3:>10.1f}{evals:>9d}{solved:>7d}/199" + f"{(secs / base - 1) * 100:>9.1f}%") + + # ------------------------------------------------------------------ + # 2. The crossover, measured rather than modelled. + # + # An earlier version estimated a per-evaluation overhead by measuring + # the cost of f separately and subtracting evals * t_f. It produced + # NEGATIVE overheads for four of six methods, which is impossible and + # proved the estimate wrong: sampling f across the whole bracket + # charges it for expensive regions the solvers never visit. + # + # Nothing is subtracted here. f is made progressively more expensive + # by a controlled amount of extra arithmetic, and the totals are timed + # directly. The crossover is then read off, not derived. + # ------------------------------------------------------------------ + print("\n2. WHERE THE CROSSOVER IS (f made progressively more expensive,") + print(" nothing subtracted; total ms over all 199 problems)") + works = [0, 3, 10, 30, 100, 300] + costs = [calibrate(probs, w) for w in works] + if any(costs[i + 1] <= costs[i] for i in range(len(costs) - 1)): + print(" WARNING: the calibration is not monotonic in the work " + "level, so the\n machine is too noisy for this measurement " + "and the crossover below\n must not be quoted.") + head = (f"{'cost of one f call':22s}" + + "".join(f"{c * 1e6:>11.2f}us" for c in costs)) + print(head) + print("-" * len(head)) + trend = {} + for name, m in methods: + cells = [] + for w in works: + pr = [(make_costly(f, w), a, b, r) for f, a, b, r in probs] + secs = min(sweep_once(m, pr)[0] for _ in range(2)) + cells.append(secs) + trend[name] = cells + print(f"{name:22s}" + "".join(f"{c * 1e3:>13.1f}" for c in cells)) + + print("\n crossover against ours:") + ours_t = trend[next(n for n, _ in methods if n.startswith('OURS'))] + for name, _m in methods: + if name.startswith("OURS"): + continue + # A crossing must PERSIST: taking the first one reported that we + # overtake Brent at 2.3 us, which the very next measurement + # contradicted. Require us to be ahead at that level and at every + # level above it, and say plainly when no such point exists. + cross = None + for i, c in enumerate(costs): + if all(trend[name][k] > ours_t[k] for k in range(i, len(costs))): + cross = c + break + flips = sum(1 for k in range(len(costs) - 1) + if (trend[name][k] > ours_t[k]) != + (trend[name][k + 1] > ours_t[k + 1])) + note = f" [{flips} sign changes - noisy]" if flips > 1 else "" + if cross is None: + print(f" {name:20s} faster than us at every level measured, " + f"up to f = {costs[-1] * 1e6:.1f} us{note}") + elif cross == costs[0]: + print(f" {name:20s} we are faster at every level, including " + f"the raw benchmark{note}") + else: + print(f" {name:20s} we are faster from f = " + f"{cross * 1e6:.1f} us per call upwards{note}") + + +if __name__ == "__main__": + main() diff --git a/summary_table.py b/summary_table.py new file mode 100644 index 0000000..7723d61 --- /dev/null +++ b/summary_table.py @@ -0,0 +1,196 @@ +"""One consolidated view of everything the project established. + +Reads sweep_full.json so the summary cannot drift from the run. Facts that +come from the stage scripts rather than the sweep (the contraction law, the +observed orders, the phase split, the step quality) are recomputed here from +the same code the stages use, not copied. +""" +from __future__ import annotations + +import json +import math + +from report_sweep import PROPOSED, head_to_head, place, rank +from simroot.baselines import bisection, brent, toms748 +from simroot.pure import PURE_SIMS, pure_root +from stage5_three_point import PROBLEMS, order_of + +XTOL = 1e-12 +MAXFEV = 200 + + +def line(t=""): + print(t) + + +def main(): + rows = json.load(open("sweep_full.json", encoding="utf8")) + + def R(setname, lbl): + return next(r for r in rows if r["label"] == lbl)[setname] + + line("=" * 78) + line("1. THE PROPOSED METHOD (fixed by the theory, not chosen from the " + "ranking)") + line("=" * 78) + line(" similarity S(z) = max(0, 1 - |z|) slope of (1-S) at 0 is 1") + line(" scale |f'| from a 3-point divided difference, times the " + "distance to the far end") + line(" safeguard projection onto [hi - a_j, lo + a_j], " + "a_j = 2^(n_max - j) * xtol/2") + line(" constants none") + line(f" guarantee 2*ceil(log2(w/xtol)) + 3 evaluations " + f"(verified on all 199 problems)") + line() + for s, name in (("APS", "Alefeld-Potra-Shi (154)"), + ("CHA", "Chandrupatla (45)")): + d = R(s, PROPOSED) + line(f" {name:26s} place {place(rows, s, PROPOSED):>3d}/{len(rows)} " + f"solved {d['solved']}/{d['n']} {d['total']} evaluations " + f"bound violations {d['over']}") + + line() + line("=" * 78) + line("2. AGAINST THE STATE OF THE ART") + line("=" * 78) + line(f"{'':10s}{'method':22s}{'constants':>11s}{'solved':>9s}" + f"{'evals':>8s}{'vs us (W/T/L)':>16s}") + line("-" * 78) + tuned = {"brent": "3 tests", "toms748": "2", "itp": "3", + "itp_oracle": "3, per problem", "bisection": "none", + "regula_falsi": "none", "ridders": "none", "illinois": "1"} + for s in ("APS", "CHA"): + d = R(s, PROPOSED) + line(f"{s:10s}{'OURS':22s}{'none':>11s}" + f"{d['solved']:>6d}/{d['n']:<2d}{d['total']:>8d}{'-':>16s}") + for b in ("toms748", "brent", "itp", "itp_oracle", "ridders", + "bisection", "regula_falsi"): + db = R(s, b) + w, t, l, _ = head_to_head(rows, PROPOSED, b, s) + line(f"{'':10s}{b:22s}{tuned[b]:>11s}" + f"{db['solved']:>6d}/{db['n']:<2d}{db['total']:>8d}" + f"{f'{w}/{t}/{l}':>16s}") + line() + + line("=" * 78) + line("3. WHAT THE SAFEGUARD COSTS (same rule, same scale, guard varied)") + line("=" * 78) + line(f"{'guard':12s}{'APS evals':>11s}{'APS solved':>12s}" + f"{'CHA evals':>11s}{'CHA solved':>12s}{'CHA over bound':>16s}") + line("-" * 78) + for gu in ("none", "project", "safe", "step", "both", "bracket"): + lbl = f"pure.ratio.derived3.{gu}" + a, c = R("APS", lbl), R("CHA", lbl) + mark = " <- proposed" if gu == "project" else "" + line(f"{gu:12s}{a['total']:>11d}{a['solved']:>9d}/154" + f"{c['total']:>11d}{c['solved']:>9d}/45{c['over']:>16d}{mark}") + + line() + line("=" * 78) + line("4. THE CONTRACTION LAW, CONFIRMED ACROSS THE WHOLE GRID") + line("=" * 78) + line(" rate = |1 - c * |f'(r)| * D / sigma| , c = slope of (1-S) at 0") + line(" predicted 0.1716, measured 0.1716 (four digits)") + line() + lin = ("ratio", "rational", "exp_abs") + quad = ("rat_sq", "exp_sq", "cosine") + line(f"{'scale':16s}{'c = 1 (linear)':>18s}{'c = 0 (quadratic)':>20s}" + f"{'ratio':>10s}") + line("-" * 66) + for scale in ("derived3", "derived", "bracket", "start"): + vals = {} + for group, gname in ((lin, "lin"), (quad, "quad")): + tot = cnt = 0 + for r in rows: + if r["spec"][0] != "pure": + continue + _, sim, sc, gu = r["spec"] + if sc == scale and gu == "step" and sim in group: + cnt += 1 + tot += r["APS"]["total"] + r["CHA"]["total"] + vals[gname] = tot / cnt + line(f"{scale:16s}{vals['lin']:>18.0f}{vals['quad']:>20.0f}" + f"{vals['quad'] / vals['lin']:>10.2f}x") + line() + best = {} + for r in rows: + if r["spec"][0] != "pure" or r["spec"][3] != "step": + continue + k = r["spec"][1] + best[k] = min(best.get(k, 10 ** 9), r["APS"]["total"] + r["CHA"]["total"]) + line(" similarity ranking (best over scales). c is the slope of (1-S)") + line(" at the origin, measured numerically - printed as a number rather") + line(" than bucketed, because 1/(1+|z|)^2 has c = 2 and a bucket would") + line(" have mislabelled it:") + for sim, v in sorted(best.items(), key=lambda kv: kv[1]): + h = 1e-7 + c = (1.0 - PURE_SIMS[sim](h)) / h + line(f" {sim:12s} {v:>7d} c = {c:>10.3g}") + + line() + line("=" * 78) + line("5. ORDER OF CONVERGENCE (measured, median over 8 standard problems)") + line("=" * 78) + line(f"{'method':34s}{'measured':>10s}{'theory':>26s}") + line("-" * 72) + specs = [ + ("bisection", lambda f, a, b, xt, mx: bisection(f, a, b, XTOL, MAXFEV), + "1.0"), + ("OURS, 2-point scale", + lambda f, a, b, xt, mx: pure_root(f, a, b, XTOL, MAXFEV, + scale="derived", guard="project"), + "1.618 (secant)"), + ("brent", lambda f, a, b, xt, mx: brent(f, a, b, XTOL, MAXFEV), + "1.839 (inverse quadratic)"), + ("OURS, 3-point scale <- proposed", + lambda f, a, b, xt, mx: pure_root(f, a, b, XTOL, MAXFEV, + scale="derived3", guard="project"), + "~1.84 (3-point)"), + ("toms748", lambda f, a, b, xt, mx: toms748(f, a, b, XTOL, MAXFEV), + "up to 2.7 (cubic)"), + ] + for name, fn, th in specs: + ps = [order_of(fn, f, a, b, root) for _n, f, a, b, root in PROBLEMS] + ps = [p for p in ps if math.isfinite(p) and 0.5 < p < 5.0] + med = sorted(ps)[len(ps) // 2] if ps else float("nan") + line(f"{name:34s}{med:>10.3f}{th:>26s}") + + line() + line("=" * 78) + line("6. WHAT WAS REFUTED (so it is not reopened)") + line("=" * 78) + for i, t in enumerate([ + "similarity normalised by the two bracket ends IS regula falsi, " + "identically", + "a faster-changing similarity is not better: sqrt and cbrt " + "(c~3e3, 5e4) fail 5-6 of 8", + "prototype-pair aggregation with softmax over the memory: " + "0 wins / 6 ties / 147 losses vs brent", + "'we win because their safeguard fires more': brent fires 53% " + "where it WINS, 34% where it loses", + "'we win because our steps are bolder': brent is bolder on CHA " + "(56.3% vs 41.8%) and loses", + "guards that REPLACE the step destroy the order: 1.94 -> 1.00, " + "2806 -> 7260 evaluations", + "zero slack in the projection is degenerate: no freedom, behaves " + "as bisection", + "the projection written as a radius loses the invariant to " + "cancellation (8.9e-5)"], 1): + line(f" {i}. {t}") + + line() + line("=" * 78) + line("7. STILL OPEN") + line("=" * 78) + line(" - on Chandrupatla, ITP (2857) and its per-problem oracle (2611) " + "still beat us (3220)") + line(" - the nominal CHA winner is another similarity configuration " + "solving 41/45 at a worse total") + line(" - aps.13.00, f(x) = x*exp(-1/x^2), is unsolved by every method: " + "it underflows to exactly") + line(" zero throughout |x| < 0.086, so every method returns a machine " + "zero far from the root") + + +if __name__ == "__main__": + main() diff --git a/sweep_full.json b/sweep_full.json new file mode 100644 index 0000000..1029243 --- /dev/null +++ b/sweep_full.json @@ -0,0 +1 @@ +[{"label": "ridders", "spec": ["base", "ridders"], "APS": {"total": 3313, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [14, true], "aps.02.00": [20, true], "aps.02.01": [16, true], "aps.02.02": [58, true], "aps.02.03": [18, true], "aps.02.04": [16, true], "aps.02.05": [20, true], "aps.02.06": [16, true], "aps.02.07": [18, true], "aps.02.08": [24, true], "aps.02.09": [18, true], "aps.03.00": [4, true], "aps.03.01": [4, true], "aps.03.02": [4, true], "aps.04.00": [84, true], "aps.04.01": [20, true], "aps.04.02": [16, true], "aps.04.03": [16, true], "aps.04.04": [18, true], "aps.04.05": [16, true], "aps.04.06": [14, true], "aps.04.07": [14, true], "aps.04.08": [16, true], "aps.04.09": [16, true], "aps.04.10": [12, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [16, true], "aps.05.00": [16, true], "aps.06.00": [10, true], "aps.06.01": [12, true], "aps.06.02": [12, true], "aps.06.03": [12, true], "aps.06.04": [14, true], "aps.06.05": [12, true], "aps.06.06": [14, true], "aps.06.07": [14, true], "aps.06.08": [14, true], "aps.06.09": [14, true], "aps.07.00": [16, true], "aps.07.01": [16, true], "aps.07.02": [18, true], "aps.08.00": [3, true], "aps.08.01": [14, true], "aps.08.02": [16, true], "aps.08.03": [18, true], "aps.08.04": [20, true], "aps.09.00": [40, true], "aps.09.01": [34, true], "aps.09.02": [18, true], "aps.09.03": [12, true], "aps.09.04": [12, true], "aps.09.05": [14, true], "aps.09.06": [12, true], "aps.10.00": [16, true], "aps.10.01": [14, true], "aps.10.02": [14, true], "aps.10.03": [62, true], "aps.10.04": [16, true], "aps.11.00": [12, true], "aps.11.01": [16, true], "aps.11.02": [16, true], "aps.11.03": [16, true], "aps.12.00": [12, true], "aps.12.01": [14, true], "aps.12.02": [14, true], "aps.12.03": [14, true], "aps.12.04": [14, true], "aps.12.05": [14, true], "aps.12.06": [14, true], "aps.12.07": [14, true], "aps.12.08": [12, true], "aps.12.09": [14, true], "aps.12.10": [14, true], "aps.12.11": [14, true], "aps.12.12": [14, true], "aps.12.13": [14, true], "aps.12.14": [14, true], "aps.12.15": [14, true], "aps.12.16": [14, true], "aps.12.17": [14, true], "aps.12.18": [14, true], "aps.13.00": [11, false], "aps.14.00": [20, true], "aps.14.01": [20, true], "aps.14.02": [20, true], "aps.14.03": [20, true], "aps.14.04": [20, true], "aps.14.05": [20, true], "aps.14.06": [20, true], "aps.14.07": [20, true], "aps.14.08": [22, true], "aps.14.09": [20, true], "aps.14.10": [20, true], "aps.14.11": [20, true], "aps.14.12": [20, true], "aps.14.13": [20, true], "aps.14.14": [20, true], "aps.14.15": [20, true], "aps.14.16": [20, true], "aps.14.17": [22, true], "aps.14.18": [22, true], "aps.14.19": [20, true], "aps.14.20": [20, true], "aps.14.21": [20, true], "aps.14.22": [20, true], "aps.14.23": [20, true], "aps.14.24": [20, true], "aps.14.25": [20, true], "aps.14.26": [20, true], "aps.14.27": [20, true], "aps.14.28": [20, true], "aps.14.29": [20, true], "aps.14.30": [20, true], "aps.14.31": [20, true], "aps.14.32": [20, true], "aps.14.33": [20, true], "aps.14.34": [20, true], "aps.14.35": [22, true], "aps.14.36": [20, true], "aps.14.37": [22, true], "aps.14.38": [20, true], "aps.14.39": [20, true], "aps.15.00": [30, true], "aps.15.01": [28, true], "aps.15.02": [28, true], "aps.15.03": [30, true], "aps.15.04": [28, true], "aps.15.05": [28, true], "aps.15.06": [28, true], "aps.15.07": [30, true], "aps.15.08": [28, true], "aps.15.09": [28, true], "aps.15.10": [30, true], "aps.15.11": [28, true], "aps.15.12": [30, true], "aps.15.13": [28, true], "aps.15.14": [28, true], "aps.15.15": [28, true], "aps.15.16": [28, true], "aps.15.17": [30, true], "aps.15.18": [26, true], "aps.15.19": [26, true], "aps.15.20": [28, true], "aps.15.21": [30, true], "aps.15.22": [30, true], "aps.15.23": [32, true], "aps.15.24": [34, true], "aps.15.25": [32, true], "aps.15.26": [34, true], "aps.15.27": [32, true], "aps.15.28": [30, true], "aps.15.29": [30, true], "aps.15.30": [32, true]}}, "CHA": {"total": 4216, "solved": 36, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [88, true], "fun1.3": [94, true], "fun1.4": [108, true], "fun1.5": [148, true], "fun2.1": [12, true], "fun2.2": [38, true], "fun2.3": [50, true], "fun2.4": [78, true], "fun2.5": [90, true], "fun3.1": [72, true], "fun3.2": [76, true], "fun3.3": [98, true], "fun3.4": [110, true], "fun3.5": [138, true], "fun4.1": [68, true], "fun4.2": [70, true], "fun4.3": [92, true], "fun4.4": [112, true], "fun4.5": [130, true], "fun5.1": [78, true], "fun5.2": [74, true], "fun5.3": [80, true], "fun5.4": [86, true], "fun5.5": [88, true], "fun6.1": [200, false], "fun6.2": [84, true], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [11, false], "fun7.2": [13, false], "fun7.3": [15, false], "fun7.4": [21, false], "fun7.5": [21, false], "fun8.1": [14, true], "fun8.2": [16, true], "fun8.3": [20, true], "fun8.4": [20, true], "fun8.5": [26, true], "fun9.1": [12, true], "fun9.2": [14, true], "fun9.3": [12, true], "fun9.4": [16, true], "fun9.5": [22, true]}}}, {"label": "pegasus", "spec": ["base", "pegasus"], "APS": {"total": 8070, "solved": 133, "n": 154, "over": 4, "per": {"aps.01.00": [9, true], "aps.02.00": [16, true], "aps.02.01": [24, true], "aps.02.02": [15, true], "aps.02.03": [24, true], "aps.02.04": [14, true], "aps.02.05": [12, true], "aps.02.06": [11, true], "aps.02.07": [12, true], "aps.02.08": [12, true], "aps.02.09": [11, true], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [50, true], "aps.04.00": [18, true], "aps.04.01": [26, true], "aps.04.02": [32, true], "aps.04.03": [35, true], "aps.04.04": [40, true], "aps.04.05": [16, true], "aps.04.06": [21, true], "aps.04.07": [28, true], "aps.04.08": [31, true], "aps.04.09": [37, true], "aps.04.10": [28, true], "aps.04.11": [32, true], "aps.04.12": [38, true], "aps.04.13": [37, true], "aps.05.00": [10, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [16, true], "aps.06.07": [17, true], "aps.06.08": [17, true], "aps.06.09": [16, true], "aps.07.00": [16, true], "aps.07.01": [20, true], "aps.07.02": [28, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [17, true], "aps.08.03": [16, true], "aps.08.04": [12, true], "aps.09.00": [10, true], "aps.09.01": [12, true], "aps.09.02": [21, true], "aps.09.03": [26, true], "aps.09.04": [30, true], "aps.09.05": [38, true], "aps.09.06": [41, true], "aps.10.00": [9, true], "aps.10.01": [17, true], "aps.10.02": [14, true], "aps.10.03": [19, true], "aps.10.04": [22, true], "aps.11.00": [15, true], "aps.11.01": [15, true], "aps.11.02": [15, true], "aps.11.03": [12, true], "aps.12.00": [9, true], "aps.12.01": [9, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [11, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [9, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [200, false], "aps.14.00": [36, true], "aps.14.01": [36, true], "aps.14.02": [35, true], "aps.14.03": [36, true], "aps.14.04": [35, true], "aps.14.05": [35, true], "aps.14.06": [35, true], "aps.14.07": [36, true], "aps.14.08": [35, true], "aps.14.09": [35, true], "aps.14.10": [35, true], "aps.14.11": [35, true], "aps.14.12": [35, true], "aps.14.13": [35, true], "aps.14.14": [35, true], "aps.14.15": [36, true], "aps.14.16": [35, true], "aps.14.17": [35, true], "aps.14.18": [35, true], "aps.14.19": [35, true], "aps.14.20": [36, true], "aps.14.21": [35, true], "aps.14.22": [35, true], "aps.14.23": [35, true], "aps.14.24": [35, true], "aps.14.25": [35, true], "aps.14.26": [35, true], "aps.14.27": [35, true], "aps.14.28": [35, true], "aps.14.29": [35, true], "aps.14.30": [35, true], "aps.14.31": [36, true], "aps.14.32": [35, true], "aps.14.33": [35, true], "aps.14.34": [35, true], "aps.14.35": [35, true], "aps.14.36": [36, true], "aps.14.37": [35, true], "aps.14.38": [37, true], "aps.14.39": [35, true], "aps.15.00": [162, true], "aps.15.01": [179, true], "aps.15.02": [196, true], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [107, true], "aps.15.22": [50, true], "aps.15.23": [36, true], "aps.15.24": [31, true], "aps.15.25": [27, true], "aps.15.26": [50, true], "aps.15.27": [61, true], "aps.15.28": [76, true], "aps.15.29": [57, true], "aps.15.30": [33, true]}}, "CHA": {"total": 5858, "solved": 20, "n": 45, "over": 1, "per": {"fun1.1": [23, true], "fun1.2": [14, true], "fun1.3": [19, true], "fun1.4": [33, true], "fun1.5": [92, true], "fun2.1": [10, true], "fun2.2": [50, true], "fun2.3": [146, true], "fun2.4": [93, true], "fun2.5": [111, true], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [13, false], "fun8.1": [22, true], "fun8.2": [23, true], "fun8.3": [25, true], "fun8.4": [24, true], "fun8.5": [30, true], "fun9.1": [8, true], "fun9.2": [17, true], "fun9.3": [25, true], "fun9.4": [39, true], "fun9.5": [54, true]}}}, {"label": "anderson_bjorck", "spec": ["base", "anderson_bjorck"], "APS": {"total": 4723, "solved": 145, "n": 154, "over": 5, "per": {"aps.01.00": [10, true], "aps.02.00": [13, true], "aps.02.01": [10, true], "aps.02.02": [13, true], "aps.02.03": [11, true], "aps.02.04": [11, true], "aps.02.05": [11, true], "aps.02.06": [15, true], "aps.02.07": [18, true], "aps.02.08": [11, true], "aps.02.09": [11, true], "aps.03.00": [97, true], "aps.03.01": [43, true], "aps.03.02": [60, true], "aps.04.00": [95, true], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [94, true], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [102, true], "aps.04.11": [48, true], "aps.04.12": [71, true], "aps.04.13": [136, true], "aps.05.00": [10, true], "aps.06.00": [7, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [12, true], "aps.06.04": [12, true], "aps.06.05": [15, true], "aps.06.06": [21, true], "aps.06.07": [68, true], "aps.06.08": [16, true], "aps.06.09": [18, true], "aps.07.00": [9, true], "aps.07.01": [8, true], "aps.07.02": [9, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [23, true], "aps.08.04": [12, true], "aps.09.00": [10, true], "aps.09.01": [11, true], "aps.09.02": [11, true], "aps.09.03": [11, true], "aps.09.04": [10, true], "aps.09.05": [10, true], "aps.09.06": [8, true], "aps.10.00": [11, true], "aps.10.01": [11, true], "aps.10.02": [10, true], "aps.10.03": [11, true], "aps.10.04": [11, true], "aps.11.00": [5, true], "aps.11.01": [5, true], "aps.11.02": [5, true], "aps.11.03": [5, true], "aps.12.00": [10, true], "aps.12.01": [10, true], "aps.12.02": [10, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [11, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [200, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [16, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [16, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [16, true], "aps.14.09": [17, true], "aps.14.10": [16, true], "aps.14.11": [16, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [16, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [16, true], "aps.14.21": [16, true], "aps.14.22": [17, true], "aps.14.23": [16, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [16, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [16, true], "aps.14.36": [16, true], "aps.14.37": [17, true], "aps.14.38": [16, true], "aps.14.39": [17, true], "aps.15.00": [19, true], "aps.15.01": [47, true], "aps.15.02": [21, true], "aps.15.03": [21, true], "aps.15.04": [20, true], "aps.15.05": [20, true], "aps.15.06": [20, true], "aps.15.07": [21, true], "aps.15.08": [20, true], "aps.15.09": [21, true], "aps.15.10": [21, true], "aps.15.11": [20, true], "aps.15.12": [20, true], "aps.15.13": [54, true], "aps.15.14": [19, true], "aps.15.15": [18, true], "aps.15.16": [17, true], "aps.15.17": [17, true], "aps.15.18": [16, true], "aps.15.19": [17, true], "aps.15.20": [18, true], "aps.15.21": [21, true], "aps.15.22": [22, true], "aps.15.23": [21, true], "aps.15.24": [20, true], "aps.15.25": [47, true], "aps.15.26": [22, true], "aps.15.27": [22, true], "aps.15.28": [25, true], "aps.15.29": [56, true], "aps.15.30": [24, true]}}, "CHA": {"total": 6098, "solved": 20, "n": 45, "over": 4, "per": {"fun1.1": [8, true], "fun1.2": [31, true], "fun1.3": [15, true], "fun1.4": [37, true], "fun1.5": [78, true], "fun2.1": [10, true], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [168, true], "fun3.2": [175, true], "fun3.3": [186, true], "fun3.4": [134, true], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [13, false], "fun8.1": [67, true], "fun8.2": [12, true], "fun8.3": [14, true], "fun8.4": [15, true], "fun8.5": [14, true], "fun9.1": [11, true], "fun9.2": [10, true], "fun9.3": [21, true], "fun9.4": [36, true], "fun9.5": [56, true]}}}, {"label": "regula_falsi", "spec": ["base", "regula_falsi"], "APS": {"total": 10560, "solved": 127, "n": 154, "over": 5, "per": {"aps.01.00": [37, true], "aps.02.00": [200, false], "aps.02.01": [64, true], "aps.02.02": [200, false], "aps.02.03": [47, true], "aps.02.04": [39, true], "aps.02.05": [45, true], "aps.02.06": [48, true], "aps.02.07": [50, true], "aps.02.08": [54, true], "aps.02.09": [53, true], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [19, true], "aps.06.00": [21, true], "aps.06.01": [34, true], "aps.06.02": [34, true], "aps.06.03": [34, true], "aps.06.04": [35, true], "aps.06.05": [38, true], "aps.06.06": [40, true], "aps.06.07": [41, true], "aps.06.08": [41, true], "aps.06.09": [41, true], "aps.07.00": [20, true], "aps.07.01": [13, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [51, true], "aps.08.02": [100, true], "aps.08.03": [156, true], "aps.08.04": [200, false], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [13, true], "aps.09.03": [10, true], "aps.09.04": [8, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [24, true], "aps.10.01": [96, true], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [178, true], "aps.12.00": [22, true], "aps.12.01": [32, true], "aps.12.02": [40, true], "aps.12.03": [45, true], "aps.12.04": [50, true], "aps.12.05": [55, true], "aps.12.06": [61, true], "aps.12.07": [67, true], "aps.12.08": [72, true], "aps.12.09": [77, true], "aps.12.10": [81, true], "aps.12.11": [83, true], "aps.12.12": [87, true], "aps.12.13": [90, true], "aps.12.14": [91, true], "aps.12.15": [93, true], "aps.12.16": [95, true], "aps.12.17": [97, true], "aps.12.18": [100, true], "aps.13.00": [200, false], "aps.14.00": [25, true], "aps.14.01": [25, true], "aps.14.02": [26, true], "aps.14.03": [25, true], "aps.14.04": [25, true], "aps.14.05": [26, true], "aps.14.06": [26, true], "aps.14.07": [25, true], "aps.14.08": [25, true], "aps.14.09": [25, true], "aps.14.10": [26, true], "aps.14.11": [26, true], "aps.14.12": [25, true], "aps.14.13": [26, true], "aps.14.14": [25, true], "aps.14.15": [25, true], "aps.14.16": [26, true], "aps.14.17": [25, true], "aps.14.18": [25, true], "aps.14.19": [25, true], "aps.14.20": [25, true], "aps.14.21": [26, true], "aps.14.22": [26, true], "aps.14.23": [26, true], "aps.14.24": [24, true], "aps.14.25": [25, true], "aps.14.26": [25, true], "aps.14.27": [26, true], "aps.14.28": [26, true], "aps.14.29": [25, true], "aps.14.30": [26, true], "aps.14.31": [25, true], "aps.14.32": [25, true], "aps.14.33": [26, true], "aps.14.34": [25, true], "aps.14.35": [25, true], "aps.14.36": [24, true], "aps.14.37": [25, true], "aps.14.38": [24, true], "aps.14.39": [25, true], "aps.15.00": [41, true], "aps.15.01": [32, true], "aps.15.02": [34, true], "aps.15.03": [35, true], "aps.15.04": [37, true], "aps.15.05": [37, true], "aps.15.06": [36, true], "aps.15.07": [37, true], "aps.15.08": [36, true], "aps.15.09": [34, true], "aps.15.10": [33, true], "aps.15.11": [35, true], "aps.15.12": [36, true], "aps.15.13": [38, true], "aps.15.14": [38, true], "aps.15.15": [39, true], "aps.15.16": [40, true], "aps.15.17": [41, true], "aps.15.18": [42, true], "aps.15.19": [43, true], "aps.15.20": [43, true], "aps.15.21": [44, true], "aps.15.22": [47, true], "aps.15.23": [43, true], "aps.15.24": [42, true], "aps.15.25": [42, true], "aps.15.26": [47, true], "aps.15.27": [52, true], "aps.15.28": [39, true], "aps.15.29": [43, true], "aps.15.30": [44, true]}}, "CHA": {"total": 8239, "solved": 6, "n": 45, "over": 2, "per": {"fun1.1": [40, true], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [92, true], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [100, true], "fun2.5": [66, true], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [21, true], "fun9.2": [120, true], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "dekker", "spec": ["base", "dekker"], "APS": {"total": 3158, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [17, true], "aps.02.01": [13, true], "aps.02.02": [31, true], "aps.02.03": [13, true], "aps.02.04": [40, true], "aps.02.05": [33, true], "aps.02.06": [11, true], "aps.02.07": [38, true], "aps.02.08": [37, true], "aps.02.09": [21, true], "aps.03.00": [16, true], "aps.03.01": [17, true], "aps.03.02": [17, true], "aps.04.00": [27, true], "aps.04.01": [15, true], "aps.04.02": [15, true], "aps.04.03": [15, true], "aps.04.04": [36, true], "aps.04.05": [14, true], "aps.04.06": [15, true], "aps.04.07": [15, true], "aps.04.08": [15, true], "aps.04.09": [15, true], "aps.04.10": [14, true], "aps.04.11": [14, true], "aps.04.12": [14, true], "aps.04.13": [15, true], "aps.05.00": [10, true], "aps.06.00": [8, true], "aps.06.01": [10, true], "aps.06.02": [11, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [15, true], "aps.06.08": [15, true], "aps.06.09": [15, true], "aps.07.00": [12, true], "aps.07.01": [13, true], "aps.07.02": [14, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [13, true], "aps.08.04": [34, true], "aps.09.00": [11, true], "aps.09.01": [12, true], "aps.09.02": [14, true], "aps.09.03": [14, true], "aps.09.04": [16, true], "aps.09.05": [21, true], "aps.09.06": [21, true], "aps.10.00": [21, true], "aps.10.01": [17, true], "aps.10.02": [11, true], "aps.10.03": [10, true], "aps.10.04": [18, true], "aps.11.00": [4, true], "aps.11.01": [13, true], "aps.11.02": [13, true], "aps.11.03": [14, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [12, true], "aps.12.03": [12, true], "aps.12.04": [12, true], "aps.12.05": [12, true], "aps.12.06": [12, true], "aps.12.07": [12, true], "aps.12.08": [11, true], "aps.12.09": [10, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [10, true], "aps.13.00": [200, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [33, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [32, true], "aps.15.04": [32, true], "aps.15.05": [33, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [32, true], "aps.15.09": [31, true], "aps.15.10": [32, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [33, true], "aps.15.15": [33, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [33, true], "aps.15.21": [35, true], "aps.15.22": [37, true], "aps.15.23": [37, true], "aps.15.24": [34, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [39, true], "aps.15.28": [37, true], "aps.15.29": [38, true], "aps.15.30": [35, true]}}, "CHA": {"total": 5372, "solved": 24, "n": 45, "over": 4, "per": {"fun1.1": [9, true], "fun1.2": [39, true], "fun1.3": [25, true], "fun1.4": [31, true], "fun1.5": [46, true], "fun2.1": [11, true], "fun2.2": [25, true], "fun2.3": [30, true], "fun2.4": [44, true], "fun2.5": [49, true], "fun3.1": [168, true], "fun3.2": [175, true], "fun3.3": [187, true], "fun3.4": [193, true], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [13, false], "fun8.1": [11, true], "fun8.2": [13, true], "fun8.3": [13, true], "fun8.4": [16, true], "fun8.5": [18, true], "fun9.1": [10, true], "fun9.2": [11, true], "fun9.3": [18, true], "fun9.4": [15, true], "fun9.5": [15, true]}}}, {"label": "itp", "spec": ["base", "itp"], "APS": {"total": 3957, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [10, true], "aps.02.00": [11, true], "aps.02.01": [10, true], "aps.02.02": [35, true], "aps.02.03": [12, true], "aps.02.04": [32, true], "aps.02.05": [11, true], "aps.02.06": [11, true], "aps.02.07": [11, true], "aps.02.08": [10, true], "aps.02.09": [36, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [18, true], "aps.04.01": [46, true], "aps.04.02": [47, true], "aps.04.03": [46, true], "aps.04.04": [47, true], "aps.04.05": [10, true], "aps.04.06": [9, true], "aps.04.07": [8, true], "aps.04.08": [8, true], "aps.04.09": [7, true], "aps.04.10": [20, true], "aps.04.11": [36, true], "aps.04.12": [36, true], "aps.04.13": [36, true], "aps.05.00": [44, true], "aps.06.00": [11, true], "aps.06.01": [11, true], "aps.06.02": [10, true], "aps.06.03": [12, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [19, true], "aps.06.08": [16, true], "aps.06.09": [21, true], "aps.07.00": [11, true], "aps.07.01": [11, true], "aps.07.02": [9, true], "aps.08.00": [3, true], "aps.08.01": [37, true], "aps.08.02": [44, true], "aps.08.03": [44, true], "aps.08.04": [44, true], "aps.09.00": [11, true], "aps.09.01": [11, true], "aps.09.02": [39, true], "aps.09.03": [10, true], "aps.09.04": [9, true], "aps.09.05": [9, true], "aps.09.06": [9, true], "aps.10.00": [42, true], "aps.10.01": [37, true], "aps.10.02": [11, true], "aps.10.03": [11, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [33, true], "aps.11.02": [44, true], "aps.11.03": [44, true], "aps.12.00": [12, true], "aps.12.01": [13, true], "aps.12.02": [15, true], "aps.12.03": [17, true], "aps.12.04": [15, true], "aps.12.05": [19, true], "aps.12.06": [35, true], "aps.12.07": [13, true], "aps.12.08": [18, true], "aps.12.09": [15, true], "aps.12.10": [34, true], "aps.12.11": [12, true], "aps.12.12": [13, true], "aps.12.13": [12, true], "aps.12.14": [16, true], "aps.12.15": [17, true], "aps.12.16": [13, true], "aps.12.17": [16, true], "aps.12.18": [15, true], "aps.13.00": [10, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [20, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [20, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [36, true], "aps.15.01": [36, true], "aps.15.02": [32, true], "aps.15.03": [34, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [34, true], "aps.15.08": [35, true], "aps.15.09": [32, true], "aps.15.10": [31, true], "aps.15.11": [32, true], "aps.15.12": [36, true], "aps.15.13": [38, true], "aps.15.14": [37, true], "aps.15.15": [38, true], "aps.15.16": [40, true], "aps.15.17": [40, true], "aps.15.18": [34, true], "aps.15.19": [39, true], "aps.15.20": [38, true], "aps.15.21": [40, true], "aps.15.22": [36, true], "aps.15.23": [42, true], "aps.15.24": [40, true], "aps.15.25": [45, true], "aps.15.26": [53, true], "aps.15.27": [47, true], "aps.15.28": [41, true], "aps.15.29": [41, true], "aps.15.30": [45, true]}}, "CHA": {"total": 2857, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [42, true], "fun1.2": [12, true], "fun1.3": [14, true], "fun1.4": [59, true], "fun1.5": [79, true], "fun2.1": [13, true], "fun2.2": [58, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [59, true], "fun3.4": [65, true], "fun3.5": [79, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [65, true], "fun4.5": [79, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [7, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [51, true], "fun7.1": [10, false], "fun7.2": [10, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [6, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [11, true], "fun9.2": [10, true], "fun9.3": [46, true], "fun9.4": [13, true], "fun9.5": [12, true]}}}, {"label": "bisection", "spec": ["base", "bisection"], "APS": {"total": 7530, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [43, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [48, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [45, true], "aps.04.01": [45, true], "aps.04.02": [45, true], "aps.04.03": [45, true], "aps.04.04": [45, true], "aps.04.05": [45, true], "aps.04.06": [45, true], "aps.04.07": [45, true], "aps.04.08": [45, true], "aps.04.09": [45, true], "aps.04.10": [45, true], "aps.04.11": [45, true], "aps.04.12": [45, true], "aps.04.13": [45, true], "aps.05.00": [43, true], "aps.06.00": [42, true], "aps.06.01": [42, true], "aps.06.02": [42, true], "aps.06.03": [42, true], "aps.06.04": [42, true], "aps.06.05": [42, true], "aps.06.06": [42, true], "aps.06.07": [42, true], "aps.06.08": [42, true], "aps.06.09": [42, true], "aps.07.00": [42, true], "aps.07.01": [42, true], "aps.07.02": [42, true], "aps.08.00": [3, true], "aps.08.01": [42, true], "aps.08.02": [42, true], "aps.08.03": [42, true], "aps.08.04": [42, true], "aps.09.00": [42, true], "aps.09.01": [42, true], "aps.09.02": [42, true], "aps.09.03": [42, true], "aps.09.04": [42, true], "aps.09.05": [42, true], "aps.09.06": [42, true], "aps.10.00": [42, true], "aps.10.01": [42, true], "aps.10.02": [42, true], "aps.10.03": [42, true], "aps.10.04": [42, true], "aps.11.00": [42, true], "aps.11.01": [42, true], "aps.11.02": [42, true], "aps.11.03": [42, true], "aps.12.00": [49, true], "aps.12.01": [49, true], "aps.12.02": [49, true], "aps.12.03": [49, true], "aps.12.04": [49, true], "aps.12.05": [49, true], "aps.12.06": [49, true], "aps.12.07": [49, true], "aps.12.08": [49, true], "aps.12.09": [49, true], "aps.12.10": [49, true], "aps.12.11": [49, true], "aps.12.12": [49, true], "aps.12.13": [49, true], "aps.12.14": [49, true], "aps.12.15": [49, true], "aps.12.16": [49, true], "aps.12.17": [49, true], "aps.12.18": [49, true], "aps.13.00": [8, false], "aps.14.00": [52, true], "aps.14.01": [52, true], "aps.14.02": [52, true], "aps.14.03": [52, true], "aps.14.04": [52, true], "aps.14.05": [52, true], "aps.14.06": [52, true], "aps.14.07": [52, true], "aps.14.08": [52, true], "aps.14.09": [52, true], "aps.14.10": [52, true], "aps.14.11": [52, true], "aps.14.12": [52, true], "aps.14.13": [52, true], "aps.14.14": [52, true], "aps.14.15": [52, true], "aps.14.16": [52, true], "aps.14.17": [52, true], "aps.14.18": [52, true], "aps.14.19": [52, true], "aps.14.20": [52, true], "aps.14.21": [52, true], "aps.14.22": [52, true], "aps.14.23": [52, true], "aps.14.24": [52, true], "aps.14.25": [52, true], "aps.14.26": [52, true], "aps.14.27": [52, true], "aps.14.28": [52, true], "aps.14.29": [52, true], "aps.14.30": [52, true], "aps.14.31": [52, true], "aps.14.32": [52, true], "aps.14.33": [52, true], "aps.14.34": [52, true], "aps.14.35": [52, true], "aps.14.36": [52, true], "aps.14.37": [52, true], "aps.14.38": [52, true], "aps.14.39": [52, true], "aps.15.00": [52, true], "aps.15.01": [52, true], "aps.15.02": [52, true], "aps.15.03": [52, true], "aps.15.04": [52, true], "aps.15.05": [52, true], "aps.15.06": [52, true], "aps.15.07": [52, true], "aps.15.08": [52, true], "aps.15.09": [52, true], "aps.15.10": [52, true], "aps.15.11": [52, true], "aps.15.12": [52, true], "aps.15.13": [52, true], "aps.15.14": [52, true], "aps.15.15": [52, true], "aps.15.16": [52, true], "aps.15.17": [52, true], "aps.15.18": [52, true], "aps.15.19": [52, true], "aps.15.20": [52, true], "aps.15.21": [52, true], "aps.15.22": [52, true], "aps.15.23": [52, true], "aps.15.24": [52, true], "aps.15.25": [52, true], "aps.15.26": [52, true], "aps.15.27": [52, true], "aps.15.28": [52, true], "aps.15.29": [52, true], "aps.15.30": [52, true]}}, "CHA": {"total": 3090, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [42, true], "fun1.2": [46, true], "fun1.3": [49, true], "fun1.4": [57, true], "fun1.5": [77, true], "fun2.1": [42, true], "fun2.2": [56, true], "fun2.3": [62, true], "fun2.4": [76, true], "fun2.5": [82, true], "fun3.1": [45, true], "fun3.2": [47, true], "fun3.3": [57, true], "fun3.4": [63, true], "fun3.5": [77, true], "fun4.1": [45, true], "fun4.2": [47, true], "fun4.3": [57, true], "fun4.4": [63, true], "fun4.5": [77, true], "fun5.1": [45, true], "fun5.2": [45, true], "fun5.3": [46, true], "fun5.4": [48, true], "fun5.5": [49, true], "fun6.1": [45, true], "fun6.2": [45, true], "fun6.3": [46, true], "fun6.4": [48, true], "fun6.5": [49, true], "fun7.1": [8, false], "fun7.2": [7, false], "fun7.3": [7, false], "fun7.4": [12, false], "fun7.5": [12, false], "fun8.1": [43, true], "fun8.2": [44, true], "fun8.3": [46, true], "fun8.4": [47, true], "fun8.5": [49, true], "fun9.1": [42, true], "fun9.2": [44, true], "fun9.3": [46, true], "fun9.4": [47, true], "fun9.5": [49, true]}}}, {"label": "illinois", "spec": ["base", "illinois"], "APS": {"total": 7045, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [41, true], "aps.02.00": [45, true], "aps.02.01": [43, true], "aps.02.02": [46, true], "aps.02.03": [45, true], "aps.02.04": [45, true], "aps.02.05": [45, true], "aps.02.06": [44, true], "aps.02.07": [43, true], "aps.02.08": [42, true], "aps.02.09": [42, true], "aps.03.00": [78, true], "aps.03.01": [71, true], "aps.03.02": [86, true], "aps.04.00": [49, true], "aps.04.01": [55, true], "aps.04.02": [61, true], "aps.04.03": [60, true], "aps.04.04": [69, true], "aps.04.05": [48, true], "aps.04.06": [48, true], "aps.04.07": [58, true], "aps.04.08": [62, true], "aps.04.09": [69, true], "aps.04.10": [61, true], "aps.04.11": [66, true], "aps.04.12": [71, true], "aps.04.13": [75, true], "aps.05.00": [43, true], "aps.06.00": [41, true], "aps.06.01": [41, true], "aps.06.02": [38, true], "aps.06.03": [42, true], "aps.06.04": [42, true], "aps.06.05": [38, true], "aps.06.06": [41, true], "aps.06.07": [40, true], "aps.06.08": [40, true], "aps.06.09": [39, true], "aps.07.00": [38, true], "aps.07.01": [34, true], "aps.07.02": [30, true], "aps.08.00": [3, true], "aps.08.01": [38, true], "aps.08.02": [39, true], "aps.08.03": [42, true], "aps.08.04": [40, true], "aps.09.00": [40, true], "aps.09.01": [41, true], "aps.09.02": [39, true], "aps.09.03": [37, true], "aps.09.04": [34, true], "aps.09.05": [30, true], "aps.09.06": [29, true], "aps.10.00": [42, true], "aps.10.01": [38, true], "aps.10.02": [41, true], "aps.10.03": [45, true], "aps.10.04": [50, true], "aps.11.00": [43, true], "aps.11.01": [45, true], "aps.11.02": [43, true], "aps.11.03": [42, true], "aps.12.00": [44, true], "aps.12.01": [45, true], "aps.12.02": [47, true], "aps.12.03": [47, true], "aps.12.04": [48, true], "aps.12.05": [48, true], "aps.12.06": [48, true], "aps.12.07": [48, true], "aps.12.08": [48, true], "aps.12.09": [47, true], "aps.12.10": [47, true], "aps.12.11": [47, true], "aps.12.12": [46, true], "aps.12.13": [44, true], "aps.12.14": [44, true], "aps.12.15": [46, true], "aps.12.16": [46, true], "aps.12.17": [47, true], "aps.12.18": [47, true], "aps.13.00": [200, false], "aps.14.00": [48, true], "aps.14.01": [48, true], "aps.14.02": [48, true], "aps.14.03": [48, true], "aps.14.04": [48, true], "aps.14.05": [48, true], "aps.14.06": [48, true], "aps.14.07": [48, true], "aps.14.08": [48, true], "aps.14.09": [48, true], "aps.14.10": [48, true], "aps.14.11": [48, true], "aps.14.12": [48, true], "aps.14.13": [48, true], "aps.14.14": [48, true], "aps.14.15": [48, true], "aps.14.16": [48, true], "aps.14.17": [48, true], "aps.14.18": [48, true], "aps.14.19": [48, true], "aps.14.20": [48, true], "aps.14.21": [48, true], "aps.14.22": [48, true], "aps.14.23": [48, true], "aps.14.24": [48, true], "aps.14.25": [48, true], "aps.14.26": [48, true], "aps.14.27": [48, true], "aps.14.28": [48, true], "aps.14.29": [48, true], "aps.14.30": [48, true], "aps.14.31": [48, true], "aps.14.32": [48, true], "aps.14.33": [48, true], "aps.14.34": [48, true], "aps.14.35": [48, true], "aps.14.36": [48, true], "aps.14.37": [48, true], "aps.14.38": [48, true], "aps.14.39": [48, true], "aps.15.00": [37, true], "aps.15.01": [38, true], "aps.15.02": [38, true], "aps.15.03": [38, true], "aps.15.04": [38, true], "aps.15.05": [38, true], "aps.15.06": [37, true], "aps.15.07": [37, true], "aps.15.08": [37, true], "aps.15.09": [37, true], "aps.15.10": [37, true], "aps.15.11": [37, true], "aps.15.12": [37, true], "aps.15.13": [36, true], "aps.15.14": [36, true], "aps.15.15": [36, true], "aps.15.16": [35, true], "aps.15.17": [34, true], "aps.15.18": [31, true], "aps.15.19": [34, true], "aps.15.20": [35, true], "aps.15.21": [38, true], "aps.15.22": [35, true], "aps.15.23": [35, true], "aps.15.24": [34, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [37, true], "aps.15.28": [37, true], "aps.15.29": [37, true], "aps.15.30": [37, true]}}, "CHA": {"total": 6234, "solved": 23, "n": 45, "over": 3, "per": {"fun1.1": [39, true], "fun1.2": [45, true], "fun1.3": [52, true], "fun1.4": [67, true], "fun1.5": [105, true], "fun2.1": [41, true], "fun2.2": [79, true], "fun2.3": [93, true], "fun2.4": [119, true], "fun2.5": [131, true], "fun3.1": [144, true], "fun3.2": [153, true], "fun3.3": [182, true], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [13, false], "fun8.1": [55, true], "fun8.2": [56, true], "fun8.3": [55, true], "fun8.4": [58, true], "fun8.5": [59, true], "fun9.1": [42, true], "fun9.2": [40, true], "fun9.3": [52, true], "fun9.4": [74, true], "fun9.5": [93, true]}}}, {"label": "brent", "spec": ["base", "brent"], "APS": {"total": 2889, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [15, true], "aps.02.01": [9, true], "aps.02.02": [15, true], "aps.02.03": [13, true], "aps.02.04": [13, true], "aps.02.05": [12, true], "aps.02.06": [12, true], "aps.02.07": [12, true], "aps.02.08": [12, true], "aps.02.09": [11, true], "aps.03.00": [17, true], "aps.03.01": [19, true], "aps.03.02": [20, true], "aps.04.00": [15, true], "aps.04.01": [17, true], "aps.04.02": [17, true], "aps.04.03": [17, true], "aps.04.04": [18, true], "aps.04.05": [15, true], "aps.04.06": [15, true], "aps.04.07": [15, true], "aps.04.08": [16, true], "aps.04.09": [17, true], "aps.04.10": [15, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [17, true], "aps.05.00": [10, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [14, true], "aps.06.08": [15, true], "aps.06.09": [14, true], "aps.07.00": [9, true], "aps.07.01": [9, true], "aps.07.02": [8, true], "aps.08.00": [3, true], "aps.08.01": [9, true], "aps.08.02": [10, true], "aps.08.03": [12, true], "aps.08.04": [13, true], "aps.09.00": [10, true], "aps.09.01": [11, true], "aps.09.02": [8, true], "aps.09.03": [8, true], "aps.09.04": [7, true], "aps.09.05": [7, true], "aps.09.06": [6, true], "aps.10.00": [8, true], "aps.10.01": [9, true], "aps.10.02": [9, true], "aps.10.03": [12, true], "aps.10.04": [12, true], "aps.11.00": [4, true], "aps.11.01": [12, true], "aps.11.02": [13, true], "aps.11.03": [14, true], "aps.12.00": [6, true], "aps.12.01": [10, true], "aps.12.02": [10, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [11, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [18, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [32, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [32, true], "aps.15.04": [32, true], "aps.15.05": [31, true], "aps.15.06": [31, true], "aps.15.07": [31, true], "aps.15.08": [31, true], "aps.15.09": [31, true], "aps.15.10": [30, true], "aps.15.11": [31, true], "aps.15.12": [31, true], "aps.15.13": [31, true], "aps.15.14": [32, true], "aps.15.15": [32, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [32, true], "aps.15.21": [33, true], "aps.15.22": [34, true], "aps.15.23": [35, true], "aps.15.24": [33, true], "aps.15.25": [35, true], "aps.15.26": [36, true], "aps.15.27": [36, true], "aps.15.28": [36, true], "aps.15.29": [36, true], "aps.15.30": [35, true]}}, "CHA": {"total": 4099, "solved": 38, "n": 45, "over": 18, "per": {"fun1.1": [8, true], "fun1.2": [15, true], "fun1.3": [16, true], "fun1.4": [36, true], "fun1.5": [75, true], "fun2.1": [10, true], "fun2.2": [24, true], "fun2.3": [29, true], "fun2.4": [44, true], "fun2.5": [49, true], "fun3.1": [110, true], "fun3.2": [134, true], "fun3.3": [145, true], "fun3.4": [169, true], "fun3.5": [200, false], "fun4.1": [110, true], "fun4.2": [114, true], "fun4.3": [144, true], "fun4.4": [167, true], "fun4.5": [200, false], "fun5.1": [120, true], "fun5.2": [122, true], "fun5.3": [121, true], "fun5.4": [127, true], "fun5.5": [129, true], "fun6.1": [102, true], "fun6.2": [104, true], "fun6.3": [104, true], "fun6.4": [112, true], "fun6.5": [116, true], "fun7.1": [18, false], "fun7.2": [21, false], "fun7.3": [24, false], "fun7.4": [27, false], "fun7.5": [33, false], "fun8.1": [10, true], "fun8.2": [12, true], "fun8.3": [12, true], "fun8.4": [15, true], "fun8.5": [17, true], "fun9.1": [9, true], "fun9.2": [11, true], "fun9.3": [16, true], "fun9.4": [19, true], "fun9.5": [22, true]}}}, {"label": "pure.cbrt.start.both", "spec": ["pure", "cbrt", "start", "both"], "APS": {"total": 10259, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [66, true], "aps.02.00": [56, true], "aps.02.01": [55, true], "aps.02.02": [56, true], "aps.02.03": [57, true], "aps.02.04": [56, true], "aps.02.05": [56, true], "aps.02.06": [56, true], "aps.02.07": [56, true], "aps.02.08": [56, true], "aps.02.09": [58, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [66, true], "aps.04.01": [65, true], "aps.04.02": [58, true], "aps.04.03": [67, true], "aps.04.04": [66, true], "aps.04.05": [67, true], "aps.04.06": [69, true], "aps.04.07": [62, true], "aps.04.08": [62, true], "aps.04.09": [58, true], "aps.04.10": [61, true], "aps.04.11": [56, true], "aps.04.12": [64, true], "aps.04.13": [60, true], "aps.05.00": [67, true], "aps.06.00": [62, true], "aps.06.01": [64, true], "aps.06.02": [60, true], "aps.06.03": [55, true], "aps.06.04": [62, true], "aps.06.05": [64, true], "aps.06.06": [57, true], "aps.06.07": [64, true], "aps.06.08": [56, true], "aps.06.09": [61, true], "aps.07.00": [58, true], "aps.07.01": [63, true], "aps.07.02": [56, true], "aps.08.00": [3, true], "aps.08.01": [60, true], "aps.08.02": [63, true], "aps.08.03": [65, true], "aps.08.04": [61, true], "aps.09.00": [66, true], "aps.09.01": [65, true], "aps.09.02": [61, true], "aps.09.03": [60, true], "aps.09.04": [55, true], "aps.09.05": [46, true], "aps.09.06": [55, true], "aps.10.00": [66, true], "aps.10.01": [64, true], "aps.10.02": [65, true], "aps.10.03": [68, true], "aps.10.04": [68, true], "aps.11.00": [54, true], "aps.11.01": [61, true], "aps.11.02": [64, true], "aps.11.03": [67, true], "aps.12.00": [73, true], "aps.12.01": [61, true], "aps.12.02": [72, true], "aps.12.03": [72, true], "aps.12.04": [74, true], "aps.12.05": [70, true], "aps.12.06": [71, true], "aps.12.07": [72, true], "aps.12.08": [76, true], "aps.12.09": [77, true], "aps.12.10": [72, true], "aps.12.11": [74, true], "aps.12.12": [75, true], "aps.12.13": [72, true], "aps.12.14": [70, true], "aps.12.15": [71, true], "aps.12.16": [71, true], "aps.12.17": [71, true], "aps.12.18": [67, true], "aps.13.00": [9, false], "aps.14.00": [75, true], "aps.14.01": [75, true], "aps.14.02": [75, true], "aps.14.03": [75, true], "aps.14.04": [75, true], "aps.14.05": [75, true], "aps.14.06": [75, true], "aps.14.07": [75, true], "aps.14.08": [75, true], "aps.14.09": [75, true], "aps.14.10": [75, true], "aps.14.11": [75, true], "aps.14.12": [75, true], "aps.14.13": [75, true], "aps.14.14": [75, true], "aps.14.15": [75, true], "aps.14.16": [75, true], "aps.14.17": [75, true], "aps.14.18": [75, true], "aps.14.19": [75, true], "aps.14.20": [75, true], "aps.14.21": [75, true], "aps.14.22": [75, true], "aps.14.23": [75, true], "aps.14.24": [75, true], "aps.14.25": [75, true], "aps.14.26": [75, true], "aps.14.27": [75, true], "aps.14.28": [75, true], "aps.14.29": [75, true], "aps.14.30": [75, true], "aps.14.31": [75, true], "aps.14.32": [75, true], "aps.14.33": [75, true], "aps.14.34": [75, true], "aps.14.35": [75, true], "aps.14.36": [75, true], "aps.14.37": [75, true], "aps.14.38": [75, true], "aps.14.39": [75, true], "aps.15.00": [58, true], "aps.15.01": [64, true], "aps.15.02": [67, true], "aps.15.03": [63, true], "aps.15.04": [68, true], "aps.15.05": [64, true], "aps.15.06": [68, true], "aps.15.07": [59, true], "aps.15.08": [62, true], "aps.15.09": [65, true], "aps.15.10": [64, true], "aps.15.11": [58, true], "aps.15.12": [68, true], "aps.15.13": [65, true], "aps.15.14": [66, true], "aps.15.15": [63, true], "aps.15.16": [69, true], "aps.15.17": [66, true], "aps.15.18": [68, true], "aps.15.19": [65, true], "aps.15.20": [64, true], "aps.15.21": [57, true], "aps.15.22": [64, true], "aps.15.23": [56, true], "aps.15.24": [62, true], "aps.15.25": [65, true], "aps.15.26": [57, true], "aps.15.27": [62, true], "aps.15.28": [64, true], "aps.15.29": [63, true], "aps.15.30": [54, true]}}, "CHA": {"total": 3845, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [63, true], "fun1.2": [68, true], "fun1.3": [68, true], "fun1.4": [89, true], "fun1.5": [118, true], "fun2.1": [62, true], "fun2.2": [80, true], "fun2.3": [104, true], "fun2.4": [117, true], "fun2.5": [128, true], "fun3.1": [61, true], "fun3.2": [66, true], "fun3.3": [64, true], "fun3.4": [63, true], "fun3.5": [56, true], "fun4.1": [58, true], "fun4.2": [62, true], "fun4.3": [74, true], "fun4.4": [85, true], "fun4.5": [107, true], "fun5.1": [60, true], "fun5.2": [58, true], "fun5.3": [59, true], "fun5.4": [61, true], "fun5.5": [62, true], "fun6.1": [49, true], "fun6.2": [53, true], "fun6.3": [53, true], "fun6.4": [54, true], "fun6.5": [55, true], "fun7.1": [9, false], "fun7.2": [5, false], "fun7.3": [9, false], "fun7.4": [12, false], "fun7.5": [12, false], "fun8.1": [67, true], "fun8.2": [65, true], "fun8.3": [71, true], "fun8.4": [68, true], "fun8.5": [72, true], "fun9.1": [65, true], "fun9.2": [64, true], "fun9.3": [70, true], "fun9.4": [72, true], "fun9.5": [74, true]}}}, {"label": "pure.cbrt.start.bracket", "spec": ["pure", "cbrt", "start", "bracket"], "APS": {"total": 11296, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [74, true], "aps.02.00": [61, true], "aps.02.01": [61, true], "aps.02.02": [61, true], "aps.02.03": [62, true], "aps.02.04": [61, true], "aps.02.05": [60, true], "aps.02.06": [61, true], "aps.02.07": [60, true], "aps.02.08": [61, true], "aps.02.09": [61, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [76, true], "aps.04.01": [74, true], "aps.04.02": [68, true], "aps.04.03": [73, true], "aps.04.04": [75, true], "aps.04.05": [76, true], "aps.04.06": [76, true], "aps.04.07": [68, true], "aps.04.08": [72, true], "aps.04.09": [67, true], "aps.04.10": [66, true], "aps.04.11": [66, true], "aps.04.12": [69, true], "aps.04.13": [69, true], "aps.05.00": [74, true], "aps.06.00": [73, true], "aps.06.01": [74, true], "aps.06.02": [69, true], "aps.06.03": [57, true], "aps.06.04": [75, true], "aps.06.05": [75, true], "aps.06.06": [75, true], "aps.06.07": [73, true], "aps.06.08": [74, true], "aps.06.09": [70, true], "aps.07.00": [65, true], "aps.07.01": [68, true], "aps.07.02": [62, true], "aps.08.00": [3, true], "aps.08.01": [67, true], "aps.08.02": [68, true], "aps.08.03": [75, true], "aps.08.04": [73, true], "aps.09.00": [72, true], "aps.09.01": [71, true], "aps.09.02": [67, true], "aps.09.03": [66, true], "aps.09.04": [60, true], "aps.09.05": [47, true], "aps.09.06": [57, true], "aps.10.00": [70, true], "aps.10.01": [74, true], "aps.10.02": [75, true], "aps.10.03": [78, true], "aps.10.04": [79, true], "aps.11.00": [63, true], "aps.11.01": [71, true], "aps.11.02": [74, true], "aps.11.03": [73, true], "aps.12.00": [81, true], "aps.12.01": [69, true], "aps.12.02": [80, true], "aps.12.03": [82, true], "aps.12.04": [82, true], "aps.12.05": [82, true], "aps.12.06": [77, true], "aps.12.07": [83, true], "aps.12.08": [81, true], "aps.12.09": [84, true], "aps.12.10": [83, true], "aps.12.11": [82, true], "aps.12.12": [83, true], "aps.12.13": [80, true], "aps.12.14": [65, true], "aps.12.15": [79, true], "aps.12.16": [78, true], "aps.12.17": [81, true], "aps.12.18": [75, true], "aps.13.00": [8, false], "aps.14.00": [83, true], "aps.14.01": [83, true], "aps.14.02": [83, true], "aps.14.03": [83, true], "aps.14.04": [83, true], "aps.14.05": [83, true], "aps.14.06": [83, true], "aps.14.07": [83, true], "aps.14.08": [83, true], "aps.14.09": [83, true], "aps.14.10": [83, true], "aps.14.11": [83, true], "aps.14.12": [83, true], "aps.14.13": [83, true], "aps.14.14": [83, true], "aps.14.15": [83, true], "aps.14.16": [83, true], "aps.14.17": [83, true], "aps.14.18": [83, true], "aps.14.19": [83, true], "aps.14.20": [83, true], "aps.14.21": [83, true], "aps.14.22": [83, true], "aps.14.23": [83, true], "aps.14.24": [83, true], "aps.14.25": [83, true], "aps.14.26": [83, true], "aps.14.27": [83, true], "aps.14.28": [83, true], "aps.14.29": [83, true], "aps.14.30": [83, true], "aps.14.31": [83, true], "aps.14.32": [83, true], "aps.14.33": [83, true], "aps.14.34": [83, true], "aps.14.35": [83, true], "aps.14.36": [83, true], "aps.14.37": [83, true], "aps.14.38": [83, true], "aps.14.39": [83, true], "aps.15.00": [65, true], "aps.15.01": [70, true], "aps.15.02": [72, true], "aps.15.03": [67, true], "aps.15.04": [71, true], "aps.15.05": [68, true], "aps.15.06": [72, true], "aps.15.07": [62, true], "aps.15.08": [66, true], "aps.15.09": [69, true], "aps.15.10": [69, true], "aps.15.11": [64, true], "aps.15.12": [71, true], "aps.15.13": [69, true], "aps.15.14": [70, true], "aps.15.15": [67, true], "aps.15.16": [71, true], "aps.15.17": [69, true], "aps.15.18": [71, true], "aps.15.19": [68, true], "aps.15.20": [68, true], "aps.15.21": [71, true], "aps.15.22": [68, true], "aps.15.23": [60, true], "aps.15.24": [64, true], "aps.15.25": [68, true], "aps.15.26": [59, true], "aps.15.27": [63, true], "aps.15.28": [66, true], "aps.15.29": [66, true], "aps.15.30": [55, true]}}, "CHA": {"total": 4044, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [70, true], "fun1.2": [64, true], "fun1.3": [77, true], "fun1.4": [98, true], "fun1.5": [123, true], "fun2.1": [71, true], "fun2.2": [84, true], "fun2.3": [113, true], "fun2.4": [121, true], "fun2.5": [138, true], "fun3.1": [67, true], "fun3.2": [71, true], "fun3.3": [67, true], "fun3.4": [64, true], "fun3.5": [56, true], "fun4.1": [64, true], "fun4.2": [66, true], "fun4.3": [80, true], "fun4.4": [89, true], "fun4.5": [107, true], "fun5.1": [62, true], "fun5.2": [61, true], "fun5.3": [63, true], "fun5.4": [65, true], "fun5.5": [66, true], "fun6.1": [53, true], "fun6.2": [54, true], "fun6.3": [54, true], "fun6.4": [56, true], "fun6.5": [57, true], "fun7.1": [8, false], "fun7.2": [5, false], "fun7.3": [9, false], "fun7.4": [13, false], "fun7.5": [12, false], "fun8.1": [72, true], "fun8.2": [74, true], "fun8.3": [78, true], "fun8.4": [79, true], "fun8.5": [75, true], "fun9.1": [72, true], "fun9.2": [73, true], "fun9.3": [78, true], "fun9.4": [80, true], "fun9.5": [82, true]}}}, {"label": "pure.cbrt.start.project", "spec": ["pure", "cbrt", "start", "project"], "APS": {"total": 14252, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [89, true], "aps.04.10": [89, true], "aps.04.11": [88, true], "aps.04.12": [89, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [83, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [82, true], "aps.06.08": [83, true], "aps.06.09": [82, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [3, true], "aps.08.01": [82, true], "aps.08.02": [82, true], "aps.08.03": [82, true], "aps.08.04": [83, true], "aps.09.00": [83, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [83, true], "aps.10.00": [83, true], "aps.10.01": [83, true], "aps.10.02": [83, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [82, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [97, true], "aps.12.01": [96, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [97, true], "aps.12.12": [96, true], "aps.12.13": [97, true], "aps.12.14": [97, true], "aps.12.15": [93, true], "aps.12.16": [96, true], "aps.12.17": [97, true], "aps.12.18": [97, true], "aps.13.00": [52, false], "aps.14.00": [103, true], "aps.14.01": [103, true], "aps.14.02": [103, true], "aps.14.03": [103, true], "aps.14.04": [103, true], "aps.14.05": [103, true], "aps.14.06": [103, true], "aps.14.07": [103, true], "aps.14.08": [103, true], "aps.14.09": [103, true], "aps.14.10": [103, true], "aps.14.11": [103, true], "aps.14.12": [103, true], "aps.14.13": [103, true], "aps.14.14": [103, true], "aps.14.15": [103, true], "aps.14.16": [103, true], "aps.14.17": [103, true], "aps.14.18": [103, true], "aps.14.19": [103, true], "aps.14.20": [103, true], "aps.14.21": [103, true], "aps.14.22": [103, true], "aps.14.23": [103, true], "aps.14.24": [103, true], "aps.14.25": [103, true], "aps.14.26": [103, true], "aps.14.27": [103, true], "aps.14.28": [103, true], "aps.14.29": [103, true], "aps.14.30": [103, true], "aps.14.31": [103, true], "aps.14.32": [103, true], "aps.14.33": [103, true], "aps.14.34": [103, true], "aps.14.35": [103, true], "aps.14.36": [103, true], "aps.14.37": [103, true], "aps.14.38": [103, true], "aps.14.39": [103, true], "aps.15.00": [84, true], "aps.15.01": [103, true], "aps.15.02": [102, true], "aps.15.03": [103, true], "aps.15.04": [102, true], "aps.15.05": [102, true], "aps.15.06": [102, true], "aps.15.07": [103, true], "aps.15.08": [103, true], "aps.15.09": [102, true], "aps.15.10": [100, true], "aps.15.11": [102, true], "aps.15.12": [103, true], "aps.15.13": [72, true], "aps.15.14": [103, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [103, true], "aps.15.18": [92, true], "aps.15.19": [103, true], "aps.15.20": [94, true], "aps.15.21": [102, true], "aps.15.22": [103, true], "aps.15.23": [72, true], "aps.15.24": [87, true], "aps.15.25": [54, true], "aps.15.26": [102, true], "aps.15.27": [83, true], "aps.15.28": [103, true], "aps.15.29": [76, true], "aps.15.30": [57, true]}}, "CHA": {"total": 5119, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [150, true], "fun2.5": [162, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [152, true], "fun4.1": [89, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [89, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [52, false], "fun7.2": [52, false], "fun7.3": [54, false], "fun7.4": [58, false], "fun7.5": [60, false], "fun8.1": [84, true], "fun8.2": [87, true], "fun8.3": [90, true], "fun8.4": [93, true], "fun8.5": [97, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [93, true], "fun9.5": [96, true]}}}, {"label": "pure.cbrt.start.safe", "spec": ["pure", "cbrt", "start", "safe"], "APS": {"total": 11950, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [83, true], "aps.02.00": [70, true], "aps.02.01": [69, true], "aps.02.02": [71, true], "aps.02.03": [68, true], "aps.02.04": [70, true], "aps.02.05": [66, true], "aps.02.06": [68, true], "aps.02.07": [68, true], "aps.02.08": [67, true], "aps.02.09": [67, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [74, true], "aps.04.03": [78, true], "aps.04.04": [77, true], "aps.04.05": [78, true], "aps.04.06": [68, true], "aps.04.07": [87, true], "aps.04.08": [84, true], "aps.04.09": [83, true], "aps.04.10": [81, true], "aps.04.11": [70, true], "aps.04.12": [81, true], "aps.04.13": [70, true], "aps.05.00": [84, true], "aps.06.00": [76, true], "aps.06.01": [83, true], "aps.06.02": [70, true], "aps.06.03": [70, true], "aps.06.04": [74, true], "aps.06.05": [79, true], "aps.06.06": [78, true], "aps.06.07": [73, true], "aps.06.08": [79, true], "aps.06.09": [76, true], "aps.07.00": [80, true], "aps.07.01": [46, true], "aps.07.02": [69, true], "aps.08.00": [3, true], "aps.08.01": [72, true], "aps.08.02": [79, true], "aps.08.03": [80, true], "aps.08.04": [83, true], "aps.09.00": [81, true], "aps.09.01": [81, true], "aps.09.02": [76, true], "aps.09.03": [63, true], "aps.09.04": [71, true], "aps.09.05": [62, true], "aps.09.06": [59, true], "aps.10.00": [79, true], "aps.10.01": [76, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [72, true], "aps.11.01": [59, true], "aps.11.02": [83, true], "aps.11.03": [70, true], "aps.12.00": [81, true], "aps.12.01": [88, true], "aps.12.02": [88, true], "aps.12.03": [87, true], "aps.12.04": [83, true], "aps.12.05": [91, true], "aps.12.06": [89, true], "aps.12.07": [93, true], "aps.12.08": [93, true], "aps.12.09": [97, true], "aps.12.10": [79, true], "aps.12.11": [83, true], "aps.12.12": [96, true], "aps.12.13": [74, true], "aps.12.14": [93, true], "aps.12.15": [96, true], "aps.12.16": [94, true], "aps.12.17": [79, true], "aps.12.18": [89, true], "aps.13.00": [10, false], "aps.14.00": [84, true], "aps.14.01": [84, true], "aps.14.02": [84, true], "aps.14.03": [84, true], "aps.14.04": [84, true], "aps.14.05": [84, true], "aps.14.06": [84, true], "aps.14.07": [84, true], "aps.14.08": [84, true], "aps.14.09": [84, true], "aps.14.10": [84, true], "aps.14.11": [84, true], "aps.14.12": [84, true], "aps.14.13": [84, true], "aps.14.14": [84, true], "aps.14.15": [84, true], "aps.14.16": [84, true], "aps.14.17": [84, true], "aps.14.18": [84, true], "aps.14.19": [84, true], "aps.14.20": [84, true], "aps.14.21": [84, true], "aps.14.22": [84, true], "aps.14.23": [84, true], "aps.14.24": [84, true], "aps.14.25": [84, true], "aps.14.26": [84, true], "aps.14.27": [84, true], "aps.14.28": [84, true], "aps.14.29": [84, true], "aps.14.30": [84, true], "aps.14.31": [84, true], "aps.14.32": [84, true], "aps.14.33": [84, true], "aps.14.34": [84, true], "aps.14.35": [84, true], "aps.14.36": [84, true], "aps.14.37": [84, true], "aps.14.38": [84, true], "aps.14.39": [84, true], "aps.15.00": [74, true], "aps.15.01": [72, true], "aps.15.02": [80, true], "aps.15.03": [72, true], "aps.15.04": [68, true], "aps.15.05": [60, true], "aps.15.06": [79, true], "aps.15.07": [70, true], "aps.15.08": [66, true], "aps.15.09": [67, true], "aps.15.10": [73, true], "aps.15.11": [72, true], "aps.15.12": [72, true], "aps.15.13": [72, true], "aps.15.14": [77, true], "aps.15.15": [72, true], "aps.15.16": [72, true], "aps.15.17": [72, true], "aps.15.18": [72, true], "aps.15.19": [77, true], "aps.15.20": [64, true], "aps.15.21": [71, true], "aps.15.22": [68, true], "aps.15.23": [59, true], "aps.15.24": [67, true], "aps.15.25": [70, true], "aps.15.26": [67, true], "aps.15.27": [71, true], "aps.15.28": [65, true], "aps.15.29": [66, true], "aps.15.30": [59, true]}}, "CHA": {"total": 4413, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [80, true], "fun1.2": [84, true], "fun1.3": [88, true], "fun1.4": [94, true], "fun1.5": [72, true], "fun2.1": [73, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [133, true], "fun2.5": [149, true], "fun3.1": [80, true], "fun3.2": [93, true], "fun3.3": [82, true], "fun3.4": [80, true], "fun3.5": [65, true], "fun4.1": [76, true], "fun4.2": [81, true], "fun4.3": [93, true], "fun4.4": [111, true], "fun4.5": [136, true], "fun5.1": [70, true], "fun5.2": [71, true], "fun5.3": [73, true], "fun5.4": [75, true], "fun5.5": [76, true], "fun6.1": [53, true], "fun6.2": [58, true], "fun6.3": [60, true], "fun6.4": [62, true], "fun6.5": [63, true], "fun7.1": [10, false], "fun7.2": [5, false], "fun7.3": [12, false], "fun7.4": [14, false], "fun7.5": [21, false], "fun8.1": [68, true], "fun8.2": [75, true], "fun8.3": [91, true], "fun8.4": [88, true], "fun8.5": [87, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [90, true], "fun9.5": [93, true]}}}, {"label": "toms748", "spec": ["base", "toms748"], "APS": {"total": 2820, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [10, true], "aps.02.00": [19, true], "aps.02.01": [15, true], "aps.02.02": [19, true], "aps.02.03": [13, true], "aps.02.04": [15, true], "aps.02.05": [11, true], "aps.02.06": [14, true], "aps.02.07": [13, true], "aps.02.08": [11, true], "aps.02.09": [11, true], "aps.03.00": [14, true], "aps.03.01": [14, true], "aps.03.02": [14, true], "aps.04.00": [18, true], "aps.04.01": [18, true], "aps.04.02": [20, true], "aps.04.03": [15, true], "aps.04.04": [19, true], "aps.04.05": [12, true], "aps.04.06": [12, true], "aps.04.07": [15, true], "aps.04.08": [14, true], "aps.04.09": [18, true], "aps.04.10": [19, true], "aps.04.11": [21, true], "aps.04.12": [22, true], "aps.04.13": [24, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [10, true], "aps.06.04": [11, true], "aps.06.05": [12, true], "aps.06.06": [13, true], "aps.06.07": [13, true], "aps.06.08": [15, true], "aps.06.09": [14, true], "aps.07.00": [9, true], "aps.07.01": [7, true], "aps.07.02": [7, true], "aps.08.00": [3, true], "aps.08.01": [11, true], "aps.08.02": [12, true], "aps.08.03": [14, true], "aps.08.04": [13, true], "aps.09.00": [13, true], "aps.09.01": [11, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [9, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [11, true], "aps.10.01": [12, true], "aps.10.02": [15, true], "aps.10.03": [17, true], "aps.10.04": [17, true], "aps.11.00": [13, true], "aps.11.01": [16, true], "aps.11.02": [18, true], "aps.11.03": [18, true], "aps.12.00": [6, true], "aps.12.01": [6, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [11, true], "aps.13.00": [16, false], "aps.14.00": [16, true], "aps.14.01": [16, true], "aps.14.02": [17, true], "aps.14.03": [16, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [16, true], "aps.14.07": [16, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [16, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [16, true], "aps.14.14": [17, true], "aps.14.15": [16, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [16, true], "aps.14.22": [16, true], "aps.14.23": [17, true], "aps.14.24": [16, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [16, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [16, true], "aps.14.32": [16, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [16, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [29, true], "aps.15.01": [29, true], "aps.15.02": [29, true], "aps.15.03": [29, true], "aps.15.04": [29, true], "aps.15.05": [29, true], "aps.15.06": [29, true], "aps.15.07": [29, true], "aps.15.08": [28, true], "aps.15.09": [29, true], "aps.15.10": [29, true], "aps.15.11": [27, true], "aps.15.12": [27, true], "aps.15.13": [27, true], "aps.15.14": [28, true], "aps.15.15": [27, true], "aps.15.16": [29, true], "aps.15.17": [28, true], "aps.15.18": [28, true], "aps.15.19": [29, true], "aps.15.20": [29, true], "aps.15.21": [31, true], "aps.15.22": [31, true], "aps.15.23": [33, true], "aps.15.24": [33, true], "aps.15.25": [33, true], "aps.15.26": [33, true], "aps.15.27": [31, true], "aps.15.28": [31, true], "aps.15.29": [33, true], "aps.15.30": [33, true]}}, "CHA": {"total": 4000, "solved": 40, "n": 45, "over": 15, "per": {"fun1.1": [11, true], "fun1.2": [15, true], "fun1.3": [19, true], "fun1.4": [39, true], "fun1.5": [81, true], "fun2.1": [11, true], "fun2.2": [48, true], "fun2.3": [66, true], "fun2.4": [95, true], "fun2.5": [113, true], "fun3.1": [91, true], "fun3.2": [97, true], "fun3.3": [131, true], "fun3.4": [157, true], "fun3.5": [174, true], "fun4.1": [95, true], "fun4.2": [89, true], "fun4.3": [141, true], "fun4.4": [116, true], "fun4.5": [129, true], "fun5.1": [95, true], "fun5.2": [108, true], "fun5.3": [117, true], "fun5.4": [129, true], "fun5.5": [132, true], "fun6.1": [70, true], "fun6.2": [112, true], "fun6.3": [110, true], "fun6.4": [138, true], "fun6.5": [95, true], "fun7.1": [18, false], "fun7.2": [19, false], "fun7.3": [22, false], "fun7.4": [19, false], "fun7.5": [10, false], "fun8.1": [14, true], "fun8.2": [14, true], "fun8.3": [20, true], "fun8.4": [21, true], "fun8.5": [28, true], "fun9.1": [9, true], "fun9.2": [11, true], "fun9.3": [20, true], "fun9.4": [16, true], "fun9.5": [23, true]}}}, {"label": "pure.cbrt.start.none", "spec": ["pure", "cbrt", "start", "none"], "APS": {"total": 28188, "solved": 29, "n": 154, "over": 13, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [200, false], "aps.04.01": [106, true], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [162, true], "aps.04.08": [200, false], "aps.04.09": [193, true], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [126, true], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [3, true], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [76, true], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [84, true], "aps.15.01": [200, false], "aps.15.02": [195, true], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [182, true], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [141, true], "aps.15.11": [97, true], "aps.15.12": [200, false], "aps.15.13": [72, true], "aps.15.14": [169, true], "aps.15.15": [185, true], "aps.15.16": [200, false], "aps.15.17": [189, true], "aps.15.18": [92, true], "aps.15.19": [130, true], "aps.15.20": [94, true], "aps.15.21": [193, true], "aps.15.22": [200, false], "aps.15.23": [72, true], "aps.15.24": [87, true], "aps.15.25": [54, true], "aps.15.26": [200, false], "aps.15.27": [83, true], "aps.15.28": [125, true], "aps.15.29": [76, true], "aps.15.30": [57, true]}}, "CHA": {"total": 8867, "solved": 1, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [67, true], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.cbrt.start.credit", "spec": ["pure", "cbrt", "start", "credit"], "APS": {"total": 7678, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [48, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3128, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [44, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [10, false], "fun7.4": [12, false], "fun7.5": [14, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "itp_oracle", "spec": ["base", "itp_oracle"], "APS": {"total": 3260, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [10, true], "aps.02.00": [11, true], "aps.02.01": [10, true], "aps.02.02": [10, true], "aps.02.03": [12, true], "aps.02.04": [11, true], "aps.02.05": [11, true], "aps.02.06": [11, true], "aps.02.07": [11, true], "aps.02.08": [10, true], "aps.02.09": [12, true], "aps.03.00": [48, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [16, true], "aps.04.01": [21, true], "aps.04.02": [20, true], "aps.04.03": [19, true], "aps.04.04": [27, true], "aps.04.05": [10, true], "aps.04.06": [9, true], "aps.04.07": [8, true], "aps.04.08": [8, true], "aps.04.09": [7, true], "aps.04.10": [16, true], "aps.04.11": [16, true], "aps.04.12": [15, true], "aps.04.13": [17, true], "aps.05.00": [9, true], "aps.06.00": [9, true], "aps.06.01": [10, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [17, true], "aps.06.08": [15, true], "aps.06.09": [18, true], "aps.07.00": [10, true], "aps.07.01": [9, true], "aps.07.02": [9, true], "aps.08.00": [3, true], "aps.08.01": [11, true], "aps.08.02": [12, true], "aps.08.03": [43, true], "aps.08.04": [16, true], "aps.09.00": [10, true], "aps.09.01": [11, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [8, true], "aps.09.05": [8, true], "aps.09.06": [6, true], "aps.10.00": [10, true], "aps.10.01": [9, true], "aps.10.02": [11, true], "aps.10.03": [11, true], "aps.10.04": [12, true], "aps.11.00": [13, true], "aps.11.01": [32, true], "aps.11.02": [43, true], "aps.11.03": [35, true], "aps.12.00": [10, true], "aps.12.01": [13, true], "aps.12.02": [14, true], "aps.12.03": [14, true], "aps.12.04": [14, true], "aps.12.05": [14, true], "aps.12.06": [15, true], "aps.12.07": [13, true], "aps.12.08": [14, true], "aps.12.09": [14, true], "aps.12.10": [14, true], "aps.12.11": [12, true], "aps.12.12": [13, true], "aps.12.13": [12, true], "aps.12.14": [12, true], "aps.12.15": [12, true], "aps.12.16": [12, true], "aps.12.17": [12, true], "aps.12.18": [12, true], "aps.13.00": [8, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [36, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [33, true], "aps.15.04": [33, true], "aps.15.05": [33, true], "aps.15.06": [33, true], "aps.15.07": [33, true], "aps.15.08": [33, true], "aps.15.09": [32, true], "aps.15.10": [31, true], "aps.15.11": [32, true], "aps.15.12": [33, true], "aps.15.13": [34, true], "aps.15.14": [34, true], "aps.15.15": [34, true], "aps.15.16": [38, true], "aps.15.17": [37, true], "aps.15.18": [33, true], "aps.15.19": [37, true], "aps.15.20": [37, true], "aps.15.21": [38, true], "aps.15.22": [36, true], "aps.15.23": [37, true], "aps.15.24": [37, true], "aps.15.25": [39, true], "aps.15.26": [41, true], "aps.15.27": [42, true], "aps.15.28": [38, true], "aps.15.29": [39, true], "aps.15.30": [39, true]}}, "CHA": {"total": 2611, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [9, true], "fun1.2": [12, true], "fun1.3": [14, true], "fun1.4": [31, true], "fun1.5": [55, true], "fun2.1": [11, true], "fun2.2": [57, true], "fun2.3": [62, true], "fun2.4": [76, true], "fun2.5": [82, true], "fun3.1": [34, true], "fun3.2": [36, true], "fun3.3": [58, true], "fun3.4": [63, true], "fun3.5": [77, true], "fun4.1": [33, true], "fun4.2": [33, true], "fun4.3": [57, true], "fun4.4": [63, true], "fun4.5": [63, true], "fun5.1": [45, true], "fun5.2": [45, true], "fun5.3": [46, true], "fun5.4": [48, true], "fun5.5": [49, true], "fun6.1": [7, true], "fun6.2": [45, true], "fun6.3": [46, true], "fun6.4": [48, true], "fun6.5": [50, true], "fun7.1": [8, false], "fun7.2": [5, false], "fun7.3": [5, false], "fun7.4": [4, false], "fun7.5": [6, false], "fun8.1": [13, true], "fun8.2": [44, true], "fun8.3": [46, true], "fun8.4": [47, true], "fun8.5": [49, true], "fun9.1": [9, true], "fun9.2": [10, true], "fun9.3": [14, true], "fun9.4": [12, true], "fun9.5": [12, true]}}}, {"label": "pure.cbrt.start.step", "spec": ["pure", "cbrt", "start", "step"], "APS": {"total": 12017, "solved": 153, "n": 154, "over": 8, "per": {"aps.01.00": [87, true], "aps.02.00": [70, true], "aps.02.01": [69, true], "aps.02.02": [71, true], "aps.02.03": [70, true], "aps.02.04": [70, true], "aps.02.05": [66, true], "aps.02.06": [68, true], "aps.02.07": [68, true], "aps.02.08": [67, true], "aps.02.09": [69, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [89, true], "aps.04.01": [90, true], "aps.04.02": [74, true], "aps.04.03": [78, true], "aps.04.04": [77, true], "aps.04.05": [78, true], "aps.04.06": [68, true], "aps.04.07": [87, true], "aps.04.08": [84, true], "aps.04.09": [83, true], "aps.04.10": [81, true], "aps.04.11": [70, true], "aps.04.12": [81, true], "aps.04.13": [70, true], "aps.05.00": [84, true], "aps.06.00": [76, true], "aps.06.01": [87, true], "aps.06.02": [70, true], "aps.06.03": [70, true], "aps.06.04": [74, true], "aps.06.05": [79, true], "aps.06.06": [78, true], "aps.06.07": [73, true], "aps.06.08": [79, true], "aps.06.09": [76, true], "aps.07.00": [80, true], "aps.07.01": [46, true], "aps.07.02": [69, true], "aps.08.00": [3, true], "aps.08.01": [72, true], "aps.08.02": [79, true], "aps.08.03": [80, true], "aps.08.04": [83, true], "aps.09.00": [84, true], "aps.09.01": [84, true], "aps.09.02": [76, true], "aps.09.03": [63, true], "aps.09.04": [71, true], "aps.09.05": [62, true], "aps.09.06": [59, true], "aps.10.00": [79, true], "aps.10.01": [76, true], "aps.10.02": [93, true], "aps.10.03": [89, true], "aps.10.04": [98, true], "aps.11.00": [72, true], "aps.11.01": [59, true], "aps.11.02": [85, true], "aps.11.03": [70, true], "aps.12.00": [81, true], "aps.12.01": [88, true], "aps.12.02": [90, true], "aps.12.03": [87, true], "aps.12.04": [83, true], "aps.12.05": [91, true], "aps.12.06": [89, true], "aps.12.07": [95, true], "aps.12.08": [93, true], "aps.12.09": [97, true], "aps.12.10": [79, true], "aps.12.11": [83, true], "aps.12.12": [100, true], "aps.12.13": [72, true], "aps.12.14": [93, true], "aps.12.15": [100, true], "aps.12.16": [92, true], "aps.12.17": [81, true], "aps.12.18": [89, true], "aps.13.00": [10, false], "aps.14.00": [84, true], "aps.14.01": [84, true], "aps.14.02": [84, true], "aps.14.03": [84, true], "aps.14.04": [84, true], "aps.14.05": [84, true], "aps.14.06": [84, true], "aps.14.07": [84, true], "aps.14.08": [84, true], "aps.14.09": [84, true], "aps.14.10": [84, true], "aps.14.11": [84, true], "aps.14.12": [84, true], "aps.14.13": [84, true], "aps.14.14": [84, true], "aps.14.15": [84, true], "aps.14.16": [84, true], "aps.14.17": [84, true], "aps.14.18": [84, true], "aps.14.19": [84, true], "aps.14.20": [84, true], "aps.14.21": [84, true], "aps.14.22": [84, true], "aps.14.23": [84, true], "aps.14.24": [84, true], "aps.14.25": [84, true], "aps.14.26": [84, true], "aps.14.27": [84, true], "aps.14.28": [84, true], "aps.14.29": [84, true], "aps.14.30": [84, true], "aps.14.31": [84, true], "aps.14.32": [84, true], "aps.14.33": [84, true], "aps.14.34": [84, true], "aps.14.35": [84, true], "aps.14.36": [84, true], "aps.14.37": [84, true], "aps.14.38": [84, true], "aps.14.39": [84, true], "aps.15.00": [74, true], "aps.15.01": [72, true], "aps.15.02": [80, true], "aps.15.03": [72, true], "aps.15.04": [68, true], "aps.15.05": [60, true], "aps.15.06": [79, true], "aps.15.07": [70, true], "aps.15.08": [66, true], "aps.15.09": [67, true], "aps.15.10": [73, true], "aps.15.11": [72, true], "aps.15.12": [72, true], "aps.15.13": [72, true], "aps.15.14": [77, true], "aps.15.15": [72, true], "aps.15.16": [72, true], "aps.15.17": [72, true], "aps.15.18": [72, true], "aps.15.19": [77, true], "aps.15.20": [64, true], "aps.15.21": [71, true], "aps.15.22": [68, true], "aps.15.23": [59, true], "aps.15.24": [67, true], "aps.15.25": [70, true], "aps.15.26": [67, true], "aps.15.27": [71, true], "aps.15.28": [65, true], "aps.15.29": [66, true], "aps.15.30": [59, true]}}, "CHA": {"total": 4419, "solved": 40, "n": 45, "over": 5, "per": {"fun1.1": [80, true], "fun1.2": [84, true], "fun1.3": [90, true], "fun1.4": [94, true], "fun1.5": [72, true], "fun2.1": [73, true], "fun2.2": [111, true], "fun2.3": [129, true], "fun2.4": [133, true], "fun2.5": [151, true], "fun3.1": [80, true], "fun3.2": [67, true], "fun3.3": [80, true], "fun3.4": [80, true], "fun3.5": [65, true], "fun4.1": [76, true], "fun4.2": [81, true], "fun4.3": [93, true], "fun4.4": [111, true], "fun4.5": [136, true], "fun5.1": [70, true], "fun5.2": [71, true], "fun5.3": [73, true], "fun5.4": [75, true], "fun5.5": [76, true], "fun6.1": [53, true], "fun6.2": [58, true], "fun6.3": [60, true], "fun6.4": [62, true], "fun6.5": [63, true], "fun7.1": [10, false], "fun7.2": [5, false], "fun7.3": [12, false], "fun7.4": [14, false], "fun7.5": [21, false], "fun8.1": [68, true], "fun8.2": [75, true], "fun8.3": [95, true], "fun8.4": [88, true], "fun8.5": [87, true], "fun9.1": [93, true], "fun9.2": [89, true], "fun9.3": [94, true], "fun9.4": [90, true], "fun9.5": [93, true]}}}, {"label": "pure.cbrt.bracket.step", "spec": ["pure", "cbrt", "bracket", "step"], "APS": {"total": 8051, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [46, true], "aps.02.00": [48, true], "aps.02.01": [50, true], "aps.02.02": [47, true], "aps.02.03": [52, true], "aps.02.04": [51, true], "aps.02.05": [57, true], "aps.02.06": [55, true], "aps.02.07": [49, true], "aps.02.08": [55, true], "aps.02.09": [53, true], "aps.03.00": [58, true], "aps.03.01": [60, true], "aps.03.02": [54, true], "aps.04.00": [44, true], "aps.04.01": [52, true], "aps.04.02": [51, true], "aps.04.03": [54, true], "aps.04.04": [47, true], "aps.04.05": [51, true], "aps.04.06": [50, true], "aps.04.07": [49, true], "aps.04.08": [50, true], "aps.04.09": [50, true], "aps.04.10": [46, true], "aps.04.11": [52, true], "aps.04.12": [47, true], "aps.04.13": [54, true], "aps.05.00": [47, true], "aps.06.00": [45, true], "aps.06.01": [45, true], "aps.06.02": [50, true], "aps.06.03": [49, true], "aps.06.04": [48, true], "aps.06.05": [49, true], "aps.06.06": [50, true], "aps.06.07": [51, true], "aps.06.08": [51, true], "aps.06.09": [52, true], "aps.07.00": [48, true], "aps.07.01": [45, true], "aps.07.02": [44, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [43, true], "aps.08.03": [47, true], "aps.08.04": [41, true], "aps.09.00": [46, true], "aps.09.01": [46, true], "aps.09.02": [43, true], "aps.09.03": [47, true], "aps.09.04": [45, true], "aps.09.05": [46, true], "aps.09.06": [45, true], "aps.10.00": [47, true], "aps.10.01": [45, true], "aps.10.02": [41, true], "aps.10.03": [40, true], "aps.10.04": [46, true], "aps.11.00": [46, true], "aps.11.01": [48, true], "aps.11.02": [45, true], "aps.11.03": [42, true], "aps.12.00": [54, true], "aps.12.01": [47, true], "aps.12.02": [60, true], "aps.12.03": [58, true], "aps.12.04": [53, true], "aps.12.05": [59, true], "aps.12.06": [54, true], "aps.12.07": [60, true], "aps.12.08": [53, true], "aps.12.09": [52, true], "aps.12.10": [48, true], "aps.12.11": [53, true], "aps.12.12": [53, true], "aps.12.13": [54, true], "aps.12.14": [58, true], "aps.12.15": [55, true], "aps.12.16": [55, true], "aps.12.17": [58, true], "aps.12.18": [57, true], "aps.13.00": [12, false], "aps.14.00": [54, true], "aps.14.01": [54, true], "aps.14.02": [54, true], "aps.14.03": [54, true], "aps.14.04": [54, true], "aps.14.05": [54, true], "aps.14.06": [54, true], "aps.14.07": [54, true], "aps.14.08": [54, true], "aps.14.09": [54, true], "aps.14.10": [54, true], "aps.14.11": [54, true], "aps.14.12": [54, true], "aps.14.13": [54, true], "aps.14.14": [54, true], "aps.14.15": [54, true], "aps.14.16": [54, true], "aps.14.17": [54, true], "aps.14.18": [54, true], "aps.14.19": [54, true], "aps.14.20": [54, true], "aps.14.21": [54, true], "aps.14.22": [54, true], "aps.14.23": [54, true], "aps.14.24": [54, true], "aps.14.25": [54, true], "aps.14.26": [54, true], "aps.14.27": [54, true], "aps.14.28": [54, true], "aps.14.29": [54, true], "aps.14.30": [54, true], "aps.14.31": [54, true], "aps.14.32": [54, true], "aps.14.33": [54, true], "aps.14.34": [54, true], "aps.14.35": [54, true], "aps.14.36": [54, true], "aps.14.37": [54, true], "aps.14.38": [54, true], "aps.14.39": [54, true], "aps.15.00": [47, true], "aps.15.01": [45, true], "aps.15.02": [52, true], "aps.15.03": [52, true], "aps.15.04": [54, true], "aps.15.05": [55, true], "aps.15.06": [55, true], "aps.15.07": [55, true], "aps.15.08": [52, true], "aps.15.09": [56, true], "aps.15.10": [54, true], "aps.15.11": [52, true], "aps.15.12": [52, true], "aps.15.13": [53, true], "aps.15.14": [50, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [50, true], "aps.15.18": [55, true], "aps.15.19": [52, true], "aps.15.20": [51, true], "aps.15.21": [50, true], "aps.15.22": [56, true], "aps.15.23": [55, true], "aps.15.24": [58, true], "aps.15.25": [54, true], "aps.15.26": [56, true], "aps.15.27": [55, true], "aps.15.28": [55, true], "aps.15.29": [53, true], "aps.15.30": [54, true]}}, "CHA": {"total": 3890, "solved": 40, "n": 45, "over": 6, "per": {"fun1.1": [38, true], "fun1.2": [49, true], "fun1.3": [47, true], "fun1.4": [51, true], "fun1.5": [49, true], "fun2.1": [43, true], "fun2.2": [92, true], "fun2.3": [108, true], "fun2.4": [150, true], "fun2.5": [168, true], "fun3.1": [24, true], "fun3.2": [39, true], "fun3.3": [8, true], "fun3.4": [6, true], "fun3.5": [6, true], "fun4.1": [87, true], "fun4.2": [94, true], "fun4.3": [107, true], "fun4.4": [120, true], "fun4.5": [135, true], "fun5.1": [110, true], "fun5.2": [101, true], "fun5.3": [98, true], "fun5.4": [117, true], "fun5.5": [122, true], "fun6.1": [71, true], "fun6.2": [72, true], "fun6.3": [79, true], "fun6.4": [79, true], "fun6.5": [81, true], "fun7.1": [12, false], "fun7.2": [5, false], "fun7.3": [11, false], "fun7.4": [30, false], "fun7.5": [14, false], "fun8.1": [50, true], "fun8.2": [49, true], "fun8.3": [58, true], "fun8.4": [64, true], "fun8.5": [67, true], "fun9.1": [43, true], "fun9.2": [48, true], "fun9.3": [48, true], "fun9.4": [52, true], "fun9.5": [60, true]}}}, {"label": "pure.cbrt.bracket.bracket", "spec": ["pure", "cbrt", "bracket", "bracket"], "APS": {"total": 8041, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [52, true], "aps.02.01": [52, true], "aps.02.02": [49, true], "aps.02.03": [53, true], "aps.02.04": [49, true], "aps.02.05": [47, true], "aps.02.06": [49, true], "aps.02.07": [50, true], "aps.02.08": [46, true], "aps.02.09": [47, true], "aps.03.00": [57, true], "aps.03.01": [60, true], "aps.03.02": [54, true], "aps.04.00": [51, true], "aps.04.01": [49, true], "aps.04.02": [50, true], "aps.04.03": [51, true], "aps.04.04": [56, true], "aps.04.05": [47, true], "aps.04.06": [51, true], "aps.04.07": [45, true], "aps.04.08": [51, true], "aps.04.09": [48, true], "aps.04.10": [47, true], "aps.04.11": [49, true], "aps.04.12": [49, true], "aps.04.13": [52, true], "aps.05.00": [51, true], "aps.06.00": [45, true], "aps.06.01": [44, true], "aps.06.02": [47, true], "aps.06.03": [43, true], "aps.06.04": [48, true], "aps.06.05": [49, true], "aps.06.06": [52, true], "aps.06.07": [50, true], "aps.06.08": [52, true], "aps.06.09": [53, true], "aps.07.00": [49, true], "aps.07.01": [47, true], "aps.07.02": [49, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [44, true], "aps.08.03": [42, true], "aps.08.04": [42, true], "aps.09.00": [47, true], "aps.09.01": [46, true], "aps.09.02": [47, true], "aps.09.03": [45, true], "aps.09.04": [43, true], "aps.09.05": [46, true], "aps.09.06": [45, true], "aps.10.00": [47, true], "aps.10.01": [42, true], "aps.10.02": [41, true], "aps.10.03": [47, true], "aps.10.04": [45, true], "aps.11.00": [44, true], "aps.11.01": [45, true], "aps.11.02": [47, true], "aps.11.03": [46, true], "aps.12.00": [53, true], "aps.12.01": [50, true], "aps.12.02": [56, true], "aps.12.03": [54, true], "aps.12.04": [52, true], "aps.12.05": [55, true], "aps.12.06": [56, true], "aps.12.07": [51, true], "aps.12.08": [59, true], "aps.12.09": [57, true], "aps.12.10": [52, true], "aps.12.11": [55, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [56, true], "aps.12.15": [53, true], "aps.12.16": [56, true], "aps.12.17": [53, true], "aps.12.18": [52, true], "aps.13.00": [10, false], "aps.14.00": [55, true], "aps.14.01": [55, true], "aps.14.02": [55, true], "aps.14.03": [55, true], "aps.14.04": [55, true], "aps.14.05": [55, true], "aps.14.06": [55, true], "aps.14.07": [55, true], "aps.14.08": [55, true], "aps.14.09": [55, true], "aps.14.10": [55, true], "aps.14.11": [55, true], "aps.14.12": [55, true], "aps.14.13": [55, true], "aps.14.14": [55, true], "aps.14.15": [55, true], "aps.14.16": [55, true], "aps.14.17": [55, true], "aps.14.18": [55, true], "aps.14.19": [55, true], "aps.14.20": [55, true], "aps.14.21": [55, true], "aps.14.22": [55, true], "aps.14.23": [55, true], "aps.14.24": [55, true], "aps.14.25": [55, true], "aps.14.26": [55, true], "aps.14.27": [55, true], "aps.14.28": [55, true], "aps.14.29": [55, true], "aps.14.30": [55, true], "aps.14.31": [55, true], "aps.14.32": [55, true], "aps.14.33": [55, true], "aps.14.34": [55, true], "aps.14.35": [55, true], "aps.14.36": [55, true], "aps.14.37": [55, true], "aps.14.38": [55, true], "aps.14.39": [55, true], "aps.15.00": [42, true], "aps.15.01": [43, true], "aps.15.02": [45, true], "aps.15.03": [43, true], "aps.15.04": [45, true], "aps.15.05": [47, true], "aps.15.06": [53, true], "aps.15.07": [54, true], "aps.15.08": [56, true], "aps.15.09": [54, true], "aps.15.10": [54, true], "aps.15.11": [54, true], "aps.15.12": [56, true], "aps.15.13": [56, true], "aps.15.14": [57, true], "aps.15.15": [54, true], "aps.15.16": [57, true], "aps.15.17": [51, true], "aps.15.18": [56, true], "aps.15.19": [55, true], "aps.15.20": [50, true], "aps.15.21": [57, true], "aps.15.22": [56, true], "aps.15.23": [57, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [55, true], "aps.15.27": [55, true], "aps.15.28": [57, true], "aps.15.29": [55, true], "aps.15.30": [55, true]}}, "CHA": {"total": 3381, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [39, true], "fun1.2": [49, true], "fun1.3": [48, true], "fun1.4": [65, true], "fun1.5": [86, true], "fun2.1": [48, true], "fun2.2": [78, true], "fun2.3": [87, true], "fun2.4": [114, true], "fun2.5": [125, true], "fun3.1": [25, true], "fun3.2": [39, true], "fun3.3": [9, true], "fun3.4": [7, true], "fun3.5": [7, true], "fun4.1": [53, true], "fun4.2": [58, true], "fun4.3": [70, true], "fun4.4": [75, true], "fun4.5": [89, true], "fun5.1": [64, true], "fun5.2": [64, true], "fun5.3": [66, true], "fun5.4": [71, true], "fun5.5": [73, true], "fun6.1": [68, true], "fun6.2": [69, true], "fun6.3": [69, true], "fun6.4": [72, true], "fun6.5": [72, true], "fun7.1": [9, false], "fun7.2": [12, false], "fun7.3": [9, false], "fun7.4": [30, false], "fun7.5": [14, false], "fun8.1": [46, true], "fun8.2": [51, true], "fun8.3": [52, true], "fun8.4": [57, true], "fun8.5": [58, true], "fun9.1": [51, true], "fun9.2": [48, true], "fun9.3": [52, true], "fun9.4": [54, true], "fun9.5": [53, true]}}}, {"label": "pure.cbrt.bracket.none", "spec": ["pure", "cbrt", "bracket", "none"], "APS": {"total": 10795, "solved": 138, "n": 154, "over": 5, "per": {"aps.01.00": [47, true], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [44, true], "aps.04.01": [51, true], "aps.04.02": [60, true], "aps.04.03": [110, true], "aps.04.04": [200, false], "aps.04.05": [51, true], "aps.04.06": [48, true], "aps.04.07": [59, true], "aps.04.08": [91, true], "aps.04.09": [182, true], "aps.04.10": [64, true], "aps.04.11": [96, true], "aps.04.12": [174, true], "aps.04.13": [200, false], "aps.05.00": [48, true], "aps.06.00": [45, true], "aps.06.01": [45, true], "aps.06.02": [45, true], "aps.06.03": [46, true], "aps.06.04": [50, true], "aps.06.05": [54, true], "aps.06.06": [56, true], "aps.06.07": [51, true], "aps.06.08": [56, true], "aps.06.09": [57, true], "aps.07.00": [48, true], "aps.07.01": [45, true], "aps.07.02": [44, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [43, true], "aps.08.03": [47, true], "aps.08.04": [41, true], "aps.09.00": [46, true], "aps.09.01": [46, true], "aps.09.02": [43, true], "aps.09.03": [47, true], "aps.09.04": [45, true], "aps.09.05": [46, true], "aps.09.06": [45, true], "aps.10.00": [47, true], "aps.10.01": [45, true], "aps.10.02": [41, true], "aps.10.03": [40, true], "aps.10.04": [47, true], "aps.11.00": [45, true], "aps.11.01": [48, true], "aps.11.02": [45, true], "aps.11.03": [48, true], "aps.12.00": [54, true], "aps.12.01": [55, true], "aps.12.02": [57, true], "aps.12.03": [54, true], "aps.12.04": [59, true], "aps.12.05": [57, true], "aps.12.06": [55, true], "aps.12.07": [59, true], "aps.12.08": [57, true], "aps.12.09": [61, true], "aps.12.10": [54, true], "aps.12.11": [54, true], "aps.12.12": [52, true], "aps.12.13": [56, true], "aps.12.14": [54, true], "aps.12.15": [49, true], "aps.12.16": [43, true], "aps.12.17": [53, true], "aps.12.18": [56, true], "aps.13.00": [200, false], "aps.14.00": [56, true], "aps.14.01": [56, true], "aps.14.02": [56, true], "aps.14.03": [56, true], "aps.14.04": [56, true], "aps.14.05": [56, true], "aps.14.06": [56, true], "aps.14.07": [56, true], "aps.14.08": [56, true], "aps.14.09": [56, true], "aps.14.10": [56, true], "aps.14.11": [56, true], "aps.14.12": [56, true], "aps.14.13": [56, true], "aps.14.14": [56, true], "aps.14.15": [56, true], "aps.14.16": [56, true], "aps.14.17": [56, true], "aps.14.18": [56, true], "aps.14.19": [56, true], "aps.14.20": [56, true], "aps.14.21": [56, true], "aps.14.22": [56, true], "aps.14.23": [56, true], "aps.14.24": [56, true], "aps.14.25": [56, true], "aps.14.26": [56, true], "aps.14.27": [56, true], "aps.14.28": [56, true], "aps.14.29": [56, true], "aps.14.30": [56, true], "aps.14.31": [56, true], "aps.14.32": [56, true], "aps.14.33": [56, true], "aps.14.34": [56, true], "aps.14.35": [56, true], "aps.14.36": [56, true], "aps.14.37": [56, true], "aps.14.38": [56, true], "aps.14.39": [56, true], "aps.15.00": [45, true], "aps.15.01": [42, true], "aps.15.02": [44, true], "aps.15.03": [44, true], "aps.15.04": [47, true], "aps.15.05": [48, true], "aps.15.06": [52, true], "aps.15.07": [56, true], "aps.15.08": [56, true], "aps.15.09": [50, true], "aps.15.10": [54, true], "aps.15.11": [56, true], "aps.15.12": [56, true], "aps.15.13": [55, true], "aps.15.14": [57, true], "aps.15.15": [54, true], "aps.15.16": [57, true], "aps.15.17": [52, true], "aps.15.18": [56, true], "aps.15.19": [53, true], "aps.15.20": [50, true], "aps.15.21": [57, true], "aps.15.22": [57, true], "aps.15.23": [59, true], "aps.15.24": [57, true], "aps.15.25": [53, true], "aps.15.26": [55, true], "aps.15.27": [55, true], "aps.15.28": [57, true], "aps.15.29": [51, true], "aps.15.30": [58, true]}}, "CHA": {"total": 6997, "solved": 15, "n": 45, "over": 3, "per": {"fun1.1": [38, true], "fun1.2": [49, true], "fun1.3": [47, true], "fun1.4": [200, false], "fun1.5": [49, true], "fun2.1": [49, true], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [75, true], "fun3.2": [52, true], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [14, false], "fun8.1": [63, true], "fun8.2": [74, true], "fun8.3": [96, true], "fun8.4": [117, true], "fun8.5": [140, true], "fun9.1": [51, true], "fun9.2": [48, true], "fun9.3": [49, true], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.cbrt.bracket.safe", "spec": ["pure", "cbrt", "bracket", "safe"], "APS": {"total": 8051, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [46, true], "aps.02.00": [48, true], "aps.02.01": [50, true], "aps.02.02": [47, true], "aps.02.03": [52, true], "aps.02.04": [51, true], "aps.02.05": [57, true], "aps.02.06": [55, true], "aps.02.07": [49, true], "aps.02.08": [55, true], "aps.02.09": [53, true], "aps.03.00": [58, true], "aps.03.01": [60, true], "aps.03.02": [54, true], "aps.04.00": [44, true], "aps.04.01": [52, true], "aps.04.02": [51, true], "aps.04.03": [54, true], "aps.04.04": [47, true], "aps.04.05": [51, true], "aps.04.06": [50, true], "aps.04.07": [49, true], "aps.04.08": [50, true], "aps.04.09": [50, true], "aps.04.10": [46, true], "aps.04.11": [52, true], "aps.04.12": [47, true], "aps.04.13": [54, true], "aps.05.00": [47, true], "aps.06.00": [45, true], "aps.06.01": [45, true], "aps.06.02": [50, true], "aps.06.03": [49, true], "aps.06.04": [48, true], "aps.06.05": [49, true], "aps.06.06": [50, true], "aps.06.07": [51, true], "aps.06.08": [51, true], "aps.06.09": [52, true], "aps.07.00": [48, true], "aps.07.01": [45, true], "aps.07.02": [44, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [43, true], "aps.08.03": [47, true], "aps.08.04": [41, true], "aps.09.00": [46, true], "aps.09.01": [46, true], "aps.09.02": [43, true], "aps.09.03": [47, true], "aps.09.04": [45, true], "aps.09.05": [46, true], "aps.09.06": [45, true], "aps.10.00": [47, true], "aps.10.01": [45, true], "aps.10.02": [41, true], "aps.10.03": [40, true], "aps.10.04": [46, true], "aps.11.00": [46, true], "aps.11.01": [48, true], "aps.11.02": [45, true], "aps.11.03": [42, true], "aps.12.00": [54, true], "aps.12.01": [47, true], "aps.12.02": [60, true], "aps.12.03": [58, true], "aps.12.04": [53, true], "aps.12.05": [59, true], "aps.12.06": [54, true], "aps.12.07": [60, true], "aps.12.08": [53, true], "aps.12.09": [52, true], "aps.12.10": [48, true], "aps.12.11": [53, true], "aps.12.12": [53, true], "aps.12.13": [54, true], "aps.12.14": [58, true], "aps.12.15": [55, true], "aps.12.16": [55, true], "aps.12.17": [58, true], "aps.12.18": [57, true], "aps.13.00": [12, false], "aps.14.00": [54, true], "aps.14.01": [54, true], "aps.14.02": [54, true], "aps.14.03": [54, true], "aps.14.04": [54, true], "aps.14.05": [54, true], "aps.14.06": [54, true], "aps.14.07": [54, true], "aps.14.08": [54, true], "aps.14.09": [54, true], "aps.14.10": [54, true], "aps.14.11": [54, true], "aps.14.12": [54, true], "aps.14.13": [54, true], "aps.14.14": [54, true], "aps.14.15": [54, true], "aps.14.16": [54, true], "aps.14.17": [54, true], "aps.14.18": [54, true], "aps.14.19": [54, true], "aps.14.20": [54, true], "aps.14.21": [54, true], "aps.14.22": [54, true], "aps.14.23": [54, true], "aps.14.24": [54, true], "aps.14.25": [54, true], "aps.14.26": [54, true], "aps.14.27": [54, true], "aps.14.28": [54, true], "aps.14.29": [54, true], "aps.14.30": [54, true], "aps.14.31": [54, true], "aps.14.32": [54, true], "aps.14.33": [54, true], "aps.14.34": [54, true], "aps.14.35": [54, true], "aps.14.36": [54, true], "aps.14.37": [54, true], "aps.14.38": [54, true], "aps.14.39": [54, true], "aps.15.00": [47, true], "aps.15.01": [45, true], "aps.15.02": [52, true], "aps.15.03": [52, true], "aps.15.04": [54, true], "aps.15.05": [55, true], "aps.15.06": [55, true], "aps.15.07": [55, true], "aps.15.08": [52, true], "aps.15.09": [56, true], "aps.15.10": [54, true], "aps.15.11": [52, true], "aps.15.12": [52, true], "aps.15.13": [53, true], "aps.15.14": [50, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [50, true], "aps.15.18": [55, true], "aps.15.19": [52, true], "aps.15.20": [51, true], "aps.15.21": [50, true], "aps.15.22": [56, true], "aps.15.23": [55, true], "aps.15.24": [58, true], "aps.15.25": [54, true], "aps.15.26": [56, true], "aps.15.27": [55, true], "aps.15.28": [55, true], "aps.15.29": [53, true], "aps.15.30": [54, true]}}, "CHA": {"total": 3788, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [38, true], "fun1.2": [49, true], "fun1.3": [47, true], "fun1.4": [51, true], "fun1.5": [49, true], "fun2.1": [43, true], "fun2.2": [92, true], "fun2.3": [108, true], "fun2.4": [150, true], "fun2.5": [162, true], "fun3.1": [24, true], "fun3.2": [39, true], "fun3.3": [8, true], "fun3.4": [6, true], "fun3.5": [6, true], "fun4.1": [87, true], "fun4.2": [92, true], "fun4.3": [107, true], "fun4.4": [120, true], "fun4.5": [135, true], "fun5.1": [86, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [71, true], "fun6.2": [72, true], "fun6.3": [79, true], "fun6.4": [79, true], "fun6.5": [81, true], "fun7.1": [12, false], "fun7.2": [5, false], "fun7.3": [11, false], "fun7.4": [30, false], "fun7.5": [14, false], "fun8.1": [50, true], "fun8.2": [49, true], "fun8.3": [58, true], "fun8.4": [64, true], "fun8.5": [67, true], "fun9.1": [43, true], "fun9.2": [48, true], "fun9.3": [48, true], "fun9.4": [52, true], "fun9.5": [60, true]}}}, {"label": "pure.cbrt.bracket.both", "spec": ["pure", "cbrt", "bracket", "both"], "APS": {"total": 7935, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [43, true], "aps.02.00": [46, true], "aps.02.01": [52, true], "aps.02.02": [45, true], "aps.02.03": [51, true], "aps.02.04": [50, true], "aps.02.05": [56, true], "aps.02.06": [54, true], "aps.02.07": [47, true], "aps.02.08": [54, true], "aps.02.09": [53, true], "aps.03.00": [54, true], "aps.03.01": [58, true], "aps.03.02": [55, true], "aps.04.00": [51, true], "aps.04.01": [49, true], "aps.04.02": [49, true], "aps.04.03": [51, true], "aps.04.04": [49, true], "aps.04.05": [47, true], "aps.04.06": [50, true], "aps.04.07": [45, true], "aps.04.08": [51, true], "aps.04.09": [48, true], "aps.04.10": [47, true], "aps.04.11": [49, true], "aps.04.12": [50, true], "aps.04.13": [53, true], "aps.05.00": [47, true], "aps.06.00": [45, true], "aps.06.01": [44, true], "aps.06.02": [47, true], "aps.06.03": [43, true], "aps.06.04": [48, true], "aps.06.05": [49, true], "aps.06.06": [52, true], "aps.06.07": [50, true], "aps.06.08": [52, true], "aps.06.09": [53, true], "aps.07.00": [49, true], "aps.07.01": [47, true], "aps.07.02": [49, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [44, true], "aps.08.03": [42, true], "aps.08.04": [42, true], "aps.09.00": [47, true], "aps.09.01": [46, true], "aps.09.02": [47, true], "aps.09.03": [45, true], "aps.09.04": [43, true], "aps.09.05": [46, true], "aps.09.06": [45, true], "aps.10.00": [47, true], "aps.10.01": [42, true], "aps.10.02": [41, true], "aps.10.03": [47, true], "aps.10.04": [45, true], "aps.11.00": [50, true], "aps.11.01": [45, true], "aps.11.02": [42, true], "aps.11.03": [43, true], "aps.12.00": [53, true], "aps.12.01": [51, true], "aps.12.02": [57, true], "aps.12.03": [56, true], "aps.12.04": [52, true], "aps.12.05": [54, true], "aps.12.06": [54, true], "aps.12.07": [54, true], "aps.12.08": [53, true], "aps.12.09": [52, true], "aps.12.10": [54, true], "aps.12.11": [56, true], "aps.12.12": [53, true], "aps.12.13": [51, true], "aps.12.14": [55, true], "aps.12.15": [57, true], "aps.12.16": [55, true], "aps.12.17": [50, true], "aps.12.18": [56, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [51, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [51, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [51, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [51, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [51, true], "aps.14.18": [51, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [51, true], "aps.14.24": [51, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [51, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [51, true], "aps.14.36": [51, true], "aps.14.37": [51, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [43, true], "aps.15.01": [45, true], "aps.15.02": [51, true], "aps.15.03": [52, true], "aps.15.04": [53, true], "aps.15.05": [55, true], "aps.15.06": [55, true], "aps.15.07": [56, true], "aps.15.08": [51, true], "aps.15.09": [56, true], "aps.15.10": [54, true], "aps.15.11": [52, true], "aps.15.12": [52, true], "aps.15.13": [53, true], "aps.15.14": [50, true], "aps.15.15": [52, true], "aps.15.16": [53, true], "aps.15.17": [50, true], "aps.15.18": [55, true], "aps.15.19": [52, true], "aps.15.20": [51, true], "aps.15.21": [50, true], "aps.15.22": [56, true], "aps.15.23": [55, true], "aps.15.24": [58, true], "aps.15.25": [55, true], "aps.15.26": [56, true], "aps.15.27": [55, true], "aps.15.28": [52, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3274, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [39, true], "fun1.2": [49, true], "fun1.3": [48, true], "fun1.4": [61, true], "fun1.5": [86, true], "fun2.1": [44, true], "fun2.2": [78, true], "fun2.3": [88, true], "fun2.4": [114, true], "fun2.5": [126, true], "fun3.1": [24, true], "fun3.2": [39, true], "fun3.3": [8, true], "fun3.4": [6, true], "fun3.5": [6, true], "fun4.1": [52, true], "fun4.2": [56, true], "fun4.3": [67, true], "fun4.4": [72, true], "fun4.5": [88, true], "fun5.1": [64, true], "fun5.2": [60, true], "fun5.3": [64, true], "fun5.4": [67, true], "fun5.5": [68, true], "fun6.1": [57, true], "fun6.2": [52, true], "fun6.3": [57, true], "fun6.4": [59, true], "fun6.5": [61, true], "fun7.1": [9, false], "fun7.2": [5, false], "fun7.3": [9, false], "fun7.4": [25, false], "fun7.5": [14, false], "fun8.1": [49, true], "fun8.2": [51, true], "fun8.3": [52, true], "fun8.4": [57, true], "fun8.5": [56, true], "fun9.1": [43, true], "fun9.2": [48, true], "fun9.3": [52, true], "fun9.4": [54, true], "fun9.5": [52, true]}}}, {"label": "pure.cbrt.bracket.project", "spec": ["pure", "cbrt", "bracket", "project"], "APS": {"total": 8925, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [47, true], "aps.02.00": [87, true], "aps.02.01": [88, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [93, true], "aps.02.09": [93, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [44, true], "aps.04.01": [51, true], "aps.04.02": [60, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [51, true], "aps.04.06": [48, true], "aps.04.07": [59, true], "aps.04.08": [85, true], "aps.04.09": [74, true], "aps.04.10": [64, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [48, true], "aps.06.00": [45, true], "aps.06.01": [45, true], "aps.06.02": [45, true], "aps.06.03": [46, true], "aps.06.04": [50, true], "aps.06.05": [54, true], "aps.06.06": [56, true], "aps.06.07": [51, true], "aps.06.08": [56, true], "aps.06.09": [57, true], "aps.07.00": [48, true], "aps.07.01": [45, true], "aps.07.02": [44, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [43, true], "aps.08.03": [47, true], "aps.08.04": [41, true], "aps.09.00": [46, true], "aps.09.01": [46, true], "aps.09.02": [43, true], "aps.09.03": [47, true], "aps.09.04": [45, true], "aps.09.05": [46, true], "aps.09.06": [45, true], "aps.10.00": [47, true], "aps.10.01": [45, true], "aps.10.02": [41, true], "aps.10.03": [40, true], "aps.10.04": [47, true], "aps.11.00": [45, true], "aps.11.01": [48, true], "aps.11.02": [45, true], "aps.11.03": [48, true], "aps.12.00": [54, true], "aps.12.01": [55, true], "aps.12.02": [57, true], "aps.12.03": [54, true], "aps.12.04": [59, true], "aps.12.05": [57, true], "aps.12.06": [55, true], "aps.12.07": [59, true], "aps.12.08": [57, true], "aps.12.09": [61, true], "aps.12.10": [54, true], "aps.12.11": [54, true], "aps.12.12": [52, true], "aps.12.13": [56, true], "aps.12.14": [54, true], "aps.12.15": [49, true], "aps.12.16": [43, true], "aps.12.17": [53, true], "aps.12.18": [56, true], "aps.13.00": [52, false], "aps.14.00": [56, true], "aps.14.01": [56, true], "aps.14.02": [56, true], "aps.14.03": [56, true], "aps.14.04": [56, true], "aps.14.05": [56, true], "aps.14.06": [56, true], "aps.14.07": [56, true], "aps.14.08": [56, true], "aps.14.09": [56, true], "aps.14.10": [56, true], "aps.14.11": [56, true], "aps.14.12": [56, true], "aps.14.13": [56, true], "aps.14.14": [56, true], "aps.14.15": [56, true], "aps.14.16": [56, true], "aps.14.17": [56, true], "aps.14.18": [56, true], "aps.14.19": [56, true], "aps.14.20": [56, true], "aps.14.21": [56, true], "aps.14.22": [56, true], "aps.14.23": [56, true], "aps.14.24": [56, true], "aps.14.25": [56, true], "aps.14.26": [56, true], "aps.14.27": [56, true], "aps.14.28": [56, true], "aps.14.29": [56, true], "aps.14.30": [56, true], "aps.14.31": [56, true], "aps.14.32": [56, true], "aps.14.33": [56, true], "aps.14.34": [56, true], "aps.14.35": [56, true], "aps.14.36": [56, true], "aps.14.37": [56, true], "aps.14.38": [56, true], "aps.14.39": [56, true], "aps.15.00": [45, true], "aps.15.01": [42, true], "aps.15.02": [44, true], "aps.15.03": [44, true], "aps.15.04": [47, true], "aps.15.05": [48, true], "aps.15.06": [52, true], "aps.15.07": [56, true], "aps.15.08": [56, true], "aps.15.09": [50, true], "aps.15.10": [54, true], "aps.15.11": [56, true], "aps.15.12": [56, true], "aps.15.13": [55, true], "aps.15.14": [57, true], "aps.15.15": [54, true], "aps.15.16": [57, true], "aps.15.17": [52, true], "aps.15.18": [56, true], "aps.15.19": [53, true], "aps.15.20": [50, true], "aps.15.21": [57, true], "aps.15.22": [57, true], "aps.15.23": [59, true], "aps.15.24": [57, true], "aps.15.25": [53, true], "aps.15.26": [55, true], "aps.15.27": [55, true], "aps.15.28": [57, true], "aps.15.29": [51, true], "aps.15.30": [58, true]}}, "CHA": {"total": 4636, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [38, true], "fun1.2": [49, true], "fun1.3": [47, true], "fun1.4": [112, true], "fun1.5": [49, true], "fun2.1": [49, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [151, true], "fun2.5": [163, true], "fun3.1": [75, true], "fun3.2": [52, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [52, false], "fun7.2": [52, false], "fun7.3": [54, false], "fun7.4": [58, false], "fun7.5": [14, false], "fun8.1": [63, true], "fun8.2": [74, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [51, true], "fun9.2": [48, true], "fun9.3": [49, true], "fun9.4": [92, true], "fun9.5": [94, true]}}}, {"label": "pure.cbrt.bracket.credit", "spec": ["pure", "cbrt", "bracket", "credit"], "APS": {"total": 7631, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [48, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [8, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [45, true], "aps.15.01": [42, true], "aps.15.02": [44, true], "aps.15.03": [44, true], "aps.15.04": [47, true], "aps.15.05": [48, true], "aps.15.06": [52, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3127, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [47, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [8, false], "fun7.2": [8, false], "fun7.3": [7, false], "fun7.4": [10, false], "fun7.5": [9, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.cbrt.derived.bracket", "spec": ["pure", "cbrt", "derived", "bracket"], "APS": {"total": 9937, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [62, true], "aps.02.00": [60, true], "aps.02.01": [63, true], "aps.02.02": [66, true], "aps.02.03": [60, true], "aps.02.04": [62, true], "aps.02.05": [63, true], "aps.02.06": [67, true], "aps.02.07": [68, true], "aps.02.08": [65, true], "aps.02.09": [68, true], "aps.03.00": [67, true], "aps.03.01": [67, true], "aps.03.02": [64, true], "aps.04.00": [67, true], "aps.04.01": [59, true], "aps.04.02": [62, true], "aps.04.03": [64, true], "aps.04.04": [64, true], "aps.04.05": [64, true], "aps.04.06": [64, true], "aps.04.07": [67, true], "aps.04.08": [59, true], "aps.04.09": [62, true], "aps.04.10": [57, true], "aps.04.11": [65, true], "aps.04.12": [62, true], "aps.04.13": [64, true], "aps.05.00": [60, true], "aps.06.00": [58, true], "aps.06.01": [58, true], "aps.06.02": [61, true], "aps.06.03": [56, true], "aps.06.04": [61, true], "aps.06.05": [57, true], "aps.06.06": [56, true], "aps.06.07": [57, true], "aps.06.08": [55, true], "aps.06.09": [57, true], "aps.07.00": [56, true], "aps.07.01": [62, true], "aps.07.02": [61, true], "aps.08.00": [61, true], "aps.08.01": [59, true], "aps.08.02": [61, true], "aps.08.03": [62, true], "aps.08.04": [57, true], "aps.09.00": [55, true], "aps.09.01": [56, true], "aps.09.02": [59, true], "aps.09.03": [59, true], "aps.09.04": [64, true], "aps.09.05": [69, true], "aps.09.06": [70, true], "aps.10.00": [55, true], "aps.10.01": [58, true], "aps.10.02": [56, true], "aps.10.03": [59, true], "aps.10.04": [57, true], "aps.11.00": [58, true], "aps.11.01": [57, true], "aps.11.02": [59, true], "aps.11.03": [59, true], "aps.12.00": [93, true], "aps.12.01": [64, true], "aps.12.02": [61, true], "aps.12.03": [68, true], "aps.12.04": [66, true], "aps.12.05": [66, true], "aps.12.06": [66, true], "aps.12.07": [68, true], "aps.12.08": [65, true], "aps.12.09": [67, true], "aps.12.10": [68, true], "aps.12.11": [64, true], "aps.12.12": [66, true], "aps.12.13": [65, true], "aps.12.14": [68, true], "aps.12.15": [64, true], "aps.12.16": [63, true], "aps.12.17": [64, true], "aps.12.18": [67, true], "aps.13.00": [11, false], "aps.14.00": [68, true], "aps.14.01": [68, true], "aps.14.02": [68, true], "aps.14.03": [68, true], "aps.14.04": [68, true], "aps.14.05": [68, true], "aps.14.06": [68, true], "aps.14.07": [68, true], "aps.14.08": [68, true], "aps.14.09": [68, true], "aps.14.10": [68, true], "aps.14.11": [68, true], "aps.14.12": [68, true], "aps.14.13": [68, true], "aps.14.14": [68, true], "aps.14.15": [68, true], "aps.14.16": [68, true], "aps.14.17": [68, true], "aps.14.18": [68, true], "aps.14.19": [68, true], "aps.14.20": [68, true], "aps.14.21": [68, true], "aps.14.22": [68, true], "aps.14.23": [68, true], "aps.14.24": [68, true], "aps.14.25": [68, true], "aps.14.26": [68, true], "aps.14.27": [68, true], "aps.14.28": [68, true], "aps.14.29": [68, true], "aps.14.30": [68, true], "aps.14.31": [68, true], "aps.14.32": [68, true], "aps.14.33": [68, true], "aps.14.34": [68, true], "aps.14.35": [68, true], "aps.14.36": [68, true], "aps.14.37": [68, true], "aps.14.38": [68, true], "aps.14.39": [68, true], "aps.15.00": [64, true], "aps.15.01": [65, true], "aps.15.02": [65, true], "aps.15.03": [63, true], "aps.15.04": [63, true], "aps.15.05": [65, true], "aps.15.06": [60, true], "aps.15.07": [60, true], "aps.15.08": [61, true], "aps.15.09": [62, true], "aps.15.10": [58, true], "aps.15.11": [61, true], "aps.15.12": [61, true], "aps.15.13": [63, true], "aps.15.14": [63, true], "aps.15.15": [64, true], "aps.15.16": [63, true], "aps.15.17": [60, true], "aps.15.18": [59, true], "aps.15.19": [60, true], "aps.15.20": [61, true], "aps.15.21": [61, true], "aps.15.22": [60, true], "aps.15.23": [62, true], "aps.15.24": [58, true], "aps.15.25": [63, true], "aps.15.26": [60, true], "aps.15.27": [59, true], "aps.15.28": [55, true], "aps.15.29": [57, true], "aps.15.30": [61, true]}}, "CHA": {"total": 3848, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [59, true], "fun1.2": [61, true], "fun1.3": [61, true], "fun1.4": [76, true], "fun1.5": [77, true], "fun2.1": [60, true], "fun2.2": [71, true], "fun2.3": [85, true], "fun2.4": [95, true], "fun2.5": [101, true], "fun3.1": [26, true], "fun3.2": [31, true], "fun3.3": [30, true], "fun3.4": [33, true], "fun3.5": [38, true], "fun4.1": [79, true], "fun4.2": [81, true], "fun4.3": [100, true], "fun4.4": [112, true], "fun4.5": [136, true], "fun5.1": [82, true], "fun5.2": [81, true], "fun5.3": [84, true], "fun5.4": [88, true], "fun5.5": [90, true], "fun6.1": [75, true], "fun6.2": [73, true], "fun6.3": [71, true], "fun6.4": [76, true], "fun6.5": [77, true], "fun7.1": [11, false], "fun7.2": [12, false], "fun7.3": [12, false], "fun7.4": [48, false], "fun7.5": [19, false], "fun8.1": [58, true], "fun8.2": [63, true], "fun8.3": [68, true], "fun8.4": [66, true], "fun8.5": [66, true], "fun9.1": [58, true], "fun9.2": [60, true], "fun9.3": [64, true], "fun9.4": [68, true], "fun9.5": [68, true]}}}, {"label": "pure.cbrt.derived.none", "spec": ["pure", "cbrt", "derived", "none"], "APS": {"total": 15364, "solved": 153, "n": 154, "over": 117, "per": {"aps.01.00": [101, true], "aps.02.00": [102, true], "aps.02.01": [104, true], "aps.02.02": [105, true], "aps.02.03": [107, true], "aps.02.04": [108, true], "aps.02.05": [108, true], "aps.02.06": [108, true], "aps.02.07": [108, true], "aps.02.08": [109, true], "aps.02.09": [109, true], "aps.03.00": [108, true], "aps.03.01": [109, true], "aps.03.02": [112, true], "aps.04.00": [98, true], "aps.04.01": [105, true], "aps.04.02": [94, true], "aps.04.03": [100, true], "aps.04.04": [103, true], "aps.04.05": [100, true], "aps.04.06": [101, true], "aps.04.07": [106, true], "aps.04.08": [103, true], "aps.04.09": [103, true], "aps.04.10": [101, true], "aps.04.11": [110, true], "aps.04.12": [103, true], "aps.04.13": [106, true], "aps.05.00": [101, true], "aps.06.00": [101, true], "aps.06.01": [99, true], "aps.06.02": [97, true], "aps.06.03": [87, true], "aps.06.04": [96, true], "aps.06.05": [92, true], "aps.06.06": [91, true], "aps.06.07": [88, true], "aps.06.08": [89, true], "aps.06.09": [91, true], "aps.07.00": [92, true], "aps.07.01": [86, true], "aps.07.02": [81, true], "aps.08.00": [101, true], "aps.08.01": [99, true], "aps.08.02": [95, true], "aps.08.03": [95, true], "aps.08.04": [96, true], "aps.09.00": [98, true], "aps.09.01": [92, true], "aps.09.02": [90, true], "aps.09.03": [87, true], "aps.09.04": [80, true], "aps.09.05": [70, true], "aps.09.06": [66, true], "aps.10.00": [101, true], "aps.10.01": [100, true], "aps.10.02": [96, true], "aps.10.03": [87, true], "aps.10.04": [92, true], "aps.11.00": [94, true], "aps.11.01": [99, true], "aps.11.02": [88, true], "aps.11.03": [92, true], "aps.12.00": [78, true], "aps.12.01": [107, true], "aps.12.02": [106, true], "aps.12.03": [106, true], "aps.12.04": [107, true], "aps.12.05": [108, true], "aps.12.06": [109, true], "aps.12.07": [113, true], "aps.12.08": [109, true], "aps.12.09": [110, true], "aps.12.10": [113, true], "aps.12.11": [114, true], "aps.12.12": [114, true], "aps.12.13": [114, true], "aps.12.14": [114, true], "aps.12.15": [114, true], "aps.12.16": [113, true], "aps.12.17": [113, true], "aps.12.18": [113, true], "aps.13.00": [16, false], "aps.14.00": [107, true], "aps.14.01": [107, true], "aps.14.02": [107, true], "aps.14.03": [107, true], "aps.14.04": [107, true], "aps.14.05": [107, true], "aps.14.06": [107, true], "aps.14.07": [107, true], "aps.14.08": [107, true], "aps.14.09": [107, true], "aps.14.10": [107, true], "aps.14.11": [107, true], "aps.14.12": [107, true], "aps.14.13": [107, true], "aps.14.14": [107, true], "aps.14.15": [107, true], "aps.14.16": [107, true], "aps.14.17": [107, true], "aps.14.18": [107, true], "aps.14.19": [107, true], "aps.14.20": [107, true], "aps.14.21": [107, true], "aps.14.22": [107, true], "aps.14.23": [107, true], "aps.14.24": [107, true], "aps.14.25": [107, true], "aps.14.26": [107, true], "aps.14.27": [107, true], "aps.14.28": [107, true], "aps.14.29": [107, true], "aps.14.30": [107, true], "aps.14.31": [107, true], "aps.14.32": [107, true], "aps.14.33": [107, true], "aps.14.34": [107, true], "aps.14.35": [107, true], "aps.14.36": [107, true], "aps.14.37": [107, true], "aps.14.38": [107, true], "aps.14.39": [107, true], "aps.15.00": [91, true], "aps.15.01": [91, true], "aps.15.02": [91, true], "aps.15.03": [91, true], "aps.15.04": [91, true], "aps.15.05": [91, true], "aps.15.06": [91, true], "aps.15.07": [91, true], "aps.15.08": [91, true], "aps.15.09": [91, true], "aps.15.10": [91, true], "aps.15.11": [91, true], "aps.15.12": [90, true], "aps.15.13": [90, true], "aps.15.14": [90, true], "aps.15.15": [90, true], "aps.15.16": [90, true], "aps.15.17": [89, true], "aps.15.18": [89, true], "aps.15.19": [89, true], "aps.15.20": [88, true], "aps.15.21": [82, true], "aps.15.22": [78, true], "aps.15.23": [80, true], "aps.15.24": [78, true], "aps.15.25": [79, true], "aps.15.26": [77, true], "aps.15.27": [74, true], "aps.15.28": [72, true], "aps.15.29": [76, true], "aps.15.30": [76, true]}}, "CHA": {"total": 4154, "solved": 40, "n": 45, "over": 14, "per": {"fun1.1": [98, true], "fun1.2": [102, true], "fun1.3": [102, true], "fun1.4": [112, true], "fun1.5": [93, true], "fun2.1": [95, true], "fun2.2": [109, true], "fun2.3": [118, true], "fun2.4": [134, true], "fun2.5": [139, true], "fun3.1": [26, true], "fun3.2": [26, true], "fun3.3": [32, true], "fun3.4": [35, true], "fun3.5": [40, true], "fun4.1": [36, true], "fun4.2": [36, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [81, true], "fun5.1": [54, true], "fun5.2": [55, true], "fun5.3": [50, true], "fun5.4": [52, true], "fun5.5": [53, true], "fun6.1": [59, true], "fun6.2": [61, true], "fun6.3": [58, true], "fun6.4": [71, true], "fun6.5": [75, true], "fun7.1": [16, false], "fun7.2": [20, false], "fun7.3": [10, false], "fun7.4": [12, false], "fun7.5": [25, false], "fun8.1": [98, true], "fun8.2": [102, true], "fun8.3": [98, true], "fun8.4": [108, true], "fun8.5": [109, true], "fun9.1": [100, true], "fun9.2": [102, true], "fun9.3": [104, true], "fun9.4": [104, true], "fun9.5": [105, true]}}}, {"label": "pure.cbrt.derived.both", "spec": ["pure", "cbrt", "derived", "both"], "APS": {"total": 9975, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [62, true], "aps.02.00": [60, true], "aps.02.01": [60, true], "aps.02.02": [63, true], "aps.02.03": [63, true], "aps.02.04": [65, true], "aps.02.05": [63, true], "aps.02.06": [64, true], "aps.02.07": [61, true], "aps.02.08": [64, true], "aps.02.09": [63, true], "aps.03.00": [67, true], "aps.03.01": [67, true], "aps.03.02": [64, true], "aps.04.00": [61, true], "aps.04.01": [59, true], "aps.04.02": [71, true], "aps.04.03": [62, true], "aps.04.04": [68, true], "aps.04.05": [62, true], "aps.04.06": [63, true], "aps.04.07": [64, true], "aps.04.08": [66, true], "aps.04.09": [61, true], "aps.04.10": [59, true], "aps.04.11": [64, true], "aps.04.12": [71, true], "aps.04.13": [58, true], "aps.05.00": [56, true], "aps.06.00": [61, true], "aps.06.01": [59, true], "aps.06.02": [60, true], "aps.06.03": [58, true], "aps.06.04": [55, true], "aps.06.05": [57, true], "aps.06.06": [56, true], "aps.06.07": [56, true], "aps.06.08": [55, true], "aps.06.09": [57, true], "aps.07.00": [63, true], "aps.07.01": [67, true], "aps.07.02": [65, true], "aps.08.00": [3, true], "aps.08.01": [62, true], "aps.08.02": [59, true], "aps.08.03": [56, true], "aps.08.04": [56, true], "aps.09.00": [58, true], "aps.09.01": [58, true], "aps.09.02": [61, true], "aps.09.03": [68, true], "aps.09.04": [69, true], "aps.09.05": [76, true], "aps.09.06": [78, true], "aps.10.00": [57, true], "aps.10.01": [59, true], "aps.10.02": [58, true], "aps.10.03": [57, true], "aps.10.04": [59, true], "aps.11.00": [55, true], "aps.11.01": [56, true], "aps.11.02": [58, true], "aps.11.03": [56, true], "aps.12.00": [93, true], "aps.12.01": [64, true], "aps.12.02": [65, true], "aps.12.03": [64, true], "aps.12.04": [66, true], "aps.12.05": [60, true], "aps.12.06": [61, true], "aps.12.07": [64, true], "aps.12.08": [68, true], "aps.12.09": [68, true], "aps.12.10": [70, true], "aps.12.11": [67, true], "aps.12.12": [61, true], "aps.12.13": [68, true], "aps.12.14": [69, true], "aps.12.15": [68, true], "aps.12.16": [68, true], "aps.12.17": [65, true], "aps.12.18": [69, true], "aps.13.00": [8, false], "aps.14.00": [68, true], "aps.14.01": [68, true], "aps.14.02": [68, true], "aps.14.03": [68, true], "aps.14.04": [68, true], "aps.14.05": [68, true], "aps.14.06": [68, true], "aps.14.07": [68, true], "aps.14.08": [68, true], "aps.14.09": [68, true], "aps.14.10": [68, true], "aps.14.11": [68, true], "aps.14.12": [68, true], "aps.14.13": [68, true], "aps.14.14": [68, true], "aps.14.15": [68, true], "aps.14.16": [68, true], "aps.14.17": [68, true], "aps.14.18": [68, true], "aps.14.19": [68, true], "aps.14.20": [68, true], "aps.14.21": [68, true], "aps.14.22": [68, true], "aps.14.23": [68, true], "aps.14.24": [68, true], "aps.14.25": [68, true], "aps.14.26": [68, true], "aps.14.27": [68, true], "aps.14.28": [68, true], "aps.14.29": [68, true], "aps.14.30": [68, true], "aps.14.31": [68, true], "aps.14.32": [68, true], "aps.14.33": [68, true], "aps.14.34": [68, true], "aps.14.35": [68, true], "aps.14.36": [68, true], "aps.14.37": [68, true], "aps.14.38": [68, true], "aps.14.39": [68, true], "aps.15.00": [64, true], "aps.15.01": [63, true], "aps.15.02": [63, true], "aps.15.03": [63, true], "aps.15.04": [63, true], "aps.15.05": [64, true], "aps.15.06": [64, true], "aps.15.07": [59, true], "aps.15.08": [65, true], "aps.15.09": [64, true], "aps.15.10": [69, true], "aps.15.11": [65, true], "aps.15.12": [64, true], "aps.15.13": [64, true], "aps.15.14": [60, true], "aps.15.15": [65, true], "aps.15.16": [61, true], "aps.15.17": [61, true], "aps.15.18": [64, true], "aps.15.19": [63, true], "aps.15.20": [62, true], "aps.15.21": [62, true], "aps.15.22": [61, true], "aps.15.23": [61, true], "aps.15.24": [64, true], "aps.15.25": [60, true], "aps.15.26": [60, true], "aps.15.27": [67, true], "aps.15.28": [68, true], "aps.15.29": [62, true], "aps.15.30": [63, true]}}, "CHA": {"total": 3548, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [59, true], "fun1.2": [61, true], "fun1.3": [61, true], "fun1.4": [65, true], "fun1.5": [87, true], "fun2.1": [58, true], "fun2.2": [75, true], "fun2.3": [85, true], "fun2.4": [95, true], "fun2.5": [101, true], "fun3.1": [22, true], "fun3.2": [26, true], "fun3.3": [8, true], "fun3.4": [6, true], "fun3.5": [6, true], "fun4.1": [62, true], "fun4.2": [65, true], "fun4.3": [80, true], "fun4.4": [84, true], "fun4.5": [102, true], "fun5.1": [69, true], "fun5.2": [70, true], "fun5.3": [69, true], "fun5.4": [76, true], "fun5.5": [78, true], "fun6.1": [62, true], "fun6.2": [66, true], "fun6.3": [70, true], "fun6.4": [74, true], "fun6.5": [75, true], "fun7.1": [8, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [47, false], "fun7.5": [18, false], "fun8.1": [61, true], "fun8.2": [63, true], "fun8.3": [66, true], "fun8.4": [66, true], "fun8.5": [68, true], "fun9.1": [56, true], "fun9.2": [60, true], "fun9.3": [59, true], "fun9.4": [61, true], "fun9.5": [71, true]}}}, {"label": "pure.cbrt.derived.safe", "spec": ["pure", "cbrt", "derived", "safe"], "APS": {"total": 9918, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [62, true], "aps.02.00": [63, true], "aps.02.01": [60, true], "aps.02.02": [62, true], "aps.02.03": [62, true], "aps.02.04": [64, true], "aps.02.05": [65, true], "aps.02.06": [63, true], "aps.02.07": [64, true], "aps.02.08": [60, true], "aps.02.09": [67, true], "aps.03.00": [67, true], "aps.03.01": [69, true], "aps.03.02": [58, true], "aps.04.00": [59, true], "aps.04.01": [61, true], "aps.04.02": [61, true], "aps.04.03": [62, true], "aps.04.04": [66, true], "aps.04.05": [61, true], "aps.04.06": [60, true], "aps.04.07": [62, true], "aps.04.08": [65, true], "aps.04.09": [65, true], "aps.04.10": [61, true], "aps.04.11": [63, true], "aps.04.12": [62, true], "aps.04.13": [63, true], "aps.05.00": [62, true], "aps.06.00": [57, true], "aps.06.01": [60, true], "aps.06.02": [59, true], "aps.06.03": [58, true], "aps.06.04": [59, true], "aps.06.05": [57, true], "aps.06.06": [56, true], "aps.06.07": [56, true], "aps.06.08": [55, true], "aps.06.09": [53, true], "aps.07.00": [61, true], "aps.07.01": [56, true], "aps.07.02": [56, true], "aps.08.00": [3, true], "aps.08.01": [59, true], "aps.08.02": [59, true], "aps.08.03": [58, true], "aps.08.04": [60, true], "aps.09.00": [55, true], "aps.09.01": [62, true], "aps.09.02": [61, true], "aps.09.03": [57, true], "aps.09.04": [52, true], "aps.09.05": [50, true], "aps.09.06": [46, true], "aps.10.00": [57, true], "aps.10.01": [57, true], "aps.10.02": [57, true], "aps.10.03": [55, true], "aps.10.04": [57, true], "aps.11.00": [58, true], "aps.11.01": [58, true], "aps.11.02": [60, true], "aps.11.03": [61, true], "aps.12.00": [55, true], "aps.12.01": [63, true], "aps.12.02": [64, true], "aps.12.03": [63, true], "aps.12.04": [65, true], "aps.12.05": [68, true], "aps.12.06": [67, true], "aps.12.07": [68, true], "aps.12.08": [69, true], "aps.12.09": [71, true], "aps.12.10": [66, true], "aps.12.11": [68, true], "aps.12.12": [68, true], "aps.12.13": [66, true], "aps.12.14": [65, true], "aps.12.15": [67, true], "aps.12.16": [67, true], "aps.12.17": [68, true], "aps.12.18": [65, true], "aps.13.00": [10, false], "aps.14.00": [70, true], "aps.14.01": [70, true], "aps.14.02": [70, true], "aps.14.03": [70, true], "aps.14.04": [70, true], "aps.14.05": [70, true], "aps.14.06": [70, true], "aps.14.07": [70, true], "aps.14.08": [70, true], "aps.14.09": [70, true], "aps.14.10": [70, true], "aps.14.11": [70, true], "aps.14.12": [70, true], "aps.14.13": [70, true], "aps.14.14": [70, true], "aps.14.15": [70, true], "aps.14.16": [70, true], "aps.14.17": [70, true], "aps.14.18": [70, true], "aps.14.19": [70, true], "aps.14.20": [70, true], "aps.14.21": [70, true], "aps.14.22": [70, true], "aps.14.23": [70, true], "aps.14.24": [70, true], "aps.14.25": [70, true], "aps.14.26": [70, true], "aps.14.27": [70, true], "aps.14.28": [70, true], "aps.14.29": [70, true], "aps.14.30": [70, true], "aps.14.31": [70, true], "aps.14.32": [70, true], "aps.14.33": [70, true], "aps.14.34": [70, true], "aps.14.35": [70, true], "aps.14.36": [70, true], "aps.14.37": [70, true], "aps.14.38": [70, true], "aps.14.39": [70, true], "aps.15.00": [65, true], "aps.15.01": [65, true], "aps.15.02": [64, true], "aps.15.03": [65, true], "aps.15.04": [64, true], "aps.15.05": [64, true], "aps.15.06": [65, true], "aps.15.07": [62, true], "aps.15.08": [62, true], "aps.15.09": [62, true], "aps.15.10": [58, true], "aps.15.11": [62, true], "aps.15.12": [64, true], "aps.15.13": [65, true], "aps.15.14": [63, true], "aps.15.15": [66, true], "aps.15.16": [66, true], "aps.15.17": [66, true], "aps.15.18": [65, true], "aps.15.19": [59, true], "aps.15.20": [62, true], "aps.15.21": [61, true], "aps.15.22": [63, true], "aps.15.23": [66, true], "aps.15.24": [64, true], "aps.15.25": [58, true], "aps.15.26": [61, true], "aps.15.27": [63, true], "aps.15.28": [61, true], "aps.15.29": [65, true], "aps.15.30": [65, true]}}, "CHA": {"total": 3240, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [61, true], "fun1.3": [62, true], "fun1.4": [69, true], "fun1.5": [83, true], "fun2.1": [57, true], "fun2.2": [75, true], "fun2.3": [82, true], "fun2.4": [94, true], "fun2.5": [101, true], "fun3.1": [22, true], "fun3.2": [26, true], "fun3.3": [8, true], "fun3.4": [6, true], "fun3.5": [6, true], "fun4.1": [42, true], "fun4.2": [46, true], "fun4.3": [57, true], "fun4.4": [56, true], "fun4.5": [71, true], "fun5.1": [51, true], "fun5.2": [59, true], "fun5.3": [51, true], "fun5.4": [52, true], "fun5.5": [54, true], "fun6.1": [46, true], "fun6.2": [56, true], "fun6.3": [46, true], "fun6.4": [54, true], "fun6.5": [55, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [15, false], "fun7.5": [21, false], "fun8.1": [64, true], "fun8.2": [62, true], "fun8.3": [64, true], "fun8.4": [67, true], "fun8.5": [70, true], "fun9.1": [58, true], "fun9.2": [58, true], "fun9.3": [62, true], "fun9.4": [62, true], "fun9.5": [67, true]}}}, {"label": "pure.cbrt.derived.credit", "spec": ["pure", "cbrt", "derived", "credit"], "APS": {"total": 7722, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [43, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [8, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 2995, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [26, true], "fun3.2": [26, true], "fun3.3": [32, true], "fun3.4": [35, true], "fun3.5": [40, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [8, false], "fun7.2": [8, false], "fun7.3": [47, false], "fun7.4": [12, false], "fun7.5": [50, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.cbrt.derived3.step", "spec": ["pure", "cbrt", "derived3", "step"], "APS": {"total": 9219, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [57, true], "aps.02.00": [62, true], "aps.02.01": [62, true], "aps.02.02": [63, true], "aps.02.03": [64, true], "aps.02.04": [66, true], "aps.02.05": [63, true], "aps.02.06": [64, true], "aps.02.07": [66, true], "aps.02.08": [61, true], "aps.02.09": [64, true], "aps.03.00": [67, true], "aps.03.01": [64, true], "aps.03.02": [65, true], "aps.04.00": [57, true], "aps.04.01": [64, true], "aps.04.02": [56, true], "aps.04.03": [65, true], "aps.04.04": [64, true], "aps.04.05": [58, true], "aps.04.06": [63, true], "aps.04.07": [62, true], "aps.04.08": [65, true], "aps.04.09": [65, true], "aps.04.10": [61, true], "aps.04.11": [61, true], "aps.04.12": [62, true], "aps.04.13": [65, true], "aps.05.00": [60, true], "aps.06.00": [57, true], "aps.06.01": [59, true], "aps.06.02": [60, true], "aps.06.03": [61, true], "aps.06.04": [61, true], "aps.06.05": [61, true], "aps.06.06": [58, true], "aps.06.07": [54, true], "aps.06.08": [62, true], "aps.06.09": [62, true], "aps.07.00": [56, true], "aps.07.01": [59, true], "aps.07.02": [59, true], "aps.08.00": [3, true], "aps.08.01": [57, true], "aps.08.02": [58, true], "aps.08.03": [58, true], "aps.08.04": [56, true], "aps.09.00": [58, true], "aps.09.01": [59, true], "aps.09.02": [58, true], "aps.09.03": [58, true], "aps.09.04": [50, true], "aps.09.05": [51, true], "aps.09.06": [44, true], "aps.10.00": [60, true], "aps.10.01": [56, true], "aps.10.02": [56, true], "aps.10.03": [57, true], "aps.10.04": [59, true], "aps.11.00": [60, true], "aps.11.01": [60, true], "aps.11.02": [55, true], "aps.11.03": [60, true], "aps.12.00": [67, true], "aps.12.01": [66, true], "aps.12.02": [68, true], "aps.12.03": [66, true], "aps.12.04": [67, true], "aps.12.05": [68, true], "aps.12.06": [70, true], "aps.12.07": [69, true], "aps.12.08": [69, true], "aps.12.09": [65, true], "aps.12.10": [65, true], "aps.12.11": [69, true], "aps.12.12": [66, true], "aps.12.13": [66, true], "aps.12.14": [64, true], "aps.12.15": [67, true], "aps.12.16": [70, true], "aps.12.17": [70, true], "aps.12.18": [69, true], "aps.13.00": [12, false], "aps.14.00": [62, true], "aps.14.01": [62, true], "aps.14.02": [62, true], "aps.14.03": [62, true], "aps.14.04": [62, true], "aps.14.05": [62, true], "aps.14.06": [62, true], "aps.14.07": [62, true], "aps.14.08": [62, true], "aps.14.09": [62, true], "aps.14.10": [62, true], "aps.14.11": [62, true], "aps.14.12": [62, true], "aps.14.13": [62, true], "aps.14.14": [62, true], "aps.14.15": [62, true], "aps.14.16": [62, true], "aps.14.17": [62, true], "aps.14.18": [62, true], "aps.14.19": [62, true], "aps.14.20": [62, true], "aps.14.21": [62, true], "aps.14.22": [62, true], "aps.14.23": [62, true], "aps.14.24": [62, true], "aps.14.25": [62, true], "aps.14.26": [62, true], "aps.14.27": [62, true], "aps.14.28": [62, true], "aps.14.29": [62, true], "aps.14.30": [62, true], "aps.14.31": [62, true], "aps.14.32": [62, true], "aps.14.33": [62, true], "aps.14.34": [62, true], "aps.14.35": [62, true], "aps.14.36": [62, true], "aps.14.37": [62, true], "aps.14.38": [62, true], "aps.14.39": [62, true], "aps.15.00": [51, true], "aps.15.01": [50, true], "aps.15.02": [52, true], "aps.15.03": [50, true], "aps.15.04": [50, true], "aps.15.05": [46, true], "aps.15.06": [48, true], "aps.15.07": [50, true], "aps.15.08": [50, true], "aps.15.09": [51, true], "aps.15.10": [52, true], "aps.15.11": [50, true], "aps.15.12": [48, true], "aps.15.13": [52, true], "aps.15.14": [50, true], "aps.15.15": [49, true], "aps.15.16": [50, true], "aps.15.17": [49, true], "aps.15.18": [49, true], "aps.15.19": [50, true], "aps.15.20": [52, true], "aps.15.21": [48, true], "aps.15.22": [46, true], "aps.15.23": [47, true], "aps.15.24": [50, true], "aps.15.25": [50, true], "aps.15.26": [51, true], "aps.15.27": [49, true], "aps.15.28": [51, true], "aps.15.29": [49, true], "aps.15.30": [50, true]}}, "CHA": {"total": 3755, "solved": 40, "n": 45, "over": 6, "per": {"fun1.1": [61, true], "fun1.2": [58, true], "fun1.3": [59, true], "fun1.4": [65, true], "fun1.5": [72, true], "fun2.1": [58, true], "fun2.2": [78, true], "fun2.3": [82, true], "fun2.4": [92, true], "fun2.5": [100, true], "fun3.1": [25, true], "fun3.2": [20, true], "fun3.3": [21, true], "fun3.4": [16, true], "fun3.5": [27, true], "fun4.1": [54, true], "fun4.2": [58, true], "fun4.3": [70, true], "fun4.4": [77, true], "fun4.5": [85, true], "fun5.1": [91, true], "fun5.2": [95, true], "fun5.3": [95, true], "fun5.4": [100, true], "fun5.5": [102, true], "fun6.1": [81, true], "fun6.2": [86, true], "fun6.3": [90, true], "fun6.4": [97, true], "fun6.5": [98, true], "fun7.1": [12, false], "fun7.2": [11, false], "fun7.3": [11, false], "fun7.4": [16, false], "fun7.5": [19, false], "fun8.1": [63, true], "fun8.2": [63, true], "fun8.3": [64, true], "fun8.4": [69, true], "fun8.5": [70, true], "fun9.1": [56, true], "fun9.2": [60, true], "fun9.3": [60, true], "fun9.4": [67, true], "fun9.5": [70, true]}}}, {"label": "pure.cbrt.derived3.bracket", "spec": ["pure", "cbrt", "derived3", "bracket"], "APS": {"total": 9701, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [61, true], "aps.02.00": [60, true], "aps.02.01": [64, true], "aps.02.02": [65, true], "aps.02.03": [65, true], "aps.02.04": [66, true], "aps.02.05": [66, true], "aps.02.06": [64, true], "aps.02.07": [66, true], "aps.02.08": [69, true], "aps.02.09": [65, true], "aps.03.00": [67, true], "aps.03.01": [65, true], "aps.03.02": [65, true], "aps.04.00": [57, true], "aps.04.01": [63, true], "aps.04.02": [62, true], "aps.04.03": [59, true], "aps.04.04": [58, true], "aps.04.05": [59, true], "aps.04.06": [63, true], "aps.04.07": [64, true], "aps.04.08": [60, true], "aps.04.09": [61, true], "aps.04.10": [60, true], "aps.04.11": [60, true], "aps.04.12": [60, true], "aps.04.13": [64, true], "aps.05.00": [63, true], "aps.06.00": [60, true], "aps.06.01": [59, true], "aps.06.02": [56, true], "aps.06.03": [57, true], "aps.06.04": [57, true], "aps.06.05": [61, true], "aps.06.06": [62, true], "aps.06.07": [63, true], "aps.06.08": [62, true], "aps.06.09": [58, true], "aps.07.00": [59, true], "aps.07.01": [60, true], "aps.07.02": [58, true], "aps.08.00": [61, true], "aps.08.01": [54, true], "aps.08.02": [58, true], "aps.08.03": [55, true], "aps.08.04": [55, true], "aps.09.00": [62, true], "aps.09.01": [59, true], "aps.09.02": [55, true], "aps.09.03": [56, true], "aps.09.04": [58, true], "aps.09.05": [49, true], "aps.09.06": [47, true], "aps.10.00": [59, true], "aps.10.01": [58, true], "aps.10.02": [57, true], "aps.10.03": [54, true], "aps.10.04": [57, true], "aps.11.00": [58, true], "aps.11.01": [57, true], "aps.11.02": [58, true], "aps.11.03": [55, true], "aps.12.00": [62, true], "aps.12.01": [71, true], "aps.12.02": [67, true], "aps.12.03": [71, true], "aps.12.04": [64, true], "aps.12.05": [67, true], "aps.12.06": [69, true], "aps.12.07": [71, true], "aps.12.08": [66, true], "aps.12.09": [66, true], "aps.12.10": [65, true], "aps.12.11": [68, true], "aps.12.12": [63, true], "aps.12.13": [67, true], "aps.12.14": [63, true], "aps.12.15": [63, true], "aps.12.16": [64, true], "aps.12.17": [67, true], "aps.12.18": [69, true], "aps.13.00": [10, false], "aps.14.00": [66, true], "aps.14.01": [66, true], "aps.14.02": [66, true], "aps.14.03": [66, true], "aps.14.04": [66, true], "aps.14.05": [66, true], "aps.14.06": [66, true], "aps.14.07": [66, true], "aps.14.08": [66, true], "aps.14.09": [66, true], "aps.14.10": [66, true], "aps.14.11": [66, true], "aps.14.12": [66, true], "aps.14.13": [66, true], "aps.14.14": [66, true], "aps.14.15": [66, true], "aps.14.16": [66, true], "aps.14.17": [66, true], "aps.14.18": [66, true], "aps.14.19": [66, true], "aps.14.20": [66, true], "aps.14.21": [66, true], "aps.14.22": [66, true], "aps.14.23": [66, true], "aps.14.24": [66, true], "aps.14.25": [66, true], "aps.14.26": [66, true], "aps.14.27": [66, true], "aps.14.28": [66, true], "aps.14.29": [66, true], "aps.14.30": [66, true], "aps.14.31": [66, true], "aps.14.32": [66, true], "aps.14.33": [66, true], "aps.14.34": [66, true], "aps.14.35": [66, true], "aps.14.36": [66, true], "aps.14.37": [66, true], "aps.14.38": [66, true], "aps.14.39": [66, true], "aps.15.00": [57, true], "aps.15.01": [60, true], "aps.15.02": [57, true], "aps.15.03": [61, true], "aps.15.04": [59, true], "aps.15.05": [62, true], "aps.15.06": [63, true], "aps.15.07": [56, true], "aps.15.08": [59, true], "aps.15.09": [56, true], "aps.15.10": [57, true], "aps.15.11": [58, true], "aps.15.12": [61, true], "aps.15.13": [57, true], "aps.15.14": [60, true], "aps.15.15": [60, true], "aps.15.16": [60, true], "aps.15.17": [60, true], "aps.15.18": [60, true], "aps.15.19": [62, true], "aps.15.20": [57, true], "aps.15.21": [60, true], "aps.15.22": [59, true], "aps.15.23": [58, true], "aps.15.24": [51, true], "aps.15.25": [58, true], "aps.15.26": [56, true], "aps.15.27": [59, true], "aps.15.28": [63, true], "aps.15.29": [59, true], "aps.15.30": [58, true]}}, "CHA": {"total": 3779, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [60, true], "fun1.2": [58, true], "fun1.3": [63, true], "fun1.4": [69, true], "fun1.5": [95, true], "fun2.1": [60, true], "fun2.2": [75, true], "fun2.3": [74, true], "fun2.4": [94, true], "fun2.5": [101, true], "fun3.1": [50, true], "fun3.2": [51, true], "fun3.3": [56, true], "fun3.4": [59, true], "fun3.5": [73, true], "fun4.1": [64, true], "fun4.2": [66, true], "fun4.3": [82, true], "fun4.4": [94, true], "fun4.5": [107, true], "fun5.1": [68, true], "fun5.2": [71, true], "fun5.3": [75, true], "fun5.4": [80, true], "fun5.5": [82, true], "fun6.1": [64, true], "fun6.2": [65, true], "fun6.3": [62, true], "fun6.4": [68, true], "fun6.5": [62, true], "fun7.1": [10, false], "fun7.2": [7, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [53, false], "fun8.1": [60, true], "fun8.2": [64, true], "fun8.3": [63, true], "fun8.4": [65, true], "fun8.5": [67, true], "fun9.1": [58, true], "fun9.2": [61, true], "fun9.3": [60, true], "fun9.4": [66, true], "fun9.5": [67, true]}}}, {"label": "pure.cbrt.derived3.none", "spec": ["pure", "cbrt", "derived3", "none"], "APS": {"total": 14957, "solved": 153, "n": 154, "over": 74, "per": {"aps.01.00": [100, true], "aps.02.00": [101, true], "aps.02.01": [102, true], "aps.02.02": [104, true], "aps.02.03": [106, true], "aps.02.04": [107, true], "aps.02.05": [107, true], "aps.02.06": [107, true], "aps.02.07": [108, true], "aps.02.08": [108, true], "aps.02.09": [108, true], "aps.03.00": [106, true], "aps.03.01": [102, true], "aps.03.02": [111, true], "aps.04.00": [98, true], "aps.04.01": [98, true], "aps.04.02": [89, true], "aps.04.03": [98, true], "aps.04.04": [102, true], "aps.04.05": [99, true], "aps.04.06": [96, true], "aps.04.07": [95, true], "aps.04.08": [90, true], "aps.04.09": [103, true], "aps.04.10": [99, true], "aps.04.11": [104, true], "aps.04.12": [105, true], "aps.04.13": [100, true], "aps.05.00": [102, true], "aps.06.00": [101, true], "aps.06.01": [101, true], "aps.06.02": [99, true], "aps.06.03": [100, true], "aps.06.04": [100, true], "aps.06.05": [99, true], "aps.06.06": [98, true], "aps.06.07": [97, true], "aps.06.08": [97, true], "aps.06.09": [92, true], "aps.07.00": [97, true], "aps.07.01": [93, true], "aps.07.02": [90, true], "aps.08.00": [101, true], "aps.08.01": [99, true], "aps.08.02": [97, true], "aps.08.03": [84, true], "aps.08.04": [94, true], "aps.09.00": [101, true], "aps.09.01": [100, true], "aps.09.02": [93, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [73, true], "aps.09.06": [62, true], "aps.10.00": [101, true], "aps.10.01": [97, true], "aps.10.02": [83, true], "aps.10.03": [91, true], "aps.10.04": [92, true], "aps.11.00": [90, true], "aps.11.01": [93, true], "aps.11.02": [94, true], "aps.11.03": [93, true], "aps.12.00": [109, true], "aps.12.01": [112, true], "aps.12.02": [112, true], "aps.12.03": [114, true], "aps.12.04": [114, true], "aps.12.05": [115, true], "aps.12.06": [115, true], "aps.12.07": [115, true], "aps.12.08": [112, true], "aps.12.09": [112, true], "aps.12.10": [112, true], "aps.12.11": [112, true], "aps.12.12": [112, true], "aps.12.13": [112, true], "aps.12.14": [113, true], "aps.12.15": [112, true], "aps.12.16": [112, true], "aps.12.17": [112, true], "aps.12.18": [111, true], "aps.13.00": [21, false], "aps.14.00": [100, true], "aps.14.01": [100, true], "aps.14.02": [100, true], "aps.14.03": [100, true], "aps.14.04": [100, true], "aps.14.05": [100, true], "aps.14.06": [100, true], "aps.14.07": [100, true], "aps.14.08": [100, true], "aps.14.09": [100, true], "aps.14.10": [100, true], "aps.14.11": [100, true], "aps.14.12": [100, true], "aps.14.13": [100, true], "aps.14.14": [100, true], "aps.14.15": [100, true], "aps.14.16": [100, true], "aps.14.17": [100, true], "aps.14.18": [100, true], "aps.14.19": [100, true], "aps.14.20": [100, true], "aps.14.21": [100, true], "aps.14.22": [100, true], "aps.14.23": [100, true], "aps.14.24": [100, true], "aps.14.25": [100, true], "aps.14.26": [100, true], "aps.14.27": [100, true], "aps.14.28": [100, true], "aps.14.29": [100, true], "aps.14.30": [100, true], "aps.14.31": [100, true], "aps.14.32": [100, true], "aps.14.33": [100, true], "aps.14.34": [100, true], "aps.14.35": [100, true], "aps.14.36": [100, true], "aps.14.37": [100, true], "aps.14.38": [100, true], "aps.14.39": [100, true], "aps.15.00": [86, true], "aps.15.01": [85, true], "aps.15.02": [85, true], "aps.15.03": [84, true], "aps.15.04": [83, true], "aps.15.05": [81, true], "aps.15.06": [79, true], "aps.15.07": [39, true], "aps.15.08": [80, true], "aps.15.09": [83, true], "aps.15.10": [83, true], "aps.15.11": [84, true], "aps.15.12": [84, true], "aps.15.13": [85, true], "aps.15.14": [85, true], "aps.15.15": [85, true], "aps.15.16": [85, true], "aps.15.17": [85, true], "aps.15.18": [85, true], "aps.15.19": [85, true], "aps.15.20": [84, true], "aps.15.21": [81, true], "aps.15.22": [81, true], "aps.15.23": [79, true], "aps.15.24": [73, true], "aps.15.25": [78, true], "aps.15.26": [81, true], "aps.15.27": [81, true], "aps.15.28": [72, true], "aps.15.29": [78, true], "aps.15.30": [79, true]}}, "CHA": {"total": 4255, "solved": 40, "n": 45, "over": 14, "per": {"fun1.1": [96, true], "fun1.2": [102, true], "fun1.3": [100, true], "fun1.4": [106, true], "fun1.5": [122, true], "fun2.1": [96, true], "fun2.2": [107, true], "fun2.3": [125, true], "fun2.4": [128, true], "fun2.5": [146, true], "fun3.1": [22, true], "fun3.2": [23, true], "fun3.3": [32, true], "fun3.4": [38, true], "fun3.5": [46, true], "fun4.1": [32, true], "fun4.2": [32, true], "fun4.3": [40, true], "fun4.4": [47, true], "fun4.5": [59, true], "fun5.1": [67, true], "fun5.2": [62, true], "fun5.3": [55, true], "fun5.4": [61, true], "fun5.5": [61, true], "fun6.1": [89, true], "fun6.2": [79, true], "fun6.3": [92, true], "fun6.4": [94, true], "fun6.5": [95, true], "fun7.1": [21, false], "fun7.2": [9, false], "fun7.3": [23, false], "fun7.4": [65, false], "fun7.5": [16, false], "fun8.1": [96, true], "fun8.2": [98, true], "fun8.3": [104, true], "fun8.4": [107, true], "fun8.5": [110, true], "fun9.1": [98, true], "fun9.2": [101, true], "fun9.3": [99, true], "fun9.4": [87, true], "fun9.5": [101, true]}}}, {"label": "pure.cbrt.derived3.both", "spec": ["pure", "cbrt", "derived3", "both"], "APS": {"total": 9315, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [61, true], "aps.02.00": [59, true], "aps.02.01": [53, true], "aps.02.02": [62, true], "aps.02.03": [61, true], "aps.02.04": [64, true], "aps.02.05": [64, true], "aps.02.06": [58, true], "aps.02.07": [63, true], "aps.02.08": [63, true], "aps.02.09": [63, true], "aps.03.00": [59, true], "aps.03.01": [69, true], "aps.03.02": [65, true], "aps.04.00": [64, true], "aps.04.01": [65, true], "aps.04.02": [60, true], "aps.04.03": [60, true], "aps.04.04": [67, true], "aps.04.05": [59, true], "aps.04.06": [59, true], "aps.04.07": [60, true], "aps.04.08": [64, true], "aps.04.09": [62, true], "aps.04.10": [59, true], "aps.04.11": [59, true], "aps.04.12": [64, true], "aps.04.13": [58, true], "aps.05.00": [60, true], "aps.06.00": [58, true], "aps.06.01": [54, true], "aps.06.02": [58, true], "aps.06.03": [58, true], "aps.06.04": [60, true], "aps.06.05": [59, true], "aps.06.06": [60, true], "aps.06.07": [60, true], "aps.06.08": [60, true], "aps.06.09": [60, true], "aps.07.00": [55, true], "aps.07.01": [56, true], "aps.07.02": [55, true], "aps.08.00": [3, true], "aps.08.01": [58, true], "aps.08.02": [59, true], "aps.08.03": [60, true], "aps.08.04": [58, true], "aps.09.00": [57, true], "aps.09.01": [57, true], "aps.09.02": [60, true], "aps.09.03": [62, true], "aps.09.04": [50, true], "aps.09.05": [54, true], "aps.09.06": [59, true], "aps.10.00": [60, true], "aps.10.01": [56, true], "aps.10.02": [53, true], "aps.10.03": [58, true], "aps.10.04": [57, true], "aps.11.00": [58, true], "aps.11.01": [57, true], "aps.11.02": [55, true], "aps.11.03": [56, true], "aps.12.00": [62, true], "aps.12.01": [71, true], "aps.12.02": [64, true], "aps.12.03": [69, true], "aps.12.04": [70, true], "aps.12.05": [71, true], "aps.12.06": [69, true], "aps.12.07": [72, true], "aps.12.08": [70, true], "aps.12.09": [68, true], "aps.12.10": [71, true], "aps.12.11": [68, true], "aps.12.12": [65, true], "aps.12.13": [69, true], "aps.12.14": [64, true], "aps.12.15": [64, true], "aps.12.16": [68, true], "aps.12.17": [67, true], "aps.12.18": [61, true], "aps.13.00": [10, false], "aps.14.00": [66, true], "aps.14.01": [66, true], "aps.14.02": [66, true], "aps.14.03": [66, true], "aps.14.04": [66, true], "aps.14.05": [66, true], "aps.14.06": [66, true], "aps.14.07": [66, true], "aps.14.08": [66, true], "aps.14.09": [66, true], "aps.14.10": [66, true], "aps.14.11": [66, true], "aps.14.12": [66, true], "aps.14.13": [66, true], "aps.14.14": [66, true], "aps.14.15": [66, true], "aps.14.16": [66, true], "aps.14.17": [66, true], "aps.14.18": [66, true], "aps.14.19": [66, true], "aps.14.20": [66, true], "aps.14.21": [66, true], "aps.14.22": [66, true], "aps.14.23": [66, true], "aps.14.24": [66, true], "aps.14.25": [66, true], "aps.14.26": [66, true], "aps.14.27": [66, true], "aps.14.28": [66, true], "aps.14.29": [66, true], "aps.14.30": [66, true], "aps.14.31": [66, true], "aps.14.32": [66, true], "aps.14.33": [66, true], "aps.14.34": [66, true], "aps.14.35": [66, true], "aps.14.36": [66, true], "aps.14.37": [66, true], "aps.14.38": [66, true], "aps.14.39": [66, true], "aps.15.00": [48, true], "aps.15.01": [48, true], "aps.15.02": [48, true], "aps.15.03": [49, true], "aps.15.04": [50, true], "aps.15.05": [54, true], "aps.15.06": [50, true], "aps.15.07": [49, true], "aps.15.08": [49, true], "aps.15.09": [51, true], "aps.15.10": [47, true], "aps.15.11": [49, true], "aps.15.12": [48, true], "aps.15.13": [51, true], "aps.15.14": [51, true], "aps.15.15": [47, true], "aps.15.16": [48, true], "aps.15.17": [47, true], "aps.15.18": [51, true], "aps.15.19": [44, true], "aps.15.20": [49, true], "aps.15.21": [47, true], "aps.15.22": [50, true], "aps.15.23": [50, true], "aps.15.24": [51, true], "aps.15.25": [49, true], "aps.15.26": [49, true], "aps.15.27": [47, true], "aps.15.28": [44, true], "aps.15.29": [47, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3727, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [60, true], "fun1.2": [58, true], "fun1.3": [63, true], "fun1.4": [72, true], "fun1.5": [88, true], "fun2.1": [52, true], "fun2.2": [75, true], "fun2.3": [79, true], "fun2.4": [94, true], "fun2.5": [101, true], "fun3.1": [51, true], "fun3.2": [51, true], "fun3.3": [59, true], "fun3.4": [65, true], "fun3.5": [46, true], "fun4.1": [62, true], "fun4.2": [64, true], "fun4.3": [79, true], "fun4.4": [87, true], "fun4.5": [105, true], "fun5.1": [69, true], "fun5.2": [70, true], "fun5.3": [72, true], "fun5.4": [73, true], "fun5.5": [74, true], "fun6.1": [61, true], "fun6.2": [62, true], "fun6.3": [65, true], "fun6.4": [66, true], "fun6.5": [71, true], "fun7.1": [10, false], "fun7.2": [8, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [17, false], "fun8.1": [60, true], "fun8.2": [61, true], "fun8.3": [68, true], "fun8.4": [68, true], "fun8.5": [69, true], "fun9.1": [58, true], "fun9.2": [61, true], "fun9.3": [60, true], "fun9.4": [65, true], "fun9.5": [63, true]}}}, {"label": "pure.cbrt.derived.step", "spec": ["pure", "cbrt", "derived", "step"], "APS": {"total": 9916, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [62, true], "aps.02.00": [63, true], "aps.02.01": [60, true], "aps.02.02": [62, true], "aps.02.03": [62, true], "aps.02.04": [64, true], "aps.02.05": [65, true], "aps.02.06": [63, true], "aps.02.07": [64, true], "aps.02.08": [60, true], "aps.02.09": [67, true], "aps.03.00": [67, true], "aps.03.01": [69, true], "aps.03.02": [58, true], "aps.04.00": [59, true], "aps.04.01": [61, true], "aps.04.02": [61, true], "aps.04.03": [62, true], "aps.04.04": [66, true], "aps.04.05": [61, true], "aps.04.06": [60, true], "aps.04.07": [62, true], "aps.04.08": [65, true], "aps.04.09": [65, true], "aps.04.10": [61, true], "aps.04.11": [63, true], "aps.04.12": [60, true], "aps.04.13": [63, true], "aps.05.00": [62, true], "aps.06.00": [57, true], "aps.06.01": [60, true], "aps.06.02": [59, true], "aps.06.03": [58, true], "aps.06.04": [59, true], "aps.06.05": [57, true], "aps.06.06": [56, true], "aps.06.07": [56, true], "aps.06.08": [55, true], "aps.06.09": [53, true], "aps.07.00": [61, true], "aps.07.01": [56, true], "aps.07.02": [56, true], "aps.08.00": [3, true], "aps.08.01": [59, true], "aps.08.02": [59, true], "aps.08.03": [58, true], "aps.08.04": [60, true], "aps.09.00": [55, true], "aps.09.01": [62, true], "aps.09.02": [61, true], "aps.09.03": [57, true], "aps.09.04": [52, true], "aps.09.05": [50, true], "aps.09.06": [46, true], "aps.10.00": [57, true], "aps.10.01": [57, true], "aps.10.02": [57, true], "aps.10.03": [55, true], "aps.10.04": [57, true], "aps.11.00": [58, true], "aps.11.01": [58, true], "aps.11.02": [60, true], "aps.11.03": [61, true], "aps.12.00": [55, true], "aps.12.01": [63, true], "aps.12.02": [64, true], "aps.12.03": [63, true], "aps.12.04": [65, true], "aps.12.05": [68, true], "aps.12.06": [67, true], "aps.12.07": [68, true], "aps.12.08": [69, true], "aps.12.09": [71, true], "aps.12.10": [66, true], "aps.12.11": [68, true], "aps.12.12": [68, true], "aps.12.13": [66, true], "aps.12.14": [65, true], "aps.12.15": [67, true], "aps.12.16": [67, true], "aps.12.17": [68, true], "aps.12.18": [65, true], "aps.13.00": [10, false], "aps.14.00": [70, true], "aps.14.01": [70, true], "aps.14.02": [70, true], "aps.14.03": [70, true], "aps.14.04": [70, true], "aps.14.05": [70, true], "aps.14.06": [70, true], "aps.14.07": [70, true], "aps.14.08": [70, true], "aps.14.09": [70, true], "aps.14.10": [70, true], "aps.14.11": [70, true], "aps.14.12": [70, true], "aps.14.13": [70, true], "aps.14.14": [70, true], "aps.14.15": [70, true], "aps.14.16": [70, true], "aps.14.17": [70, true], "aps.14.18": [70, true], "aps.14.19": [70, true], "aps.14.20": [70, true], "aps.14.21": [70, true], "aps.14.22": [70, true], "aps.14.23": [70, true], "aps.14.24": [70, true], "aps.14.25": [70, true], "aps.14.26": [70, true], "aps.14.27": [70, true], "aps.14.28": [70, true], "aps.14.29": [70, true], "aps.14.30": [70, true], "aps.14.31": [70, true], "aps.14.32": [70, true], "aps.14.33": [70, true], "aps.14.34": [70, true], "aps.14.35": [70, true], "aps.14.36": [70, true], "aps.14.37": [70, true], "aps.14.38": [70, true], "aps.14.39": [70, true], "aps.15.00": [65, true], "aps.15.01": [65, true], "aps.15.02": [64, true], "aps.15.03": [65, true], "aps.15.04": [64, true], "aps.15.05": [64, true], "aps.15.06": [65, true], "aps.15.07": [62, true], "aps.15.08": [62, true], "aps.15.09": [62, true], "aps.15.10": [58, true], "aps.15.11": [62, true], "aps.15.12": [64, true], "aps.15.13": [65, true], "aps.15.14": [63, true], "aps.15.15": [66, true], "aps.15.16": [66, true], "aps.15.17": [66, true], "aps.15.18": [65, true], "aps.15.19": [59, true], "aps.15.20": [62, true], "aps.15.21": [61, true], "aps.15.22": [63, true], "aps.15.23": [66, true], "aps.15.24": [64, true], "aps.15.25": [58, true], "aps.15.26": [61, true], "aps.15.27": [63, true], "aps.15.28": [61, true], "aps.15.29": [65, true], "aps.15.30": [65, true]}}, "CHA": {"total": 3240, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [61, true], "fun1.3": [62, true], "fun1.4": [69, true], "fun1.5": [83, true], "fun2.1": [57, true], "fun2.2": [75, true], "fun2.3": [82, true], "fun2.4": [94, true], "fun2.5": [101, true], "fun3.1": [22, true], "fun3.2": [26, true], "fun3.3": [8, true], "fun3.4": [6, true], "fun3.5": [6, true], "fun4.1": [42, true], "fun4.2": [46, true], "fun4.3": [57, true], "fun4.4": [56, true], "fun4.5": [71, true], "fun5.1": [51, true], "fun5.2": [59, true], "fun5.3": [51, true], "fun5.4": [52, true], "fun5.5": [54, true], "fun6.1": [46, true], "fun6.2": [56, true], "fun6.3": [46, true], "fun6.4": [54, true], "fun6.5": [55, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [15, false], "fun7.5": [21, false], "fun8.1": [64, true], "fun8.2": [62, true], "fun8.3": [64, true], "fun8.4": [67, true], "fun8.5": [70, true], "fun9.1": [58, true], "fun9.2": [58, true], "fun9.3": [62, true], "fun9.4": [62, true], "fun9.5": [67, true]}}}, {"label": "pure.cbrt.derived3.credit", "spec": ["pure", "cbrt", "derived3", "credit"], "APS": {"total": 7708, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [43, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [5, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [39, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3016, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [32, true], "fun3.2": [32, true], "fun3.3": [34, true], "fun3.4": [37, true], "fun3.5": [45, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [5, false], "fun7.2": [9, false], "fun7.3": [7, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.cbrt.derived3.project", "spec": ["pure", "cbrt", "derived3", "project"], "APS": {"total": 13894, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [88, true], "aps.02.02": [89, true], "aps.02.03": [91, true], "aps.02.04": [90, true], "aps.02.05": [90, true], "aps.02.06": [91, true], "aps.02.07": [91, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [89, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [89, true], "aps.04.07": [89, true], "aps.04.08": [88, true], "aps.04.09": [89, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [82, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [83, true], "aps.08.02": [82, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [83, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [73, true], "aps.09.06": [62, true], "aps.10.00": [82, true], "aps.10.01": [83, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [83, true], "aps.11.01": [83, true], "aps.11.02": [82, true], "aps.11.03": [82, true], "aps.12.00": [97, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [96, true], "aps.12.06": [97, true], "aps.12.07": [96, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [96, true], "aps.12.11": [94, true], "aps.12.12": [97, true], "aps.12.13": [97, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [96, true], "aps.12.18": [97, true], "aps.13.00": [21, false], "aps.14.00": [100, true], "aps.14.01": [100, true], "aps.14.02": [100, true], "aps.14.03": [100, true], "aps.14.04": [100, true], "aps.14.05": [100, true], "aps.14.06": [100, true], "aps.14.07": [100, true], "aps.14.08": [100, true], "aps.14.09": [100, true], "aps.14.10": [100, true], "aps.14.11": [100, true], "aps.14.12": [100, true], "aps.14.13": [100, true], "aps.14.14": [100, true], "aps.14.15": [100, true], "aps.14.16": [100, true], "aps.14.17": [100, true], "aps.14.18": [100, true], "aps.14.19": [100, true], "aps.14.20": [100, true], "aps.14.21": [100, true], "aps.14.22": [100, true], "aps.14.23": [100, true], "aps.14.24": [100, true], "aps.14.25": [100, true], "aps.14.26": [100, true], "aps.14.27": [100, true], "aps.14.28": [100, true], "aps.14.29": [100, true], "aps.14.30": [100, true], "aps.14.31": [100, true], "aps.14.32": [100, true], "aps.14.33": [100, true], "aps.14.34": [100, true], "aps.14.35": [100, true], "aps.14.36": [100, true], "aps.14.37": [100, true], "aps.14.38": [100, true], "aps.14.39": [100, true], "aps.15.00": [86, true], "aps.15.01": [85, true], "aps.15.02": [85, true], "aps.15.03": [84, true], "aps.15.04": [83, true], "aps.15.05": [81, true], "aps.15.06": [79, true], "aps.15.07": [39, true], "aps.15.08": [80, true], "aps.15.09": [83, true], "aps.15.10": [83, true], "aps.15.11": [84, true], "aps.15.12": [84, true], "aps.15.13": [85, true], "aps.15.14": [85, true], "aps.15.15": [85, true], "aps.15.16": [85, true], "aps.15.17": [85, true], "aps.15.18": [85, true], "aps.15.19": [85, true], "aps.15.20": [84, true], "aps.15.21": [81, true], "aps.15.22": [81, true], "aps.15.23": [79, true], "aps.15.24": [73, true], "aps.15.25": [78, true], "aps.15.26": [81, true], "aps.15.27": [81, true], "aps.15.28": [72, true], "aps.15.29": [78, true], "aps.15.30": [79, true]}}, "CHA": {"total": 4099, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [106, true], "fun1.5": [122, true], "fun2.1": [82, true], "fun2.2": [107, true], "fun2.3": [123, true], "fun2.4": [128, true], "fun2.5": [146, true], "fun3.1": [22, true], "fun3.2": [23, true], "fun3.3": [32, true], "fun3.4": [38, true], "fun3.5": [46, true], "fun4.1": [32, true], "fun4.2": [32, true], "fun4.3": [40, true], "fun4.4": [47, true], "fun4.5": [59, true], "fun5.1": [67, true], "fun5.2": [62, true], "fun5.3": [55, true], "fun5.4": [61, true], "fun5.5": [61, true], "fun6.1": [88, true], "fun6.2": [79, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [21, false], "fun7.2": [9, false], "fun7.3": [23, false], "fun7.4": [65, false], "fun7.5": [16, false], "fun8.1": [84, true], "fun8.2": [87, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [97, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [87, true], "fun9.5": [96, true]}}}, {"label": "pure.cosine.start.bracket", "spec": ["pure", "cosine", "start", "bracket"], "APS": {"total": 10304, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [59, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [87, true], "aps.03.01": [58, true], "aps.03.02": [48, true], "aps.04.00": [59, true], "aps.04.01": [58, true], "aps.04.02": [59, true], "aps.04.03": [59, true], "aps.04.04": [59, true], "aps.04.05": [61, true], "aps.04.06": [61, true], "aps.04.07": [61, true], "aps.04.08": [60, true], "aps.04.09": [61, true], "aps.04.10": [61, true], "aps.04.11": [62, true], "aps.04.12": [60, true], "aps.04.13": [62, true], "aps.05.00": [60, true], "aps.06.00": [60, true], "aps.06.01": [60, true], "aps.06.02": [59, true], "aps.06.03": [59, true], "aps.06.04": [59, true], "aps.06.05": [60, true], "aps.06.06": [60, true], "aps.06.07": [60, true], "aps.06.08": [59, true], "aps.06.09": [60, true], "aps.07.00": [57, true], "aps.07.01": [55, true], "aps.07.02": [54, true], "aps.08.00": [60, true], "aps.08.01": [59, true], "aps.08.02": [58, true], "aps.08.03": [58, true], "aps.08.04": [59, true], "aps.09.00": [57, true], "aps.09.01": [57, true], "aps.09.02": [55, true], "aps.09.03": [53, true], "aps.09.04": [50, true], "aps.09.05": [46, true], "aps.09.06": [43, true], "aps.10.00": [60, true], "aps.10.01": [58, true], "aps.10.02": [56, true], "aps.10.03": [54, true], "aps.10.04": [51, true], "aps.11.00": [59, true], "aps.11.01": [61, true], "aps.11.02": [60, true], "aps.11.03": [62, true], "aps.12.00": [63, true], "aps.12.01": [64, true], "aps.12.02": [65, true], "aps.12.03": [66, true], "aps.12.04": [65, true], "aps.12.05": [66, true], "aps.12.06": [66, true], "aps.12.07": [61, true], "aps.12.08": [66, true], "aps.12.09": [67, true], "aps.12.10": [65, true], "aps.12.11": [66, true], "aps.12.12": [65, true], "aps.12.13": [65, true], "aps.12.14": [66, true], "aps.12.15": [66, true], "aps.12.16": [66, true], "aps.12.17": [66, true], "aps.12.18": [66, true], "aps.13.00": [9, false], "aps.14.00": [73, true], "aps.14.01": [73, true], "aps.14.02": [73, true], "aps.14.03": [73, true], "aps.14.04": [73, true], "aps.14.05": [73, true], "aps.14.06": [73, true], "aps.14.07": [73, true], "aps.14.08": [73, true], "aps.14.09": [73, true], "aps.14.10": [73, true], "aps.14.11": [73, true], "aps.14.12": [73, true], "aps.14.13": [73, true], "aps.14.14": [73, true], "aps.14.15": [73, true], "aps.14.16": [73, true], "aps.14.17": [73, true], "aps.14.18": [73, true], "aps.14.19": [73, true], "aps.14.20": [73, true], "aps.14.21": [73, true], "aps.14.22": [73, true], "aps.14.23": [73, true], "aps.14.24": [73, true], "aps.14.25": [73, true], "aps.14.26": [73, true], "aps.14.27": [73, true], "aps.14.28": [73, true], "aps.14.29": [73, true], "aps.14.30": [73, true], "aps.14.31": [73, true], "aps.14.32": [73, true], "aps.14.33": [73, true], "aps.14.34": [73, true], "aps.14.35": [73, true], "aps.14.36": [73, true], "aps.14.37": [73, true], "aps.14.38": [73, true], "aps.14.39": [73, true], "aps.15.00": [77, true], "aps.15.01": [77, true], "aps.15.02": [77, true], "aps.15.03": [78, true], "aps.15.04": [78, true], "aps.15.05": [78, true], "aps.15.06": [77, true], "aps.15.07": [78, true], "aps.15.08": [77, true], "aps.15.09": [78, true], "aps.15.10": [77, true], "aps.15.11": [78, true], "aps.15.12": [77, true], "aps.15.13": [77, true], "aps.15.14": [78, true], "aps.15.15": [78, true], "aps.15.16": [78, true], "aps.15.17": [78, true], "aps.15.18": [77, true], "aps.15.19": [77, true], "aps.15.20": [78, true], "aps.15.21": [78, true], "aps.15.22": [78, true], "aps.15.23": [75, true], "aps.15.24": [75, true], "aps.15.25": [73, true], "aps.15.26": [78, true], "aps.15.27": [78, true], "aps.15.28": [73, true], "aps.15.29": [76, true], "aps.15.30": [77, true]}}, "CHA": {"total": 3515, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [57, true], "fun1.2": [62, true], "fun1.3": [68, true], "fun1.4": [64, true], "fun1.5": [85, true], "fun2.1": [59, true], "fun2.2": [78, true], "fun2.3": [85, true], "fun2.4": [102, true], "fun2.5": [113, true], "fun3.1": [50, true], "fun3.2": [54, true], "fun3.3": [64, true], "fun3.4": [72, true], "fun3.5": [85, true], "fun4.1": [49, true], "fun4.2": [51, true], "fun4.3": [60, true], "fun4.4": [67, true], "fun4.5": [80, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [49, true], "fun5.4": [51, true], "fun5.5": [52, true], "fun6.1": [45, true], "fun6.2": [45, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [9, false], "fun7.4": [12, false], "fun7.5": [14, false], "fun8.1": [60, true], "fun8.2": [60, true], "fun8.3": [63, true], "fun8.4": [66, true], "fun8.5": [68, true], "fun9.1": [58, true], "fun9.2": [60, true], "fun9.3": [62, true], "fun9.4": [64, true], "fun9.5": [69, true]}}}, {"label": "pure.cosine.start.both", "spec": ["pure", "cosine", "start", "both"], "APS": {"total": 9753, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [54, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [88, true], "aps.03.01": [58, true], "aps.03.02": [48, true], "aps.04.00": [53, true], "aps.04.01": [58, true], "aps.04.02": [54, true], "aps.04.03": [56, true], "aps.04.04": [54, true], "aps.04.05": [54, true], "aps.04.06": [55, true], "aps.04.07": [55, true], "aps.04.08": [54, true], "aps.04.09": [56, true], "aps.04.10": [57, true], "aps.04.11": [54, true], "aps.04.12": [57, true], "aps.04.13": [56, true], "aps.05.00": [57, true], "aps.06.00": [54, true], "aps.06.01": [54, true], "aps.06.02": [54, true], "aps.06.03": [54, true], "aps.06.04": [55, true], "aps.06.05": [55, true], "aps.06.06": [54, true], "aps.06.07": [51, true], "aps.06.08": [54, true], "aps.06.09": [55, true], "aps.07.00": [53, true], "aps.07.01": [52, true], "aps.07.02": [49, true], "aps.08.00": [56, true], "aps.08.01": [57, true], "aps.08.02": [53, true], "aps.08.03": [55, true], "aps.08.04": [53, true], "aps.09.00": [52, true], "aps.09.01": [53, true], "aps.09.02": [51, true], "aps.09.03": [48, true], "aps.09.04": [44, true], "aps.09.05": [42, true], "aps.09.06": [39, true], "aps.10.00": [57, true], "aps.10.01": [54, true], "aps.10.02": [53, true], "aps.10.03": [51, true], "aps.10.04": [50, true], "aps.11.00": [55, true], "aps.11.01": [54, true], "aps.11.02": [56, true], "aps.11.03": [56, true], "aps.12.00": [56, true], "aps.12.01": [57, true], "aps.12.02": [57, true], "aps.12.03": [60, true], "aps.12.04": [61, true], "aps.12.05": [62, true], "aps.12.06": [64, true], "aps.12.07": [61, true], "aps.12.08": [64, true], "aps.12.09": [61, true], "aps.12.10": [61, true], "aps.12.11": [59, true], "aps.12.12": [61, true], "aps.12.13": [60, true], "aps.12.14": [61, true], "aps.12.15": [60, true], "aps.12.16": [60, true], "aps.12.17": [62, true], "aps.12.18": [61, true], "aps.13.00": [9, false], "aps.14.00": [71, true], "aps.14.01": [71, true], "aps.14.02": [71, true], "aps.14.03": [71, true], "aps.14.04": [71, true], "aps.14.05": [71, true], "aps.14.06": [71, true], "aps.14.07": [71, true], "aps.14.08": [71, true], "aps.14.09": [71, true], "aps.14.10": [71, true], "aps.14.11": [71, true], "aps.14.12": [71, true], "aps.14.13": [71, true], "aps.14.14": [71, true], "aps.14.15": [71, true], "aps.14.16": [71, true], "aps.14.17": [71, true], "aps.14.18": [71, true], "aps.14.19": [71, true], "aps.14.20": [71, true], "aps.14.21": [71, true], "aps.14.22": [71, true], "aps.14.23": [71, true], "aps.14.24": [71, true], "aps.14.25": [71, true], "aps.14.26": [71, true], "aps.14.27": [71, true], "aps.14.28": [71, true], "aps.14.29": [71, true], "aps.14.30": [71, true], "aps.14.31": [71, true], "aps.14.32": [71, true], "aps.14.33": [71, true], "aps.14.34": [71, true], "aps.14.35": [71, true], "aps.14.36": [71, true], "aps.14.37": [71, true], "aps.14.38": [71, true], "aps.14.39": [71, true], "aps.15.00": [70, true], "aps.15.01": [70, true], "aps.15.02": [72, true], "aps.15.03": [72, true], "aps.15.04": [72, true], "aps.15.05": [71, true], "aps.15.06": [75, true], "aps.15.07": [74, true], "aps.15.08": [73, true], "aps.15.09": [74, true], "aps.15.10": [73, true], "aps.15.11": [71, true], "aps.15.12": [74, true], "aps.15.13": [72, true], "aps.15.14": [74, true], "aps.15.15": [72, true], "aps.15.16": [75, true], "aps.15.17": [73, true], "aps.15.18": [69, true], "aps.15.19": [73, true], "aps.15.20": [73, true], "aps.15.21": [75, true], "aps.15.22": [76, true], "aps.15.23": [70, true], "aps.15.24": [70, true], "aps.15.25": [70, true], "aps.15.26": [74, true], "aps.15.27": [73, true], "aps.15.28": [69, true], "aps.15.29": [69, true], "aps.15.30": [74, true]}}, "CHA": {"total": 3413, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [51, true], "fun1.2": [55, true], "fun1.3": [66, true], "fun1.4": [62, true], "fun1.5": [83, true], "fun2.1": [56, true], "fun2.2": [71, true], "fun2.3": [82, true], "fun2.4": [98, true], "fun2.5": [110, true], "fun3.1": [50, true], "fun3.2": [53, true], "fun3.3": [63, true], "fun3.4": [69, true], "fun3.5": [82, true], "fun4.1": [48, true], "fun4.2": [50, true], "fun4.3": [59, true], "fun4.4": [66, true], "fun4.5": [79, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [48, true], "fun5.4": [50, true], "fun5.5": [51, true], "fun6.1": [45, true], "fun6.2": [45, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [9, false], "fun7.4": [49, false], "fun7.5": [13, false], "fun8.1": [56, true], "fun8.2": [57, true], "fun8.3": [58, true], "fun8.4": [60, true], "fun8.5": [61, true], "fun9.1": [55, true], "fun9.2": [55, true], "fun9.3": [56, true], "fun9.4": [60, true], "fun9.5": [65, true]}}}, {"label": "pure.cosine.start.none", "spec": ["pure", "cosine", "start", "none"], "APS": {"total": 29111, "solved": 11, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [49, true], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 8542, "solved": 3, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [45, true], "fun6.4": [48, true], "fun6.5": [49, true], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.cosine.start.step", "spec": ["pure", "cosine", "start", "step"], "APS": {"total": 12536, "solved": 153, "n": 154, "over": 11, "per": {"aps.01.00": [69, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [90, true], "aps.03.01": [59, true], "aps.03.02": [48, true], "aps.04.00": [70, true], "aps.04.01": [73, true], "aps.04.02": [68, true], "aps.04.03": [72, true], "aps.04.04": [71, true], "aps.04.05": [76, true], "aps.04.06": [74, true], "aps.04.07": [78, true], "aps.04.08": [76, true], "aps.04.09": [73, true], "aps.04.10": [71, true], "aps.04.11": [72, true], "aps.04.12": [72, true], "aps.04.13": [68, true], "aps.05.00": [72, true], "aps.06.00": [68, true], "aps.06.01": [70, true], "aps.06.02": [68, true], "aps.06.03": [65, true], "aps.06.04": [69, true], "aps.06.05": [72, true], "aps.06.06": [72, true], "aps.06.07": [72, true], "aps.06.08": [73, true], "aps.06.09": [75, true], "aps.07.00": [68, true], "aps.07.01": [70, true], "aps.07.02": [64, true], "aps.08.00": [73, true], "aps.08.01": [70, true], "aps.08.02": [66, true], "aps.08.03": [70, true], "aps.08.04": [68, true], "aps.09.00": [66, true], "aps.09.01": [73, true], "aps.09.02": [66, true], "aps.09.03": [62, true], "aps.09.04": [59, true], "aps.09.05": [55, true], "aps.09.06": [53, true], "aps.10.00": [68, true], "aps.10.01": [69, true], "aps.10.02": [64, true], "aps.10.03": [59, true], "aps.10.04": [58, true], "aps.11.00": [69, true], "aps.11.01": [69, true], "aps.11.02": [69, true], "aps.11.03": [77, true], "aps.12.00": [74, true], "aps.12.01": [76, true], "aps.12.02": [76, true], "aps.12.03": [77, true], "aps.12.04": [76, true], "aps.12.05": [79, true], "aps.12.06": [76, true], "aps.12.07": [73, true], "aps.12.08": [72, true], "aps.12.09": [79, true], "aps.12.10": [76, true], "aps.12.11": [77, true], "aps.12.12": [73, true], "aps.12.13": [76, true], "aps.12.14": [80, true], "aps.12.15": [76, true], "aps.12.16": [76, true], "aps.12.17": [76, true], "aps.12.18": [76, true], "aps.13.00": [11, false], "aps.14.00": [90, true], "aps.14.01": [90, true], "aps.14.02": [90, true], "aps.14.03": [90, true], "aps.14.04": [90, true], "aps.14.05": [90, true], "aps.14.06": [90, true], "aps.14.07": [90, true], "aps.14.08": [90, true], "aps.14.09": [90, true], "aps.14.10": [90, true], "aps.14.11": [90, true], "aps.14.12": [90, true], "aps.14.13": [90, true], "aps.14.14": [90, true], "aps.14.15": [90, true], "aps.14.16": [90, true], "aps.14.17": [90, true], "aps.14.18": [90, true], "aps.14.19": [90, true], "aps.14.20": [90, true], "aps.14.21": [90, true], "aps.14.22": [90, true], "aps.14.23": [90, true], "aps.14.24": [90, true], "aps.14.25": [90, true], "aps.14.26": [90, true], "aps.14.27": [90, true], "aps.14.28": [90, true], "aps.14.29": [90, true], "aps.14.30": [90, true], "aps.14.31": [90, true], "aps.14.32": [90, true], "aps.14.33": [90, true], "aps.14.34": [90, true], "aps.14.35": [90, true], "aps.14.36": [90, true], "aps.14.37": [90, true], "aps.14.38": [90, true], "aps.14.39": [90, true], "aps.15.00": [103, true], "aps.15.01": [100, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [103, true], "aps.15.05": [103, true], "aps.15.06": [102, true], "aps.15.07": [101, true], "aps.15.08": [101, true], "aps.15.09": [102, true], "aps.15.10": [103, true], "aps.15.11": [106, true], "aps.15.12": [106, true], "aps.15.13": [105, true], "aps.15.14": [102, true], "aps.15.15": [102, true], "aps.15.16": [107, true], "aps.15.17": [107, true], "aps.15.18": [105, true], "aps.15.19": [103, true], "aps.15.20": [105, true], "aps.15.21": [103, true], "aps.15.22": [100, true], "aps.15.23": [93, true], "aps.15.24": [105, true], "aps.15.25": [105, true], "aps.15.26": [105, true], "aps.15.27": [106, true], "aps.15.28": [103, true], "aps.15.29": [101, true], "aps.15.30": [96, true]}}, "CHA": {"total": 3858, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [64, true], "fun1.2": [72, true], "fun1.3": [77, true], "fun1.4": [70, true], "fun1.5": [90, true], "fun2.1": [72, true], "fun2.2": [100, true], "fun2.3": [115, true], "fun2.4": [142, true], "fun2.5": [153, true], "fun3.1": [53, true], "fun3.2": [59, true], "fun3.3": [70, true], "fun3.4": [77, true], "fun3.5": [90, true], "fun4.1": [51, true], "fun4.2": [53, true], "fun4.3": [63, true], "fun4.4": [70, true], "fun4.5": [83, true], "fun5.1": [48, true], "fun5.2": [47, true], "fun5.3": [49, true], "fun5.4": [51, true], "fun5.5": [52, true], "fun6.1": [46, true], "fun6.2": [45, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [62, false], "fun7.4": [14, false], "fun7.5": [17, false], "fun8.1": [75, true], "fun8.2": [72, true], "fun8.3": [76, true], "fun8.4": [81, true], "fun8.5": [79, true], "fun9.1": [68, true], "fun9.2": [71, true], "fun9.3": [70, true], "fun9.4": [79, true], "fun9.5": [79, true]}}}, {"label": "pure.cbrt.derived3.safe", "spec": ["pure", "cbrt", "derived3", "safe"], "APS": {"total": 9219, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [57, true], "aps.02.00": [62, true], "aps.02.01": [62, true], "aps.02.02": [63, true], "aps.02.03": [64, true], "aps.02.04": [66, true], "aps.02.05": [63, true], "aps.02.06": [64, true], "aps.02.07": [66, true], "aps.02.08": [61, true], "aps.02.09": [64, true], "aps.03.00": [67, true], "aps.03.01": [64, true], "aps.03.02": [65, true], "aps.04.00": [57, true], "aps.04.01": [64, true], "aps.04.02": [56, true], "aps.04.03": [65, true], "aps.04.04": [64, true], "aps.04.05": [58, true], "aps.04.06": [63, true], "aps.04.07": [62, true], "aps.04.08": [65, true], "aps.04.09": [65, true], "aps.04.10": [61, true], "aps.04.11": [61, true], "aps.04.12": [62, true], "aps.04.13": [65, true], "aps.05.00": [60, true], "aps.06.00": [57, true], "aps.06.01": [59, true], "aps.06.02": [60, true], "aps.06.03": [61, true], "aps.06.04": [61, true], "aps.06.05": [61, true], "aps.06.06": [58, true], "aps.06.07": [54, true], "aps.06.08": [62, true], "aps.06.09": [62, true], "aps.07.00": [56, true], "aps.07.01": [59, true], "aps.07.02": [59, true], "aps.08.00": [3, true], "aps.08.01": [57, true], "aps.08.02": [58, true], "aps.08.03": [58, true], "aps.08.04": [56, true], "aps.09.00": [58, true], "aps.09.01": [59, true], "aps.09.02": [58, true], "aps.09.03": [58, true], "aps.09.04": [50, true], "aps.09.05": [51, true], "aps.09.06": [44, true], "aps.10.00": [60, true], "aps.10.01": [56, true], "aps.10.02": [56, true], "aps.10.03": [57, true], "aps.10.04": [59, true], "aps.11.00": [60, true], "aps.11.01": [60, true], "aps.11.02": [55, true], "aps.11.03": [60, true], "aps.12.00": [67, true], "aps.12.01": [66, true], "aps.12.02": [68, true], "aps.12.03": [66, true], "aps.12.04": [67, true], "aps.12.05": [68, true], "aps.12.06": [70, true], "aps.12.07": [69, true], "aps.12.08": [69, true], "aps.12.09": [65, true], "aps.12.10": [65, true], "aps.12.11": [69, true], "aps.12.12": [66, true], "aps.12.13": [66, true], "aps.12.14": [64, true], "aps.12.15": [67, true], "aps.12.16": [70, true], "aps.12.17": [70, true], "aps.12.18": [69, true], "aps.13.00": [12, false], "aps.14.00": [62, true], "aps.14.01": [62, true], "aps.14.02": [62, true], "aps.14.03": [62, true], "aps.14.04": [62, true], "aps.14.05": [62, true], "aps.14.06": [62, true], "aps.14.07": [62, true], "aps.14.08": [62, true], "aps.14.09": [62, true], "aps.14.10": [62, true], "aps.14.11": [62, true], "aps.14.12": [62, true], "aps.14.13": [62, true], "aps.14.14": [62, true], "aps.14.15": [62, true], "aps.14.16": [62, true], "aps.14.17": [62, true], "aps.14.18": [62, true], "aps.14.19": [62, true], "aps.14.20": [62, true], "aps.14.21": [62, true], "aps.14.22": [62, true], "aps.14.23": [62, true], "aps.14.24": [62, true], "aps.14.25": [62, true], "aps.14.26": [62, true], "aps.14.27": [62, true], "aps.14.28": [62, true], "aps.14.29": [62, true], "aps.14.30": [62, true], "aps.14.31": [62, true], "aps.14.32": [62, true], "aps.14.33": [62, true], "aps.14.34": [62, true], "aps.14.35": [62, true], "aps.14.36": [62, true], "aps.14.37": [62, true], "aps.14.38": [62, true], "aps.14.39": [62, true], "aps.15.00": [51, true], "aps.15.01": [50, true], "aps.15.02": [52, true], "aps.15.03": [50, true], "aps.15.04": [50, true], "aps.15.05": [46, true], "aps.15.06": [48, true], "aps.15.07": [50, true], "aps.15.08": [50, true], "aps.15.09": [51, true], "aps.15.10": [52, true], "aps.15.11": [50, true], "aps.15.12": [48, true], "aps.15.13": [52, true], "aps.15.14": [50, true], "aps.15.15": [49, true], "aps.15.16": [50, true], "aps.15.17": [49, true], "aps.15.18": [49, true], "aps.15.19": [50, true], "aps.15.20": [52, true], "aps.15.21": [48, true], "aps.15.22": [46, true], "aps.15.23": [47, true], "aps.15.24": [50, true], "aps.15.25": [50, true], "aps.15.26": [51, true], "aps.15.27": [49, true], "aps.15.28": [51, true], "aps.15.29": [49, true], "aps.15.30": [50, true]}}, "CHA": {"total": 3724, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [61, true], "fun1.2": [58, true], "fun1.3": [59, true], "fun1.4": [65, true], "fun1.5": [72, true], "fun2.1": [58, true], "fun2.2": [78, true], "fun2.3": [82, true], "fun2.4": [92, true], "fun2.5": [100, true], "fun3.1": [25, true], "fun3.2": [20, true], "fun3.3": [21, true], "fun3.4": [16, true], "fun3.5": [27, true], "fun4.1": [54, true], "fun4.2": [58, true], "fun4.3": [70, true], "fun4.4": [77, true], "fun4.5": [85, true], "fun5.1": [87, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [81, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [12, false], "fun7.2": [11, false], "fun7.3": [11, false], "fun7.4": [16, false], "fun7.5": [19, false], "fun8.1": [63, true], "fun8.2": [63, true], "fun8.3": [64, true], "fun8.4": [69, true], "fun8.5": [70, true], "fun9.1": [56, true], "fun9.2": [60, true], "fun9.3": [60, true], "fun9.4": [67, true], "fun9.5": [70, true]}}}, {"label": "pure.cosine.start.credit", "spec": ["pure", "cosine", "start", "credit"], "APS": {"total": 7671, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [44, true], "aps.02.01": [46, true], "aps.02.02": [45, true], "aps.02.03": [45, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [46, true], "aps.02.09": [46, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [8, false], "fun7.4": [10, false], "fun7.5": [14, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.cbrt.derived.project", "spec": ["pure", "cbrt", "derived", "project"], "APS": {"total": 14129, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [91, true], "aps.02.04": [91, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [91, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [89, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [89, true], "aps.04.07": [88, true], "aps.04.08": [89, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [89, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [83, true], "aps.06.06": [83, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [82, true], "aps.07.00": [83, true], "aps.07.01": [83, true], "aps.07.02": [81, true], "aps.08.00": [82, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [82, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [82, true], "aps.09.02": [82, true], "aps.09.03": [82, true], "aps.09.04": [80, true], "aps.09.05": [70, true], "aps.09.06": [66, true], "aps.10.00": [82, true], "aps.10.01": [83, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [83, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [78, true], "aps.12.01": [96, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [96, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [96, true], "aps.12.12": [96, true], "aps.12.13": [97, true], "aps.12.14": [97, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [97, true], "aps.12.18": [96, true], "aps.13.00": [16, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [91, true], "aps.15.01": [91, true], "aps.15.02": [91, true], "aps.15.03": [91, true], "aps.15.04": [91, true], "aps.15.05": [91, true], "aps.15.06": [91, true], "aps.15.07": [91, true], "aps.15.08": [91, true], "aps.15.09": [91, true], "aps.15.10": [91, true], "aps.15.11": [91, true], "aps.15.12": [90, true], "aps.15.13": [90, true], "aps.15.14": [90, true], "aps.15.15": [90, true], "aps.15.16": [90, true], "aps.15.17": [89, true], "aps.15.18": [89, true], "aps.15.19": [89, true], "aps.15.20": [88, true], "aps.15.21": [82, true], "aps.15.22": [78, true], "aps.15.23": [80, true], "aps.15.24": [78, true], "aps.15.25": [79, true], "aps.15.26": [77, true], "aps.15.27": [74, true], "aps.15.28": [72, true], "aps.15.29": [76, true], "aps.15.30": [76, true]}}, "CHA": {"total": 3979, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [112, true], "fun1.5": [93, true], "fun2.1": [83, true], "fun2.2": [109, true], "fun2.3": [118, true], "fun2.4": [134, true], "fun2.5": [139, true], "fun3.1": [26, true], "fun3.2": [26, true], "fun3.3": [32, true], "fun3.4": [35, true], "fun3.5": [40, true], "fun4.1": [36, true], "fun4.2": [36, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [81, true], "fun5.1": [54, true], "fun5.2": [55, true], "fun5.3": [50, true], "fun5.4": [52, true], "fun5.5": [53, true], "fun6.1": [59, true], "fun6.2": [61, true], "fun6.3": [58, true], "fun6.4": [71, true], "fun6.5": [75, true], "fun7.1": [16, false], "fun7.2": [20, false], "fun7.3": [10, false], "fun7.4": [12, false], "fun7.5": [25, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [97, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [93, true], "fun9.5": [97, true]}}}, {"label": "pure.cosine.start.safe", "spec": ["pure", "cosine", "start", "safe"], "APS": {"total": 12447, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [69, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [90, true], "aps.03.01": [59, true], "aps.03.02": [48, true], "aps.04.00": [70, true], "aps.04.01": [73, true], "aps.04.02": [68, true], "aps.04.03": [72, true], "aps.04.04": [71, true], "aps.04.05": [76, true], "aps.04.06": [74, true], "aps.04.07": [78, true], "aps.04.08": [76, true], "aps.04.09": [73, true], "aps.04.10": [71, true], "aps.04.11": [72, true], "aps.04.12": [72, true], "aps.04.13": [68, true], "aps.05.00": [72, true], "aps.06.00": [68, true], "aps.06.01": [70, true], "aps.06.02": [68, true], "aps.06.03": [65, true], "aps.06.04": [69, true], "aps.06.05": [72, true], "aps.06.06": [72, true], "aps.06.07": [72, true], "aps.06.08": [73, true], "aps.06.09": [75, true], "aps.07.00": [68, true], "aps.07.01": [70, true], "aps.07.02": [64, true], "aps.08.00": [73, true], "aps.08.01": [70, true], "aps.08.02": [66, true], "aps.08.03": [70, true], "aps.08.04": [68, true], "aps.09.00": [66, true], "aps.09.01": [73, true], "aps.09.02": [66, true], "aps.09.03": [62, true], "aps.09.04": [59, true], "aps.09.05": [55, true], "aps.09.06": [53, true], "aps.10.00": [68, true], "aps.10.01": [69, true], "aps.10.02": [64, true], "aps.10.03": [59, true], "aps.10.04": [58, true], "aps.11.00": [69, true], "aps.11.01": [69, true], "aps.11.02": [69, true], "aps.11.03": [77, true], "aps.12.00": [74, true], "aps.12.01": [76, true], "aps.12.02": [76, true], "aps.12.03": [77, true], "aps.12.04": [76, true], "aps.12.05": [79, true], "aps.12.06": [76, true], "aps.12.07": [73, true], "aps.12.08": [72, true], "aps.12.09": [79, true], "aps.12.10": [76, true], "aps.12.11": [77, true], "aps.12.12": [73, true], "aps.12.13": [76, true], "aps.12.14": [80, true], "aps.12.15": [76, true], "aps.12.16": [76, true], "aps.12.17": [76, true], "aps.12.18": [76, true], "aps.13.00": [11, false], "aps.14.00": [89, true], "aps.14.01": [89, true], "aps.14.02": [89, true], "aps.14.03": [89, true], "aps.14.04": [89, true], "aps.14.05": [89, true], "aps.14.06": [89, true], "aps.14.07": [89, true], "aps.14.08": [89, true], "aps.14.09": [89, true], "aps.14.10": [89, true], "aps.14.11": [89, true], "aps.14.12": [89, true], "aps.14.13": [89, true], "aps.14.14": [89, true], "aps.14.15": [89, true], "aps.14.16": [89, true], "aps.14.17": [89, true], "aps.14.18": [89, true], "aps.14.19": [89, true], "aps.14.20": [89, true], "aps.14.21": [89, true], "aps.14.22": [89, true], "aps.14.23": [89, true], "aps.14.24": [89, true], "aps.14.25": [89, true], "aps.14.26": [89, true], "aps.14.27": [89, true], "aps.14.28": [89, true], "aps.14.29": [89, true], "aps.14.30": [89, true], "aps.14.31": [89, true], "aps.14.32": [89, true], "aps.14.33": [89, true], "aps.14.34": [89, true], "aps.14.35": [89, true], "aps.14.36": [89, true], "aps.14.37": [89, true], "aps.14.38": [89, true], "aps.14.39": [89, true], "aps.15.00": [100, true], "aps.15.01": [99, true], "aps.15.02": [103, true], "aps.15.03": [102, true], "aps.15.04": [103, true], "aps.15.05": [103, true], "aps.15.06": [101, true], "aps.15.07": [100, true], "aps.15.08": [100, true], "aps.15.09": [101, true], "aps.15.10": [103, true], "aps.15.11": [103, true], "aps.15.12": [102, true], "aps.15.13": [103, true], "aps.15.14": [101, true], "aps.15.15": [101, true], "aps.15.16": [103, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [102, true], "aps.15.21": [103, true], "aps.15.22": [99, true], "aps.15.23": [92, true], "aps.15.24": [103, true], "aps.15.25": [101, true], "aps.15.26": [102, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [100, true], "aps.15.30": [95, true]}}, "CHA": {"total": 3852, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [64, true], "fun1.2": [72, true], "fun1.3": [77, true], "fun1.4": [70, true], "fun1.5": [90, true], "fun2.1": [72, true], "fun2.2": [100, true], "fun2.3": [115, true], "fun2.4": [142, true], "fun2.5": [147, true], "fun3.1": [53, true], "fun3.2": [59, true], "fun3.3": [70, true], "fun3.4": [77, true], "fun3.5": [90, true], "fun4.1": [51, true], "fun4.2": [53, true], "fun4.3": [63, true], "fun4.4": [70, true], "fun4.5": [83, true], "fun5.1": [48, true], "fun5.2": [47, true], "fun5.3": [49, true], "fun5.4": [51, true], "fun5.5": [52, true], "fun6.1": [46, true], "fun6.2": [45, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [64, false], "fun7.4": [14, false], "fun7.5": [17, false], "fun8.1": [75, true], "fun8.2": [72, true], "fun8.3": [76, true], "fun8.4": [81, true], "fun8.5": [79, true], "fun9.1": [68, true], "fun9.2": [71, true], "fun9.3": [70, true], "fun9.4": [79, true], "fun9.5": [79, true]}}}, {"label": "pure.cosine.start.project", "spec": ["pure", "cosine", "start", "project"], "APS": {"total": 14153, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [49, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [88, true], "aps.04.07": [89, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [89, true], "aps.04.11": [88, true], "aps.04.12": [89, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [83, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [82, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [82, true], "aps.07.00": [82, true], "aps.07.01": [82, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [83, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [97, true], "aps.12.01": [97, true], "aps.12.02": [96, true], "aps.12.03": [82, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [81, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [96, true], "aps.12.10": [80, true], "aps.12.11": [97, true], "aps.12.12": [95, true], "aps.12.13": [96, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [97, true], "aps.12.17": [97, true], "aps.12.18": [97, true], "aps.13.00": [52, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [103, true], "aps.15.01": [102, true], "aps.15.02": [102, true], "aps.15.03": [102, true], "aps.15.04": [103, true], "aps.15.05": [103, true], "aps.15.06": [103, true], "aps.15.07": [102, true], "aps.15.08": [102, true], "aps.15.09": [103, true], "aps.15.10": [103, true], "aps.15.11": [102, true], "aps.15.12": [103, true], "aps.15.13": [103, true], "aps.15.14": [103, true], "aps.15.15": [102, true], "aps.15.16": [102, true], "aps.15.17": [102, true], "aps.15.18": [103, true], "aps.15.19": [102, true], "aps.15.20": [102, true], "aps.15.21": [103, true], "aps.15.22": [102, true], "aps.15.23": [103, true], "aps.15.24": [103, true], "aps.15.25": [103, true], "aps.15.26": [103, true], "aps.15.27": [102, true], "aps.15.28": [103, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 4984, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [152, true], "fun2.1": [83, true], "fun2.2": [111, true], "fun2.3": [122, true], "fun2.4": [150, true], "fun2.5": [162, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [93, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [45, true], "fun6.4": [48, true], "fun6.5": [49, true], "fun7.1": [52, false], "fun7.2": [52, false], "fun7.3": [49, false], "fun7.4": [58, false], "fun7.5": [60, false], "fun8.1": [85, true], "fun8.2": [87, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [97, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [93, true], "fun9.5": [96, true]}}}, {"label": "pure.cosine.bracket.bracket", "spec": ["pure", "cosine", "bracket", "bracket"], "APS": {"total": 10957, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [64, true], "aps.02.00": [66, true], "aps.02.01": [66, true], "aps.02.02": [68, true], "aps.02.03": [68, true], "aps.02.04": [68, true], "aps.02.05": [69, true], "aps.02.06": [70, true], "aps.02.07": [70, true], "aps.02.08": [70, true], "aps.02.09": [70, true], "aps.03.00": [70, true], "aps.03.01": [70, true], "aps.03.02": [69, true], "aps.04.00": [66, true], "aps.04.01": [65, true], "aps.04.02": [65, true], "aps.04.03": [63, true], "aps.04.04": [65, true], "aps.04.05": [68, true], "aps.04.06": [66, true], "aps.04.07": [68, true], "aps.04.08": [67, true], "aps.04.09": [65, true], "aps.04.10": [67, true], "aps.04.11": [65, true], "aps.04.12": [65, true], "aps.04.13": [65, true], "aps.05.00": [64, true], "aps.06.00": [62, true], "aps.06.01": [62, true], "aps.06.02": [62, true], "aps.06.03": [61, true], "aps.06.04": [61, true], "aps.06.05": [61, true], "aps.06.06": [61, true], "aps.06.07": [61, true], "aps.06.08": [61, true], "aps.06.09": [61, true], "aps.07.00": [61, true], "aps.07.01": [61, true], "aps.07.02": [61, true], "aps.08.00": [63, true], "aps.08.01": [62, true], "aps.08.02": [62, true], "aps.08.03": [61, true], "aps.08.04": [62, true], "aps.09.00": [61, true], "aps.09.01": [62, true], "aps.09.02": [60, true], "aps.09.03": [60, true], "aps.09.04": [60, true], "aps.09.05": [59, true], "aps.09.06": [59, true], "aps.10.00": [63, true], "aps.10.01": [63, true], "aps.10.02": [64, true], "aps.10.03": [64, true], "aps.10.04": [64, true], "aps.11.00": [63, true], "aps.11.01": [64, true], "aps.11.02": [64, true], "aps.11.03": [64, true], "aps.12.00": [73, true], "aps.12.01": [73, true], "aps.12.02": [72, true], "aps.12.03": [67, true], "aps.12.04": [69, true], "aps.12.05": [70, true], "aps.12.06": [71, true], "aps.12.07": [72, true], "aps.12.08": [74, true], "aps.12.09": [74, true], "aps.12.10": [74, true], "aps.12.11": [74, true], "aps.12.12": [74, true], "aps.12.13": [74, true], "aps.12.14": [74, true], "aps.12.15": [74, true], "aps.12.16": [74, true], "aps.12.17": [74, true], "aps.12.18": [74, true], "aps.13.00": [10, false], "aps.14.00": [77, true], "aps.14.01": [77, true], "aps.14.02": [77, true], "aps.14.03": [77, true], "aps.14.04": [77, true], "aps.14.05": [77, true], "aps.14.06": [77, true], "aps.14.07": [77, true], "aps.14.08": [77, true], "aps.14.09": [77, true], "aps.14.10": [77, true], "aps.14.11": [77, true], "aps.14.12": [77, true], "aps.14.13": [77, true], "aps.14.14": [77, true], "aps.14.15": [77, true], "aps.14.16": [77, true], "aps.14.17": [77, true], "aps.14.18": [77, true], "aps.14.19": [77, true], "aps.14.20": [77, true], "aps.14.21": [77, true], "aps.14.22": [77, true], "aps.14.23": [77, true], "aps.14.24": [77, true], "aps.14.25": [77, true], "aps.14.26": [77, true], "aps.14.27": [77, true], "aps.14.28": [77, true], "aps.14.29": [77, true], "aps.14.30": [77, true], "aps.14.31": [77, true], "aps.14.32": [77, true], "aps.14.33": [77, true], "aps.14.34": [77, true], "aps.14.35": [77, true], "aps.14.36": [77, true], "aps.14.37": [77, true], "aps.14.38": [77, true], "aps.14.39": [77, true], "aps.15.00": [74, true], "aps.15.01": [74, true], "aps.15.02": [74, true], "aps.15.03": [74, true], "aps.15.04": [75, true], "aps.15.05": [74, true], "aps.15.06": [74, true], "aps.15.07": [74, true], "aps.15.08": [74, true], "aps.15.09": [74, true], "aps.15.10": [73, true], "aps.15.11": [73, true], "aps.15.12": [74, true], "aps.15.13": [74, true], "aps.15.14": [74, true], "aps.15.15": [74, true], "aps.15.16": [74, true], "aps.15.17": [74, true], "aps.15.18": [74, true], "aps.15.19": [74, true], "aps.15.20": [74, true], "aps.15.21": [74, true], "aps.15.22": [71, true], "aps.15.23": [71, true], "aps.15.24": [69, true], "aps.15.25": [69, true], "aps.15.26": [67, true], "aps.15.27": [72, true], "aps.15.28": [72, true], "aps.15.29": [67, true], "aps.15.30": [69, true]}}, "CHA": {"total": 4156, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [63, true], "fun1.2": [68, true], "fun1.3": [74, true], "fun1.4": [87, true], "fun1.5": [124, true], "fun2.1": [62, true], "fun2.2": [76, true], "fun2.3": [83, true], "fun2.4": [96, true], "fun2.5": [102, true], "fun3.1": [78, true], "fun3.2": [80, true], "fun3.3": [98, true], "fun3.4": [112, true], "fun3.5": [134, true], "fun4.1": [67, true], "fun4.2": [72, true], "fun4.3": [92, true], "fun4.4": [98, true], "fun4.5": [121, true], "fun5.1": [69, true], "fun5.2": [71, true], "fun5.3": [66, true], "fun5.4": [70, true], "fun5.5": [72, true], "fun6.1": [63, true], "fun6.2": [63, true], "fun6.3": [64, true], "fun6.4": [72, true], "fun6.5": [71, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [67, false], "fun7.5": [18, false], "fun8.1": [65, true], "fun8.2": [66, true], "fun8.3": [70, true], "fun8.4": [72, true], "fun8.5": [76, true], "fun9.1": [63, true], "fun9.2": [67, true], "fun9.3": [69, true], "fun9.4": [69, true], "fun9.5": [71, true]}}}, {"label": "pure.cosine.bracket.credit", "spec": ["pure", "cosine", "bracket", "credit"], "APS": {"total": 7683, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [46, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [46, false], "fun7.2": [9, false], "fun7.3": [11, false], "fun7.4": [10, false], "fun7.5": [10, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.cosine.bracket.safe", "spec": ["pure", "cosine", "bracket", "safe"], "APS": {"total": 14649, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [91, true], "aps.02.05": [90, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [93, true], "aps.02.09": [93, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [89, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [89, true], "aps.04.11": [88, true], "aps.04.12": [89, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [83, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [83, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [82, true], "aps.06.09": [82, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [83, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [83, true], "aps.09.01": [82, true], "aps.09.02": [83, true], "aps.09.03": [80, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [83, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [96, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [96, true], "aps.12.11": [97, true], "aps.12.12": [96, true], "aps.12.13": [96, true], "aps.12.14": [97, true], "aps.12.15": [97, true], "aps.12.16": [97, true], "aps.12.17": [96, true], "aps.12.18": [97, true], "aps.13.00": [10, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [102, true], "aps.15.01": [103, true], "aps.15.02": [103, true], "aps.15.03": [101, true], "aps.15.04": [101, true], "aps.15.05": [103, true], "aps.15.06": [102, true], "aps.15.07": [101, true], "aps.15.08": [102, true], "aps.15.09": [102, true], "aps.15.10": [101, true], "aps.15.11": [101, true], "aps.15.12": [102, true], "aps.15.13": [102, true], "aps.15.14": [102, true], "aps.15.15": [100, true], "aps.15.16": [102, true], "aps.15.17": [102, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [102, true], "aps.15.21": [102, true], "aps.15.22": [101, true], "aps.15.23": [101, true], "aps.15.24": [102, true], "aps.15.25": [102, true], "aps.15.26": [102, true], "aps.15.27": [102, true], "aps.15.28": [102, true], "aps.15.29": [88, true], "aps.15.30": [98, true]}}, "CHA": {"total": 4925, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [109, true], "fun2.3": [122, true], "fun2.4": [142, true], "fun2.5": [153, true], "fun3.1": [86, true], "fun3.2": [92, true], "fun3.3": [113, true], "fun3.4": [123, true], "fun3.5": [149, true], "fun4.1": [84, true], "fun4.2": [87, true], "fun4.3": [106, true], "fun4.4": [123, true], "fun4.5": [137, true], "fun5.1": [87, true], "fun5.2": [85, true], "fun5.3": [84, true], "fun5.4": [88, true], "fun5.5": [89, true], "fun6.1": [70, true], "fun6.2": [69, true], "fun6.3": [69, true], "fun6.4": [71, true], "fun6.5": [72, true], "fun7.1": [10, false], "fun7.2": [15, false], "fun7.3": [17, false], "fun7.4": [18, false], "fun7.5": [24, false], "fun8.1": [82, true], "fun8.2": [87, true], "fun8.3": [91, true], "fun8.4": [93, true], "fun8.5": [97, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [93, true], "fun9.5": [96, true]}}}, {"label": "pure.cosine.bracket.project", "spec": ["pure", "cosine", "bracket", "project"], "APS": {"total": 14545, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [88, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [90, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [89, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [78, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [83, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [83, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [82, true], "aps.07.00": [83, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [72, true], "aps.11.02": [82, true], "aps.11.03": [70, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [81, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [83, true], "aps.12.10": [80, true], "aps.12.11": [96, true], "aps.12.12": [97, true], "aps.12.13": [96, true], "aps.12.14": [97, true], "aps.12.15": [83, true], "aps.12.16": [82, true], "aps.12.17": [83, true], "aps.12.18": [79, true], "aps.13.00": [51, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [102, true], "aps.15.01": [102, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [103, true], "aps.15.05": [102, true], "aps.15.06": [102, true], "aps.15.07": [103, true], "aps.15.08": [102, true], "aps.15.09": [103, true], "aps.15.10": [103, true], "aps.15.11": [102, true], "aps.15.12": [103, true], "aps.15.13": [102, true], "aps.15.14": [103, true], "aps.15.15": [102, true], "aps.15.16": [103, true], "aps.15.17": [102, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [103, true], "aps.15.21": [102, true], "aps.15.22": [102, true], "aps.15.23": [102, true], "aps.15.24": [102, true], "aps.15.25": [103, true], "aps.15.26": [103, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 5111, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [96, true], "fun1.4": [113, true], "fun1.5": [152, true], "fun2.1": [82, true], "fun2.2": [111, true], "fun2.3": [123, true], "fun2.4": [151, true], "fun2.5": [162, true], "fun3.1": [88, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [78, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [51, false], "fun7.2": [52, false], "fun7.3": [52, false], "fun7.4": [57, false], "fun7.5": [58, false], "fun8.1": [85, true], "fun8.2": [87, true], "fun8.3": [91, true], "fun8.4": [93, true], "fun8.5": [97, true], "fun9.1": [82, true], "fun9.2": [87, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.cosine.bracket.none", "spec": ["pure", "cosine", "bracket", "none"], "APS": {"total": 30800, "solved": 0, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.cosine.derived.bracket", "spec": ["pure", "cosine", "derived", "bracket"], "APS": {"total": 11635, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [68, true], "aps.02.00": [75, true], "aps.02.01": [76, true], "aps.02.02": [74, true], "aps.02.03": [78, true], "aps.02.04": [76, true], "aps.02.05": [76, true], "aps.02.06": [78, true], "aps.02.07": [78, true], "aps.02.08": [80, true], "aps.02.09": [78, true], "aps.03.00": [74, true], "aps.03.01": [78, true], "aps.03.02": [76, true], "aps.04.00": [74, true], "aps.04.01": [74, true], "aps.04.02": [74, true], "aps.04.03": [73, true], "aps.04.04": [69, true], "aps.04.05": [78, true], "aps.04.06": [75, true], "aps.04.07": [77, true], "aps.04.08": [76, true], "aps.04.09": [73, true], "aps.04.10": [73, true], "aps.04.11": [74, true], "aps.04.12": [71, true], "aps.04.13": [74, true], "aps.05.00": [71, true], "aps.06.00": [70, true], "aps.06.01": [70, true], "aps.06.02": [72, true], "aps.06.03": [69, true], "aps.06.04": [67, true], "aps.06.05": [65, true], "aps.06.06": [64, true], "aps.06.07": [67, true], "aps.06.08": [67, true], "aps.06.09": [65, true], "aps.07.00": [65, true], "aps.07.01": [65, true], "aps.07.02": [65, true], "aps.08.00": [71, true], "aps.08.01": [74, true], "aps.08.02": [72, true], "aps.08.03": [70, true], "aps.08.04": [66, true], "aps.09.00": [70, true], "aps.09.01": [70, true], "aps.09.02": [65, true], "aps.09.03": [65, true], "aps.09.04": [63, true], "aps.09.05": [63, true], "aps.09.06": [63, true], "aps.10.00": [72, true], "aps.10.01": [70, true], "aps.10.02": [72, true], "aps.10.03": [68, true], "aps.10.04": [70, true], "aps.11.00": [70, true], "aps.11.01": [72, true], "aps.11.02": [67, true], "aps.11.03": [68, true], "aps.12.00": [80, true], "aps.12.01": [81, true], "aps.12.02": [80, true], "aps.12.03": [79, true], "aps.12.04": [79, true], "aps.12.05": [79, true], "aps.12.06": [81, true], "aps.12.07": [77, true], "aps.12.08": [80, true], "aps.12.09": [81, true], "aps.12.10": [82, true], "aps.12.11": [80, true], "aps.12.12": [83, true], "aps.12.13": [82, true], "aps.12.14": [79, true], "aps.12.15": [82, true], "aps.12.16": [74, true], "aps.12.17": [82, true], "aps.12.18": [82, true], "aps.13.00": [6, false], "aps.14.00": [81, true], "aps.14.01": [81, true], "aps.14.02": [81, true], "aps.14.03": [81, true], "aps.14.04": [81, true], "aps.14.05": [81, true], "aps.14.06": [81, true], "aps.14.07": [81, true], "aps.14.08": [81, true], "aps.14.09": [81, true], "aps.14.10": [81, true], "aps.14.11": [81, true], "aps.14.12": [81, true], "aps.14.13": [81, true], "aps.14.14": [81, true], "aps.14.15": [81, true], "aps.14.16": [81, true], "aps.14.17": [81, true], "aps.14.18": [81, true], "aps.14.19": [81, true], "aps.14.20": [81, true], "aps.14.21": [81, true], "aps.14.22": [81, true], "aps.14.23": [81, true], "aps.14.24": [81, true], "aps.14.25": [81, true], "aps.14.26": [81, true], "aps.14.27": [81, true], "aps.14.28": [81, true], "aps.14.29": [81, true], "aps.14.30": [81, true], "aps.14.31": [81, true], "aps.14.32": [81, true], "aps.14.33": [81, true], "aps.14.34": [81, true], "aps.14.35": [81, true], "aps.14.36": [81, true], "aps.14.37": [81, true], "aps.14.38": [81, true], "aps.14.39": [81, true], "aps.15.00": [71, true], "aps.15.01": [73, true], "aps.15.02": [73, true], "aps.15.03": [69, true], "aps.15.04": [73, true], "aps.15.05": [71, true], "aps.15.06": [70, true], "aps.15.07": [72, true], "aps.15.08": [70, true], "aps.15.09": [72, true], "aps.15.10": [71, true], "aps.15.11": [72, true], "aps.15.12": [72, true], "aps.15.13": [70, true], "aps.15.14": [70, true], "aps.15.15": [69, true], "aps.15.16": [72, true], "aps.15.17": [72, true], "aps.15.18": [72, true], "aps.15.19": [68, true], "aps.15.20": [72, true], "aps.15.21": [69, true], "aps.15.22": [71, true], "aps.15.23": [70, true], "aps.15.24": [70, true], "aps.15.25": [70, true], "aps.15.26": [69, true], "aps.15.27": [70, true], "aps.15.28": [70, true], "aps.15.29": [68, true], "aps.15.30": [68, true]}}, "CHA": {"total": 4349, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [70, true], "fun1.2": [78, true], "fun1.3": [82, true], "fun1.4": [98, true], "fun1.5": [134, true], "fun2.1": [69, true], "fun2.2": [95, true], "fun2.3": [105, true], "fun2.4": [123, true], "fun2.5": [128, true], "fun3.1": [76, true], "fun3.2": [82, true], "fun3.3": [98, true], "fun3.4": [107, true], "fun3.5": [130, true], "fun4.1": [71, true], "fun4.2": [78, true], "fun4.3": [95, true], "fun4.4": [108, true], "fun4.5": [135, true], "fun5.1": [73, true], "fun5.2": [72, true], "fun5.3": [73, true], "fun5.4": [76, true], "fun5.5": [78, true], "fun6.1": [51, true], "fun6.2": [51, true], "fun6.3": [51, true], "fun6.4": [57, true], "fun6.5": [57, true], "fun7.1": [6, false], "fun7.2": [10, false], "fun7.3": [8, false], "fun7.4": [16, false], "fun7.5": [18, false], "fun8.1": [72, true], "fun8.2": [73, true], "fun8.3": [71, true], "fun8.4": [72, true], "fun8.5": [77, true], "fun9.1": [70, true], "fun9.2": [76, true], "fun9.3": [78, true], "fun9.4": [76, true], "fun9.5": [83, true]}}}, {"label": "pure.cosine.derived.both", "spec": ["pure", "cosine", "derived", "both"], "APS": {"total": 10405, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [61, true], "aps.02.00": [66, true], "aps.02.01": [64, true], "aps.02.02": [66, true], "aps.02.03": [67, true], "aps.02.04": [66, true], "aps.02.05": [68, true], "aps.02.06": [67, true], "aps.02.07": [67, true], "aps.02.08": [68, true], "aps.02.09": [70, true], "aps.03.00": [69, true], "aps.03.01": [68, true], "aps.03.02": [67, true], "aps.04.00": [64, true], "aps.04.01": [66, true], "aps.04.02": [67, true], "aps.04.03": [64, true], "aps.04.04": [64, true], "aps.04.05": [65, true], "aps.04.06": [66, true], "aps.04.07": [66, true], "aps.04.08": [65, true], "aps.04.09": [64, true], "aps.04.10": [64, true], "aps.04.11": [66, true], "aps.04.12": [66, true], "aps.04.13": [62, true], "aps.05.00": [63, true], "aps.06.00": [60, true], "aps.06.01": [63, true], "aps.06.02": [60, true], "aps.06.03": [60, true], "aps.06.04": [62, true], "aps.06.05": [57, true], "aps.06.06": [58, true], "aps.06.07": [56, true], "aps.06.08": [56, true], "aps.06.09": [59, true], "aps.07.00": [59, true], "aps.07.01": [59, true], "aps.07.02": [59, true], "aps.08.00": [63, true], "aps.08.01": [63, true], "aps.08.02": [62, true], "aps.08.03": [64, true], "aps.08.04": [63, true], "aps.09.00": [63, true], "aps.09.01": [64, true], "aps.09.02": [59, true], "aps.09.03": [59, true], "aps.09.04": [57, true], "aps.09.05": [57, true], "aps.09.06": [57, true], "aps.10.00": [61, true], "aps.10.01": [62, true], "aps.10.02": [62, true], "aps.10.03": [61, true], "aps.10.04": [61, true], "aps.11.00": [61, true], "aps.11.01": [60, true], "aps.11.02": [63, true], "aps.11.03": [62, true], "aps.12.00": [70, true], "aps.12.01": [69, true], "aps.12.02": [68, true], "aps.12.03": [71, true], "aps.12.04": [71, true], "aps.12.05": [70, true], "aps.12.06": [70, true], "aps.12.07": [69, true], "aps.12.08": [72, true], "aps.12.09": [72, true], "aps.12.10": [70, true], "aps.12.11": [71, true], "aps.12.12": [72, true], "aps.12.13": [74, true], "aps.12.14": [71, true], "aps.12.15": [70, true], "aps.12.16": [71, true], "aps.12.17": [71, true], "aps.12.18": [72, true], "aps.13.00": [11, false], "aps.14.00": [72, true], "aps.14.01": [72, true], "aps.14.02": [72, true], "aps.14.03": [72, true], "aps.14.04": [72, true], "aps.14.05": [72, true], "aps.14.06": [72, true], "aps.14.07": [72, true], "aps.14.08": [72, true], "aps.14.09": [72, true], "aps.14.10": [72, true], "aps.14.11": [72, true], "aps.14.12": [72, true], "aps.14.13": [72, true], "aps.14.14": [72, true], "aps.14.15": [72, true], "aps.14.16": [72, true], "aps.14.17": [72, true], "aps.14.18": [72, true], "aps.14.19": [72, true], "aps.14.20": [72, true], "aps.14.21": [72, true], "aps.14.22": [72, true], "aps.14.23": [72, true], "aps.14.24": [72, true], "aps.14.25": [72, true], "aps.14.26": [72, true], "aps.14.27": [72, true], "aps.14.28": [72, true], "aps.14.29": [72, true], "aps.14.30": [72, true], "aps.14.31": [72, true], "aps.14.32": [72, true], "aps.14.33": [72, true], "aps.14.34": [72, true], "aps.14.35": [72, true], "aps.14.36": [72, true], "aps.14.37": [72, true], "aps.14.38": [72, true], "aps.14.39": [72, true], "aps.15.00": [66, true], "aps.15.01": [66, true], "aps.15.02": [66, true], "aps.15.03": [68, true], "aps.15.04": [67, true], "aps.15.05": [66, true], "aps.15.06": [65, true], "aps.15.07": [67, true], "aps.15.08": [65, true], "aps.15.09": [64, true], "aps.15.10": [64, true], "aps.15.11": [65, true], "aps.15.12": [65, true], "aps.15.13": [65, true], "aps.15.14": [66, true], "aps.15.15": [65, true], "aps.15.16": [65, true], "aps.15.17": [65, true], "aps.15.18": [65, true], "aps.15.19": [68, true], "aps.15.20": [66, true], "aps.15.21": [65, true], "aps.15.22": [65, true], "aps.15.23": [65, true], "aps.15.24": [65, true], "aps.15.25": [65, true], "aps.15.26": [64, true], "aps.15.27": [65, true], "aps.15.28": [64, true], "aps.15.29": [63, true], "aps.15.30": [63, true]}}, "CHA": {"total": 3985, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [61, true], "fun1.2": [66, true], "fun1.3": [72, true], "fun1.4": [84, true], "fun1.5": [121, true], "fun2.1": [63, true], "fun2.2": [81, true], "fun2.3": [92, true], "fun2.4": [110, true], "fun2.5": [117, true], "fun3.1": [68, true], "fun3.2": [71, true], "fun3.3": [86, true], "fun3.4": [99, true], "fun3.5": [119, true], "fun4.1": [62, true], "fun4.2": [67, true], "fun4.3": [90, true], "fun4.4": [91, true], "fun4.5": [122, true], "fun5.1": [67, true], "fun5.2": [68, true], "fun5.3": [68, true], "fun5.4": [70, true], "fun5.5": [71, true], "fun6.1": [48, true], "fun6.2": [41, true], "fun6.3": [48, true], "fun6.4": [52, true], "fun6.5": [52, true], "fun7.1": [11, false], "fun7.2": [10, false], "fun7.3": [25, false], "fun7.4": [16, false], "fun7.5": [19, false], "fun8.1": [63, true], "fun8.2": [64, true], "fun8.3": [68, true], "fun8.4": [67, true], "fun8.5": [67, true], "fun9.1": [62, true], "fun9.2": [64, true], "fun9.3": [67, true], "fun9.4": [67, true], "fun9.5": [69, true]}}}, {"label": "pure.cosine.derived.step", "spec": ["pure", "cosine", "derived", "step"], "APS": {"total": 14403, "solved": 153, "n": 154, "over": 68, "per": {"aps.01.00": [92, true], "aps.02.00": [91, true], "aps.02.01": [94, true], "aps.02.02": [94, true], "aps.02.03": [97, true], "aps.02.04": [91, true], "aps.02.05": [94, true], "aps.02.06": [99, true], "aps.02.07": [101, true], "aps.02.08": [98, true], "aps.02.09": [95, true], "aps.03.00": [94, true], "aps.03.01": [97, true], "aps.03.02": [96, true], "aps.04.00": [90, true], "aps.04.01": [95, true], "aps.04.02": [94, true], "aps.04.03": [93, true], "aps.04.04": [94, true], "aps.04.05": [92, true], "aps.04.06": [94, true], "aps.04.07": [94, true], "aps.04.08": [97, true], "aps.04.09": [94, true], "aps.04.10": [94, true], "aps.04.11": [91, true], "aps.04.12": [90, true], "aps.04.13": [90, true], "aps.05.00": [89, true], "aps.06.00": [86, true], "aps.06.01": [92, true], "aps.06.02": [93, true], "aps.06.03": [92, true], "aps.06.04": [92, true], "aps.06.05": [79, true], "aps.06.06": [82, true], "aps.06.07": [82, true], "aps.06.08": [84, true], "aps.06.09": [87, true], "aps.07.00": [85, true], "aps.07.01": [86, true], "aps.07.02": [85, true], "aps.08.00": [90, true], "aps.08.01": [87, true], "aps.08.02": [91, true], "aps.08.03": [92, true], "aps.08.04": [92, true], "aps.09.00": [94, true], "aps.09.01": [90, true], "aps.09.02": [82, true], "aps.09.03": [86, true], "aps.09.04": [85, true], "aps.09.05": [85, true], "aps.09.06": [84, true], "aps.10.00": [82, true], "aps.10.01": [95, true], "aps.10.02": [92, true], "aps.10.03": [89, true], "aps.10.04": [93, true], "aps.11.00": [92, true], "aps.11.01": [90, true], "aps.11.02": [90, true], "aps.11.03": [90, true], "aps.12.00": [107, true], "aps.12.01": [103, true], "aps.12.02": [103, true], "aps.12.03": [104, true], "aps.12.04": [102, true], "aps.12.05": [105, true], "aps.12.06": [100, true], "aps.12.07": [101, true], "aps.12.08": [103, true], "aps.12.09": [104, true], "aps.12.10": [105, true], "aps.12.11": [102, true], "aps.12.12": [104, true], "aps.12.13": [104, true], "aps.12.14": [99, true], "aps.12.15": [102, true], "aps.12.16": [105, true], "aps.12.17": [94, true], "aps.12.18": [102, true], "aps.13.00": [11, false], "aps.14.00": [99, true], "aps.14.01": [99, true], "aps.14.02": [99, true], "aps.14.03": [99, true], "aps.14.04": [99, true], "aps.14.05": [99, true], "aps.14.06": [99, true], "aps.14.07": [99, true], "aps.14.08": [99, true], "aps.14.09": [99, true], "aps.14.10": [99, true], "aps.14.11": [99, true], "aps.14.12": [99, true], "aps.14.13": [99, true], "aps.14.14": [99, true], "aps.14.15": [99, true], "aps.14.16": [99, true], "aps.14.17": [99, true], "aps.14.18": [99, true], "aps.14.19": [99, true], "aps.14.20": [99, true], "aps.14.21": [99, true], "aps.14.22": [99, true], "aps.14.23": [99, true], "aps.14.24": [99, true], "aps.14.25": [99, true], "aps.14.26": [99, true], "aps.14.27": [99, true], "aps.14.28": [99, true], "aps.14.29": [99, true], "aps.14.30": [99, true], "aps.14.31": [99, true], "aps.14.32": [99, true], "aps.14.33": [99, true], "aps.14.34": [99, true], "aps.14.35": [99, true], "aps.14.36": [99, true], "aps.14.37": [99, true], "aps.14.38": [99, true], "aps.14.39": [99, true], "aps.15.00": [82, true], "aps.15.01": [85, true], "aps.15.02": [85, true], "aps.15.03": [85, true], "aps.15.04": [85, true], "aps.15.05": [84, true], "aps.15.06": [83, true], "aps.15.07": [86, true], "aps.15.08": [83, true], "aps.15.09": [87, true], "aps.15.10": [87, true], "aps.15.11": [85, true], "aps.15.12": [84, true], "aps.15.13": [84, true], "aps.15.14": [83, true], "aps.15.15": [87, true], "aps.15.16": [84, true], "aps.15.17": [81, true], "aps.15.18": [82, true], "aps.15.19": [83, true], "aps.15.20": [83, true], "aps.15.21": [82, true], "aps.15.22": [86, true], "aps.15.23": [77, true], "aps.15.24": [81, true], "aps.15.25": [80, true], "aps.15.26": [82, true], "aps.15.27": [82, true], "aps.15.28": [79, true], "aps.15.29": [81, true], "aps.15.30": [76, true]}}, "CHA": {"total": 5091, "solved": 40, "n": 45, "over": 23, "per": {"fun1.1": [92, true], "fun1.2": [89, true], "fun1.3": [108, true], "fun1.4": [125, true], "fun1.5": [162, true], "fun2.1": [87, true], "fun2.2": [113, true], "fun2.3": [120, true], "fun2.4": [134, true], "fun2.5": [145, true], "fun3.1": [98, true], "fun3.2": [97, true], "fun3.3": [120, true], "fun3.4": [141, true], "fun3.5": [166, true], "fun4.1": [91, true], "fun4.2": [99, true], "fun4.3": [114, true], "fun4.4": [133, true], "fun4.5": [156, true], "fun5.1": [86, true], "fun5.2": [93, true], "fun5.3": [94, true], "fun5.4": [96, true], "fun5.5": [97, true], "fun6.1": [59, true], "fun6.2": [59, true], "fun6.3": [54, true], "fun6.4": [58, true], "fun6.5": [58, true], "fun7.1": [11, false], "fun7.2": [7, false], "fun7.3": [33, false], "fun7.4": [19, false], "fun7.5": [23, false], "fun8.1": [92, true], "fun8.2": [96, true], "fun8.3": [91, true], "fun8.4": [94, true], "fun8.5": [86, true], "fun9.1": [90, true], "fun9.2": [99, true], "fun9.3": [92, true], "fun9.4": [99, true], "fun9.5": [108, true]}}}, {"label": "pure.cosine.bracket.both", "spec": ["pure", "cosine", "bracket", "both"], "APS": {"total": 10457, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [63, true], "aps.02.00": [62, true], "aps.02.01": [64, true], "aps.02.02": [67, true], "aps.02.03": [63, true], "aps.02.04": [67, true], "aps.02.05": [66, true], "aps.02.06": [69, true], "aps.02.07": [69, true], "aps.02.08": [64, true], "aps.02.09": [69, true], "aps.03.00": [66, true], "aps.03.01": [64, true], "aps.03.02": [65, true], "aps.04.00": [61, true], "aps.04.01": [64, true], "aps.04.02": [63, true], "aps.04.03": [64, true], "aps.04.04": [62, true], "aps.04.05": [61, true], "aps.04.06": [64, true], "aps.04.07": [64, true], "aps.04.08": [61, true], "aps.04.09": [65, true], "aps.04.10": [66, true], "aps.04.11": [63, true], "aps.04.12": [62, true], "aps.04.13": [58, true], "aps.05.00": [62, true], "aps.06.00": [62, true], "aps.06.01": [60, true], "aps.06.02": [56, true], "aps.06.03": [57, true], "aps.06.04": [57, true], "aps.06.05": [56, true], "aps.06.06": [56, true], "aps.06.07": [57, true], "aps.06.08": [57, true], "aps.06.09": [58, true], "aps.07.00": [60, true], "aps.07.01": [58, true], "aps.07.02": [61, true], "aps.08.00": [63, true], "aps.08.01": [59, true], "aps.08.02": [59, true], "aps.08.03": [61, true], "aps.08.04": [59, true], "aps.09.00": [60, true], "aps.09.01": [60, true], "aps.09.02": [57, true], "aps.09.03": [59, true], "aps.09.04": [54, true], "aps.09.05": [55, true], "aps.09.06": [58, true], "aps.10.00": [62, true], "aps.10.01": [60, true], "aps.10.02": [57, true], "aps.10.03": [61, true], "aps.10.04": [58, true], "aps.11.00": [61, true], "aps.11.01": [59, true], "aps.11.02": [63, true], "aps.11.03": [63, true], "aps.12.00": [67, true], "aps.12.01": [71, true], "aps.12.02": [70, true], "aps.12.03": [66, true], "aps.12.04": [63, true], "aps.12.05": [65, true], "aps.12.06": [70, true], "aps.12.07": [71, true], "aps.12.08": [67, true], "aps.12.09": [74, true], "aps.12.10": [68, true], "aps.12.11": [70, true], "aps.12.12": [68, true], "aps.12.13": [67, true], "aps.12.14": [71, true], "aps.12.15": [66, true], "aps.12.16": [69, true], "aps.12.17": [69, true], "aps.12.18": [72, true], "aps.13.00": [56, false], "aps.14.00": [73, true], "aps.14.01": [73, true], "aps.14.02": [73, true], "aps.14.03": [73, true], "aps.14.04": [73, true], "aps.14.05": [73, true], "aps.14.06": [73, true], "aps.14.07": [73, true], "aps.14.08": [73, true], "aps.14.09": [73, true], "aps.14.10": [73, true], "aps.14.11": [73, true], "aps.14.12": [73, true], "aps.14.13": [73, true], "aps.14.14": [73, true], "aps.14.15": [73, true], "aps.14.16": [73, true], "aps.14.17": [73, true], "aps.14.18": [73, true], "aps.14.19": [73, true], "aps.14.20": [73, true], "aps.14.21": [73, true], "aps.14.22": [73, true], "aps.14.23": [73, true], "aps.14.24": [73, true], "aps.14.25": [73, true], "aps.14.26": [73, true], "aps.14.27": [73, true], "aps.14.28": [73, true], "aps.14.29": [73, true], "aps.14.30": [73, true], "aps.14.31": [73, true], "aps.14.32": [73, true], "aps.14.33": [73, true], "aps.14.34": [73, true], "aps.14.35": [73, true], "aps.14.36": [73, true], "aps.14.37": [73, true], "aps.14.38": [73, true], "aps.14.39": [73, true], "aps.15.00": [71, true], "aps.15.01": [72, true], "aps.15.02": [70, true], "aps.15.03": [70, true], "aps.15.04": [70, true], "aps.15.05": [72, true], "aps.15.06": [73, true], "aps.15.07": [70, true], "aps.15.08": [70, true], "aps.15.09": [73, true], "aps.15.10": [71, true], "aps.15.11": [71, true], "aps.15.12": [71, true], "aps.15.13": [72, true], "aps.15.14": [71, true], "aps.15.15": [71, true], "aps.15.16": [71, true], "aps.15.17": [70, true], "aps.15.18": [71, true], "aps.15.19": [72, true], "aps.15.20": [70, true], "aps.15.21": [71, true], "aps.15.22": [68, true], "aps.15.23": [68, true], "aps.15.24": [67, true], "aps.15.25": [67, true], "aps.15.26": [64, true], "aps.15.27": [71, true], "aps.15.28": [71, true], "aps.15.29": [66, true], "aps.15.30": [67, true]}}, "CHA": {"total": 3884, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [62, true], "fun1.2": [65, true], "fun1.3": [66, true], "fun1.4": [78, true], "fun1.5": [112, true], "fun2.1": [58, true], "fun2.2": [72, true], "fun2.3": [78, true], "fun2.4": [90, true], "fun2.5": [97, true], "fun3.1": [64, true], "fun3.2": [66, true], "fun3.3": [82, true], "fun3.4": [90, true], "fun3.5": [107, true], "fun4.1": [63, true], "fun4.2": [64, true], "fun4.3": [77, true], "fun4.4": [90, true], "fun4.5": [107, true], "fun5.1": [65, true], "fun5.2": [67, true], "fun5.3": [66, true], "fun5.4": [68, true], "fun5.5": [69, true], "fun6.1": [59, true], "fun6.2": [56, true], "fun6.3": [62, true], "fun6.4": [66, true], "fun6.5": [67, true], "fun7.1": [56, false], "fun7.2": [5, false], "fun7.3": [7, false], "fun7.4": [14, false], "fun7.5": [15, false], "fun8.1": [63, true], "fun8.2": [61, true], "fun8.3": [65, true], "fun8.4": [68, true], "fun8.5": [74, true], "fun9.1": [61, true], "fun9.2": [65, true], "fun9.3": [63, true], "fun9.4": [65, true], "fun9.5": [66, true]}}}, {"label": "pure.cosine.derived.project", "spec": ["pure", "cosine", "derived", "project"], "APS": {"total": 14676, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [88, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [93, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [89, true], "aps.04.03": [88, true], "aps.04.04": [89, true], "aps.04.05": [88, true], "aps.04.06": [77, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [85, true], "aps.06.00": [83, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [82, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [82, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [83, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [97, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [94, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [97, true], "aps.12.12": [97, true], "aps.12.13": [97, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [97, true], "aps.12.17": [96, true], "aps.12.18": [96, true], "aps.13.00": [51, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [102, true], "aps.15.01": [103, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [103, true], "aps.15.05": [103, true], "aps.15.06": [103, true], "aps.15.07": [103, true], "aps.15.08": [103, true], "aps.15.09": [103, true], "aps.15.10": [102, true], "aps.15.11": [102, true], "aps.15.12": [103, true], "aps.15.13": [103, true], "aps.15.14": [102, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [102, true], "aps.15.18": [102, true], "aps.15.19": [103, true], "aps.15.20": [102, true], "aps.15.21": [102, true], "aps.15.22": [102, true], "aps.15.23": [102, true], "aps.15.24": [103, true], "aps.15.25": [102, true], "aps.15.26": [102, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 5100, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [112, true], "fun1.5": [152, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [123, true], "fun2.4": [151, true], "fun2.5": [162, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [152, true], "fun4.1": [89, true], "fun4.2": [78, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [52, false], "fun7.3": [52, false], "fun7.4": [57, false], "fun7.5": [96, false], "fun8.1": [85, true], "fun8.2": [87, true], "fun8.3": [91, true], "fun8.4": [93, true], "fun8.5": [96, true], "fun9.1": [83, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.cosine.bracket.step", "spec": ["pure", "cosine", "bracket", "step"], "APS": {"total": 18321, "solved": 153, "n": 154, "over": 145, "per": {"aps.01.00": [117, true], "aps.02.00": [116, true], "aps.02.01": [117, true], "aps.02.02": [110, true], "aps.02.03": [119, true], "aps.02.04": [119, true], "aps.02.05": [123, true], "aps.02.06": [122, true], "aps.02.07": [122, true], "aps.02.08": [112, true], "aps.02.09": [123, true], "aps.03.00": [118, true], "aps.03.01": [114, true], "aps.03.02": [113, true], "aps.04.00": [116, true], "aps.04.01": [113, true], "aps.04.02": [112, true], "aps.04.03": [111, true], "aps.04.04": [111, true], "aps.04.05": [114, true], "aps.04.06": [113, true], "aps.04.07": [112, true], "aps.04.08": [111, true], "aps.04.09": [114, true], "aps.04.10": [112, true], "aps.04.11": [118, true], "aps.04.12": [117, true], "aps.04.13": [110, true], "aps.05.00": [118, true], "aps.06.00": [113, true], "aps.06.01": [111, true], "aps.06.02": [109, true], "aps.06.03": [110, true], "aps.06.04": [111, true], "aps.06.05": [110, true], "aps.06.06": [111, true], "aps.06.07": [108, true], "aps.06.08": [107, true], "aps.06.09": [108, true], "aps.07.00": [111, true], "aps.07.01": [109, true], "aps.07.02": [106, true], "aps.08.00": [115, true], "aps.08.01": [113, true], "aps.08.02": [104, true], "aps.08.03": [104, true], "aps.08.04": [110, true], "aps.09.00": [109, true], "aps.09.01": [111, true], "aps.09.02": [109, true], "aps.09.03": [108, true], "aps.09.04": [104, true], "aps.09.05": [104, true], "aps.09.06": [101, true], "aps.10.00": [114, true], "aps.10.01": [114, true], "aps.10.02": [113, true], "aps.10.03": [112, true], "aps.10.04": [111, true], "aps.11.00": [114, true], "aps.11.01": [115, true], "aps.11.02": [114, true], "aps.11.03": [109, true], "aps.12.00": [130, true], "aps.12.01": [132, true], "aps.12.02": [126, true], "aps.12.03": [122, true], "aps.12.04": [123, true], "aps.12.05": [125, true], "aps.12.06": [123, true], "aps.12.07": [131, true], "aps.12.08": [132, true], "aps.12.09": [132, true], "aps.12.10": [132, true], "aps.12.11": [119, true], "aps.12.12": [131, true], "aps.12.13": [133, true], "aps.12.14": [134, true], "aps.12.15": [133, true], "aps.12.16": [130, true], "aps.12.17": [129, true], "aps.12.18": [132, true], "aps.13.00": [10, false], "aps.14.00": [132, true], "aps.14.01": [132, true], "aps.14.02": [132, true], "aps.14.03": [132, true], "aps.14.04": [132, true], "aps.14.05": [132, true], "aps.14.06": [132, true], "aps.14.07": [132, true], "aps.14.08": [132, true], "aps.14.09": [132, true], "aps.14.10": [132, true], "aps.14.11": [132, true], "aps.14.12": [132, true], "aps.14.13": [132, true], "aps.14.14": [132, true], "aps.14.15": [132, true], "aps.14.16": [132, true], "aps.14.17": [132, true], "aps.14.18": [132, true], "aps.14.19": [132, true], "aps.14.20": [132, true], "aps.14.21": [132, true], "aps.14.22": [132, true], "aps.14.23": [132, true], "aps.14.24": [132, true], "aps.14.25": [132, true], "aps.14.26": [132, true], "aps.14.27": [132, true], "aps.14.28": [132, true], "aps.14.29": [132, true], "aps.14.30": [132, true], "aps.14.31": [132, true], "aps.14.32": [132, true], "aps.14.33": [132, true], "aps.14.34": [132, true], "aps.14.35": [132, true], "aps.14.36": [132, true], "aps.14.37": [132, true], "aps.14.38": [132, true], "aps.14.39": [132, true], "aps.15.00": [110, true], "aps.15.01": [112, true], "aps.15.02": [112, true], "aps.15.03": [112, true], "aps.15.04": [113, true], "aps.15.05": [112, true], "aps.15.06": [113, true], "aps.15.07": [109, true], "aps.15.08": [109, true], "aps.15.09": [110, true], "aps.15.10": [101, true], "aps.15.11": [102, true], "aps.15.12": [109, true], "aps.15.13": [105, true], "aps.15.14": [106, true], "aps.15.15": [107, true], "aps.15.16": [107, true], "aps.15.17": [112, true], "aps.15.18": [109, true], "aps.15.19": [112, true], "aps.15.20": [109, true], "aps.15.21": [106, true], "aps.15.22": [108, true], "aps.15.23": [101, true], "aps.15.24": [107, true], "aps.15.25": [102, true], "aps.15.26": [102, true], "aps.15.27": [103, true], "aps.15.28": [105, true], "aps.15.29": [90, true], "aps.15.30": [98, true]}}, "CHA": {"total": 5458, "solved": 40, "n": 45, "over": 19, "per": {"fun1.1": [112, true], "fun1.2": [121, true], "fun1.3": [119, true], "fun1.4": [142, true], "fun1.5": [186, true], "fun2.1": [111, true], "fun2.2": [123, true], "fun2.3": [128, true], "fun2.4": [142, true], "fun2.5": [153, true], "fun3.1": [87, true], "fun3.2": [93, true], "fun3.3": [119, true], "fun3.4": [123, true], "fun3.5": [150, true], "fun4.1": [84, true], "fun4.2": [87, true], "fun4.3": [106, true], "fun4.4": [123, true], "fun4.5": [151, true], "fun5.1": [87, true], "fun5.2": [85, true], "fun5.3": [84, true], "fun5.4": [88, true], "fun5.5": [89, true], "fun6.1": [70, true], "fun6.2": [69, true], "fun6.3": [69, true], "fun6.4": [71, true], "fun6.5": [72, true], "fun7.1": [10, false], "fun7.2": [15, false], "fun7.3": [17, false], "fun7.4": [18, false], "fun7.5": [24, false], "fun8.1": [116, true], "fun8.2": [115, true], "fun8.3": [122, true], "fun8.4": [124, true], "fun8.5": [135, true], "fun9.1": [113, true], "fun9.2": [116, true], "fun9.3": [126, true], "fun9.4": [121, true], "fun9.5": [126, true]}}}, {"label": "pure.cosine.derived.safe", "spec": ["pure", "cosine", "derived", "safe"], "APS": {"total": 13947, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [91, true], "aps.02.08": [93, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [93, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [89, true], "aps.04.03": [88, true], "aps.04.04": [86, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [89, true], "aps.04.10": [88, true], "aps.04.11": [89, true], "aps.04.12": [88, true], "aps.04.13": [89, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [79, true], "aps.06.06": [82, true], "aps.06.07": [82, true], "aps.06.08": [80, true], "aps.06.09": [82, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [82, true], "aps.09.02": [81, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [81, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [83, true], "aps.10.02": [83, true], "aps.10.03": [82, true], "aps.10.04": [83, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [82, true], "aps.11.03": [83, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [95, true], "aps.12.12": [97, true], "aps.12.13": [97, true], "aps.12.14": [96, true], "aps.12.15": [95, true], "aps.12.16": [96, true], "aps.12.17": [94, true], "aps.12.18": [96, true], "aps.13.00": [11, false], "aps.14.00": [99, true], "aps.14.01": [99, true], "aps.14.02": [99, true], "aps.14.03": [99, true], "aps.14.04": [99, true], "aps.14.05": [99, true], "aps.14.06": [99, true], "aps.14.07": [99, true], "aps.14.08": [99, true], "aps.14.09": [99, true], "aps.14.10": [99, true], "aps.14.11": [99, true], "aps.14.12": [99, true], "aps.14.13": [99, true], "aps.14.14": [99, true], "aps.14.15": [99, true], "aps.14.16": [99, true], "aps.14.17": [99, true], "aps.14.18": [99, true], "aps.14.19": [99, true], "aps.14.20": [99, true], "aps.14.21": [99, true], "aps.14.22": [99, true], "aps.14.23": [99, true], "aps.14.24": [99, true], "aps.14.25": [99, true], "aps.14.26": [99, true], "aps.14.27": [99, true], "aps.14.28": [99, true], "aps.14.29": [99, true], "aps.14.30": [99, true], "aps.14.31": [99, true], "aps.14.32": [99, true], "aps.14.33": [99, true], "aps.14.34": [99, true], "aps.14.35": [99, true], "aps.14.36": [99, true], "aps.14.37": [99, true], "aps.14.38": [99, true], "aps.14.39": [99, true], "aps.15.00": [82, true], "aps.15.01": [85, true], "aps.15.02": [85, true], "aps.15.03": [85, true], "aps.15.04": [85, true], "aps.15.05": [84, true], "aps.15.06": [83, true], "aps.15.07": [86, true], "aps.15.08": [83, true], "aps.15.09": [87, true], "aps.15.10": [87, true], "aps.15.11": [85, true], "aps.15.12": [84, true], "aps.15.13": [84, true], "aps.15.14": [83, true], "aps.15.15": [87, true], "aps.15.16": [84, true], "aps.15.17": [81, true], "aps.15.18": [82, true], "aps.15.19": [83, true], "aps.15.20": [83, true], "aps.15.21": [82, true], "aps.15.22": [86, true], "aps.15.23": [77, true], "aps.15.24": [81, true], "aps.15.25": [80, true], "aps.15.26": [82, true], "aps.15.27": [82, true], "aps.15.28": [79, true], "aps.15.29": [81, true], "aps.15.30": [76, true]}}, "CHA": {"total": 4894, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [89, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [152, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [120, true], "fun2.4": [134, true], "fun2.5": [145, true], "fun3.1": [89, true], "fun3.2": [92, true], "fun3.3": [113, true], "fun3.4": [124, true], "fun3.5": [153, true], "fun4.1": [88, true], "fun4.2": [93, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [152, true], "fun5.1": [86, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [59, true], "fun6.2": [59, true], "fun6.3": [54, true], "fun6.4": [58, true], "fun6.5": [58, true], "fun7.1": [11, false], "fun7.2": [7, false], "fun7.3": [33, false], "fun7.4": [19, false], "fun7.5": [23, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [86, true], "fun9.1": [82, true], "fun9.2": [87, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.cosine.derived.credit", "spec": ["pure", "cosine", "derived", "credit"], "APS": {"total": 7683, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [11, false], "fun7.4": [49, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "chandrupatla", "spec": ["base", "chandrupatla"], "APS": {"total": 2785, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [11, true], "aps.02.01": [12, true], "aps.02.02": [11, true], "aps.02.03": [11, true], "aps.02.04": [12, true], "aps.02.05": [12, true], "aps.02.06": [12, true], "aps.02.07": [12, true], "aps.02.08": [12, true], "aps.02.09": [12, true], "aps.03.00": [14, true], "aps.03.01": [16, true], "aps.03.02": [16, true], "aps.04.00": [13, true], "aps.04.01": [13, true], "aps.04.02": [14, true], "aps.04.03": [13, true], "aps.04.04": [14, true], "aps.04.05": [12, true], "aps.04.06": [12, true], "aps.04.07": [13, true], "aps.04.08": [13, true], "aps.04.09": [13, true], "aps.04.10": [12, true], "aps.04.11": [12, true], "aps.04.12": [13, true], "aps.04.13": [14, true], "aps.05.00": [8, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [12, true], "aps.06.06": [13, true], "aps.06.07": [14, true], "aps.06.08": [14, true], "aps.06.09": [14, true], "aps.07.00": [10, true], "aps.07.01": [10, true], "aps.07.02": [10, true], "aps.08.00": [3, true], "aps.08.01": [9, true], "aps.08.02": [11, true], "aps.08.03": [11, true], "aps.08.04": [12, true], "aps.09.00": [9, true], "aps.09.01": [10, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [8, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [8, true], "aps.10.01": [11, true], "aps.10.02": [12, true], "aps.10.03": [12, true], "aps.10.04": [13, true], "aps.11.00": [9, true], "aps.11.01": [10, true], "aps.11.02": [13, true], "aps.11.03": [13, true], "aps.12.00": [5, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [12, true], "aps.12.05": [11, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [9, true], "aps.12.16": [9, true], "aps.12.17": [9, true], "aps.12.18": [9, true], "aps.13.00": [8, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [31, true], "aps.15.01": [31, true], "aps.15.02": [31, true], "aps.15.03": [31, true], "aps.15.04": [31, true], "aps.15.05": [31, true], "aps.15.06": [31, true], "aps.15.07": [31, true], "aps.15.08": [31, true], "aps.15.09": [30, true], "aps.15.10": [30, true], "aps.15.11": [31, true], "aps.15.12": [31, true], "aps.15.13": [31, true], "aps.15.14": [32, true], "aps.15.15": [32, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [32, true], "aps.15.21": [33, true], "aps.15.22": [34, true], "aps.15.23": [35, true], "aps.15.24": [33, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [36, true], "aps.15.28": [36, true], "aps.15.29": [36, true], "aps.15.30": [35, true]}}, "CHA": {"total": 2423, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [8, true], "fun1.2": [12, true], "fun1.3": [15, true], "fun1.4": [24, true], "fun1.5": [44, true], "fun2.1": [9, true], "fun2.2": [23, true], "fun2.3": [29, true], "fun2.4": [42, true], "fun2.5": [49, true], "fun3.1": [44, true], "fun3.2": [46, true], "fun3.3": [60, true], "fun3.4": [69, true], "fun3.5": [82, true], "fun4.1": [44, true], "fun4.2": [46, true], "fun4.3": [56, true], "fun4.4": [67, true], "fun4.5": [80, true], "fun5.1": [44, true], "fun5.2": [44, true], "fun5.3": [45, true], "fun5.4": [47, true], "fun5.5": [48, true], "fun6.1": [44, true], "fun6.2": [44, true], "fun6.3": [45, true], "fun6.4": [47, true], "fun6.5": [48, true], "fun7.1": [8, false], "fun7.2": [8, false], "fun7.3": [11, false], "fun7.4": [18, false], "fun7.5": [19, false], "fun8.1": [10, true], "fun8.2": [11, true], "fun8.3": [13, true], "fun8.4": [14, true], "fun8.5": [15, true], "fun9.1": [8, true], "fun9.2": [9, true], "fun9.3": [11, true], "fun9.4": [13, true], "fun9.5": [14, true]}}}, {"label": "pure.cosine.derived3.bracket", "spec": ["pure", "cosine", "derived3", "bracket"], "APS": {"total": 11529, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [73, true], "aps.02.00": [72, true], "aps.02.01": [74, true], "aps.02.02": [75, true], "aps.02.03": [77, true], "aps.02.04": [76, true], "aps.02.05": [75, true], "aps.02.06": [79, true], "aps.02.07": [76, true], "aps.02.08": [75, true], "aps.02.09": [79, true], "aps.03.00": [75, true], "aps.03.01": [77, true], "aps.03.02": [75, true], "aps.04.00": [76, true], "aps.04.01": [74, true], "aps.04.02": [75, true], "aps.04.03": [73, true], "aps.04.04": [73, true], "aps.04.05": [69, true], "aps.04.06": [76, true], "aps.04.07": [74, true], "aps.04.08": [74, true], "aps.04.09": [75, true], "aps.04.10": [72, true], "aps.04.11": [75, true], "aps.04.12": [69, true], "aps.04.13": [70, true], "aps.05.00": [71, true], "aps.06.00": [72, true], "aps.06.01": [71, true], "aps.06.02": [70, true], "aps.06.03": [69, true], "aps.06.04": [70, true], "aps.06.05": [67, true], "aps.06.06": [65, true], "aps.06.07": [65, true], "aps.06.08": [69, true], "aps.06.09": [67, true], "aps.07.00": [67, true], "aps.07.01": [66, true], "aps.07.02": [65, true], "aps.08.00": [71, true], "aps.08.01": [70, true], "aps.08.02": [70, true], "aps.08.03": [70, true], "aps.08.04": [70, true], "aps.09.00": [68, true], "aps.09.01": [67, true], "aps.09.02": [66, true], "aps.09.03": [63, true], "aps.09.04": [65, true], "aps.09.05": [61, true], "aps.09.06": [63, true], "aps.10.00": [70, true], "aps.10.01": [67, true], "aps.10.02": [69, true], "aps.10.03": [70, true], "aps.10.04": [68, true], "aps.11.00": [70, true], "aps.11.01": [71, true], "aps.11.02": [67, true], "aps.11.03": [66, true], "aps.12.00": [78, true], "aps.12.01": [76, true], "aps.12.02": [81, true], "aps.12.03": [77, true], "aps.12.04": [77, true], "aps.12.05": [81, true], "aps.12.06": [80, true], "aps.12.07": [80, true], "aps.12.08": [82, true], "aps.12.09": [81, true], "aps.12.10": [80, true], "aps.12.11": [82, true], "aps.12.12": [82, true], "aps.12.13": [80, true], "aps.12.14": [82, true], "aps.12.15": [82, true], "aps.12.16": [76, true], "aps.12.17": [82, true], "aps.12.18": [82, true], "aps.13.00": [11, false], "aps.14.00": [79, true], "aps.14.01": [79, true], "aps.14.02": [79, true], "aps.14.03": [79, true], "aps.14.04": [79, true], "aps.14.05": [79, true], "aps.14.06": [79, true], "aps.14.07": [79, true], "aps.14.08": [79, true], "aps.14.09": [79, true], "aps.14.10": [79, true], "aps.14.11": [79, true], "aps.14.12": [79, true], "aps.14.13": [79, true], "aps.14.14": [79, true], "aps.14.15": [79, true], "aps.14.16": [79, true], "aps.14.17": [79, true], "aps.14.18": [79, true], "aps.14.19": [79, true], "aps.14.20": [79, true], "aps.14.21": [79, true], "aps.14.22": [79, true], "aps.14.23": [79, true], "aps.14.24": [79, true], "aps.14.25": [79, true], "aps.14.26": [79, true], "aps.14.27": [79, true], "aps.14.28": [79, true], "aps.14.29": [79, true], "aps.14.30": [79, true], "aps.14.31": [79, true], "aps.14.32": [79, true], "aps.14.33": [79, true], "aps.14.34": [79, true], "aps.14.35": [79, true], "aps.14.36": [79, true], "aps.14.37": [79, true], "aps.14.38": [79, true], "aps.14.39": [79, true], "aps.15.00": [73, true], "aps.15.01": [73, true], "aps.15.02": [71, true], "aps.15.03": [71, true], "aps.15.04": [72, true], "aps.15.05": [73, true], "aps.15.06": [70, true], "aps.15.07": [72, true], "aps.15.08": [68, true], "aps.15.09": [70, true], "aps.15.10": [71, true], "aps.15.11": [72, true], "aps.15.12": [72, true], "aps.15.13": [70, true], "aps.15.14": [70, true], "aps.15.15": [70, true], "aps.15.16": [72, true], "aps.15.17": [72, true], "aps.15.18": [70, true], "aps.15.19": [70, true], "aps.15.20": [70, true], "aps.15.21": [69, true], "aps.15.22": [72, true], "aps.15.23": [72, true], "aps.15.24": [69, true], "aps.15.25": [69, true], "aps.15.26": [67, true], "aps.15.27": [70, true], "aps.15.28": [69, true], "aps.15.29": [69, true], "aps.15.30": [71, true]}}, "CHA": {"total": 4303, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [68, true], "fun1.2": [76, true], "fun1.3": [82, true], "fun1.4": [92, true], "fun1.5": [133, true], "fun2.1": [64, true], "fun2.2": [96, true], "fun2.3": [100, true], "fun2.4": [121, true], "fun2.5": [127, true], "fun3.1": [66, true], "fun3.2": [76, true], "fun3.3": [95, true], "fun3.4": [100, true], "fun3.5": [132, true], "fun4.1": [73, true], "fun4.2": [75, true], "fun4.3": [98, true], "fun4.4": [108, true], "fun4.5": [138, true], "fun5.1": [77, true], "fun5.2": [78, true], "fun5.3": [78, true], "fun5.4": [81, true], "fun5.5": [83, true], "fun6.1": [43, true], "fun6.2": [54, true], "fun6.3": [50, true], "fun6.4": [53, true], "fun6.5": [55, true], "fun7.1": [11, false], "fun7.2": [10, false], "fun7.3": [13, false], "fun7.4": [16, false], "fun7.5": [18, false], "fun8.1": [69, true], "fun8.2": [74, true], "fun8.3": [72, true], "fun8.4": [71, true], "fun8.5": [75, true], "fun9.1": [70, true], "fun9.2": [74, true], "fun9.3": [75, true], "fun9.4": [73, true], "fun9.5": [78, true]}}}, {"label": "pure.cosine.derived3.both", "spec": ["pure", "cosine", "derived3", "both"], "APS": {"total": 10404, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [63, true], "aps.02.00": [63, true], "aps.02.01": [68, true], "aps.02.02": [64, true], "aps.02.03": [66, true], "aps.02.04": [66, true], "aps.02.05": [66, true], "aps.02.06": [66, true], "aps.02.07": [65, true], "aps.02.08": [66, true], "aps.02.09": [67, true], "aps.03.00": [69, true], "aps.03.01": [68, true], "aps.03.02": [69, true], "aps.04.00": [65, true], "aps.04.01": [65, true], "aps.04.02": [64, true], "aps.04.03": [65, true], "aps.04.04": [65, true], "aps.04.05": [66, true], "aps.04.06": [65, true], "aps.04.07": [63, true], "aps.04.08": [65, true], "aps.04.09": [65, true], "aps.04.10": [64, true], "aps.04.11": [65, true], "aps.04.12": [65, true], "aps.04.13": [67, true], "aps.05.00": [63, true], "aps.06.00": [61, true], "aps.06.01": [62, true], "aps.06.02": [62, true], "aps.06.03": [61, true], "aps.06.04": [62, true], "aps.06.05": [59, true], "aps.06.06": [58, true], "aps.06.07": [58, true], "aps.06.08": [56, true], "aps.06.09": [56, true], "aps.07.00": [57, true], "aps.07.01": [56, true], "aps.07.02": [55, true], "aps.08.00": [60, true], "aps.08.01": [61, true], "aps.08.02": [60, true], "aps.08.03": [61, true], "aps.08.04": [62, true], "aps.09.00": [62, true], "aps.09.01": [61, true], "aps.09.02": [57, true], "aps.09.03": [57, true], "aps.09.04": [58, true], "aps.09.05": [56, true], "aps.09.06": [56, true], "aps.10.00": [61, true], "aps.10.01": [63, true], "aps.10.02": [62, true], "aps.10.03": [64, true], "aps.10.04": [59, true], "aps.11.00": [61, true], "aps.11.01": [61, true], "aps.11.02": [61, true], "aps.11.03": [62, true], "aps.12.00": [70, true], "aps.12.01": [72, true], "aps.12.02": [71, true], "aps.12.03": [68, true], "aps.12.04": [71, true], "aps.12.05": [72, true], "aps.12.06": [71, true], "aps.12.07": [71, true], "aps.12.08": [70, true], "aps.12.09": [71, true], "aps.12.10": [70, true], "aps.12.11": [72, true], "aps.12.12": [72, true], "aps.12.13": [69, true], "aps.12.14": [72, true], "aps.12.15": [71, true], "aps.12.16": [70, true], "aps.12.17": [71, true], "aps.12.18": [67, true], "aps.13.00": [10, false], "aps.14.00": [73, true], "aps.14.01": [73, true], "aps.14.02": [73, true], "aps.14.03": [73, true], "aps.14.04": [73, true], "aps.14.05": [73, true], "aps.14.06": [73, true], "aps.14.07": [73, true], "aps.14.08": [73, true], "aps.14.09": [73, true], "aps.14.10": [73, true], "aps.14.11": [73, true], "aps.14.12": [73, true], "aps.14.13": [73, true], "aps.14.14": [73, true], "aps.14.15": [73, true], "aps.14.16": [73, true], "aps.14.17": [73, true], "aps.14.18": [73, true], "aps.14.19": [73, true], "aps.14.20": [73, true], "aps.14.21": [73, true], "aps.14.22": [73, true], "aps.14.23": [73, true], "aps.14.24": [73, true], "aps.14.25": [73, true], "aps.14.26": [73, true], "aps.14.27": [73, true], "aps.14.28": [73, true], "aps.14.29": [73, true], "aps.14.30": [73, true], "aps.14.31": [73, true], "aps.14.32": [73, true], "aps.14.33": [73, true], "aps.14.34": [73, true], "aps.14.35": [73, true], "aps.14.36": [73, true], "aps.14.37": [73, true], "aps.14.38": [73, true], "aps.14.39": [73, true], "aps.15.00": [65, true], "aps.15.01": [66, true], "aps.15.02": [65, true], "aps.15.03": [67, true], "aps.15.04": [66, true], "aps.15.05": [66, true], "aps.15.06": [65, true], "aps.15.07": [65, true], "aps.15.08": [66, true], "aps.15.09": [65, true], "aps.15.10": [65, true], "aps.15.11": [63, true], "aps.15.12": [66, true], "aps.15.13": [64, true], "aps.15.14": [65, true], "aps.15.15": [67, true], "aps.15.16": [65, true], "aps.15.17": [66, true], "aps.15.18": [65, true], "aps.15.19": [65, true], "aps.15.20": [65, true], "aps.15.21": [63, true], "aps.15.22": [67, true], "aps.15.23": [65, true], "aps.15.24": [65, true], "aps.15.25": [65, true], "aps.15.26": [63, true], "aps.15.27": [64, true], "aps.15.28": [65, true], "aps.15.29": [63, true], "aps.15.30": [65, true]}}, "CHA": {"total": 3919, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [60, true], "fun1.2": [66, true], "fun1.3": [70, true], "fun1.4": [84, true], "fun1.5": [113, true], "fun2.1": [61, true], "fun2.2": [81, true], "fun2.3": [91, true], "fun2.4": [104, true], "fun2.5": [110, true], "fun3.1": [66, true], "fun3.2": [67, true], "fun3.3": [85, true], "fun3.4": [96, true], "fun3.5": [117, true], "fun4.1": [65, true], "fun4.2": [68, true], "fun4.3": [87, true], "fun4.4": [103, true], "fun4.5": [120, true], "fun5.1": [67, true], "fun5.2": [66, true], "fun5.3": [65, true], "fun5.4": [69, true], "fun5.5": [70, true], "fun6.1": [41, true], "fun6.2": [42, true], "fun6.3": [43, true], "fun6.4": [46, true], "fun6.5": [47, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [16, false], "fun7.5": [18, false], "fun8.1": [63, true], "fun8.2": [63, true], "fun8.3": [66, true], "fun8.4": [66, true], "fun8.5": [62, true], "fun9.1": [62, true], "fun9.2": [66, true], "fun9.3": [64, true], "fun9.4": [69, true], "fun9.5": [68, true]}}}, {"label": "pure.cosine.derived3.step", "spec": ["pure", "cosine", "derived3", "step"], "APS": {"total": 14489, "solved": 153, "n": 154, "over": 68, "per": {"aps.01.00": [95, true], "aps.02.00": [91, true], "aps.02.01": [85, true], "aps.02.02": [94, true], "aps.02.03": [88, true], "aps.02.04": [93, true], "aps.02.05": [97, true], "aps.02.06": [95, true], "aps.02.07": [93, true], "aps.02.08": [96, true], "aps.02.09": [99, true], "aps.03.00": [103, true], "aps.03.01": [99, true], "aps.03.02": [94, true], "aps.04.00": [95, true], "aps.04.01": [94, true], "aps.04.02": [95, true], "aps.04.03": [93, true], "aps.04.04": [94, true], "aps.04.05": [95, true], "aps.04.06": [88, true], "aps.04.07": [94, true], "aps.04.08": [95, true], "aps.04.09": [95, true], "aps.04.10": [93, true], "aps.04.11": [95, true], "aps.04.12": [93, true], "aps.04.13": [94, true], "aps.05.00": [90, true], "aps.06.00": [91, true], "aps.06.01": [90, true], "aps.06.02": [89, true], "aps.06.03": [89, true], "aps.06.04": [85, true], "aps.06.05": [86, true], "aps.06.06": [84, true], "aps.06.07": [80, true], "aps.06.08": [80, true], "aps.06.09": [83, true], "aps.07.00": [86, true], "aps.07.01": [87, true], "aps.07.02": [87, true], "aps.08.00": [90, true], "aps.08.01": [88, true], "aps.08.02": [91, true], "aps.08.03": [93, true], "aps.08.04": [90, true], "aps.09.00": [92, true], "aps.09.01": [92, true], "aps.09.02": [84, true], "aps.09.03": [86, true], "aps.09.04": [86, true], "aps.09.05": [86, true], "aps.09.06": [84, true], "aps.10.00": [92, true], "aps.10.01": [92, true], "aps.10.02": [92, true], "aps.10.03": [92, true], "aps.10.04": [91, true], "aps.11.00": [87, true], "aps.11.01": [90, true], "aps.11.02": [93, true], "aps.11.03": [90, true], "aps.12.00": [102, true], "aps.12.01": [104, true], "aps.12.02": [107, true], "aps.12.03": [106, true], "aps.12.04": [105, true], "aps.12.05": [102, true], "aps.12.06": [105, true], "aps.12.07": [98, true], "aps.12.08": [103, true], "aps.12.09": [100, true], "aps.12.10": [98, true], "aps.12.11": [100, true], "aps.12.12": [106, true], "aps.12.13": [106, true], "aps.12.14": [95, true], "aps.12.15": [97, true], "aps.12.16": [102, true], "aps.12.17": [100, true], "aps.12.18": [105, true], "aps.13.00": [11, false], "aps.14.00": [101, true], "aps.14.01": [101, true], "aps.14.02": [101, true], "aps.14.03": [101, true], "aps.14.04": [101, true], "aps.14.05": [101, true], "aps.14.06": [101, true], "aps.14.07": [101, true], "aps.14.08": [101, true], "aps.14.09": [101, true], "aps.14.10": [101, true], "aps.14.11": [101, true], "aps.14.12": [101, true], "aps.14.13": [101, true], "aps.14.14": [101, true], "aps.14.15": [101, true], "aps.14.16": [101, true], "aps.14.17": [101, true], "aps.14.18": [101, true], "aps.14.19": [101, true], "aps.14.20": [101, true], "aps.14.21": [101, true], "aps.14.22": [101, true], "aps.14.23": [101, true], "aps.14.24": [101, true], "aps.14.25": [101, true], "aps.14.26": [101, true], "aps.14.27": [101, true], "aps.14.28": [101, true], "aps.14.29": [101, true], "aps.14.30": [101, true], "aps.14.31": [101, true], "aps.14.32": [101, true], "aps.14.33": [101, true], "aps.14.34": [101, true], "aps.14.35": [101, true], "aps.14.36": [101, true], "aps.14.37": [101, true], "aps.14.38": [101, true], "aps.14.39": [101, true], "aps.15.00": [82, true], "aps.15.01": [82, true], "aps.15.02": [84, true], "aps.15.03": [84, true], "aps.15.04": [80, true], "aps.15.05": [83, true], "aps.15.06": [86, true], "aps.15.07": [85, true], "aps.15.08": [84, true], "aps.15.09": [86, true], "aps.15.10": [85, true], "aps.15.11": [80, true], "aps.15.12": [85, true], "aps.15.13": [85, true], "aps.15.14": [81, true], "aps.15.15": [85, true], "aps.15.16": [83, true], "aps.15.17": [84, true], "aps.15.18": [85, true], "aps.15.19": [83, true], "aps.15.20": [85, true], "aps.15.21": [82, true], "aps.15.22": [86, true], "aps.15.23": [81, true], "aps.15.24": [86, true], "aps.15.25": [80, true], "aps.15.26": [85, true], "aps.15.27": [81, true], "aps.15.28": [80, true], "aps.15.29": [84, true], "aps.15.30": [83, true]}}, "CHA": {"total": 5033, "solved": 40, "n": 45, "over": 25, "per": {"fun1.1": [93, true], "fun1.2": [92, true], "fun1.3": [103, true], "fun1.4": [128, true], "fun1.5": [163, true], "fun2.1": [91, true], "fun2.2": [104, true], "fun2.3": [104, true], "fun2.4": [129, true], "fun2.5": [129, true], "fun3.1": [78, true], "fun3.2": [94, true], "fun3.3": [107, true], "fun3.4": [135, true], "fun3.5": [160, true], "fun4.1": [95, true], "fun4.2": [97, true], "fun4.3": [121, true], "fun4.4": [145, true], "fun4.5": [174, true], "fun5.1": [96, true], "fun5.2": [102, true], "fun5.3": [109, true], "fun5.4": [108, true], "fun5.5": [109, true], "fun6.1": [42, true], "fun6.2": [47, true], "fun6.3": [44, true], "fun6.4": [47, true], "fun6.5": [49, true], "fun7.1": [11, false], "fun7.2": [7, false], "fun7.3": [14, false], "fun7.4": [22, false], "fun7.5": [22, false], "fun8.1": [93, true], "fun8.2": [94, true], "fun8.3": [97, true], "fun8.4": [95, true], "fun8.5": [88, true], "fun9.1": [85, true], "fun9.2": [101, true], "fun9.3": [94, true], "fun9.4": [95, true], "fun9.5": [96, true]}}}, {"label": "pure.cosine.derived3.none", "spec": ["pure", "cosine", "derived3", "none"], "APS": {"total": 30800, "solved": 0, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 8969, "solved": 1, "n": 45, "over": 1, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [169, true], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.cosine.derived3.credit", "spec": ["pure", "cosine", "derived3", "credit"], "APS": {"total": 7683, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [11, false], "fun7.4": [49, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.exp_abs.start.step", "spec": ["pure", "exp_abs", "start", "step"], "APS": {"total": 11673, "solved": 153, "n": 154, "over": 27, "per": {"aps.01.00": [49, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [53, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [116, true], "aps.04.01": [83, true], "aps.04.02": [86, true], "aps.04.03": [153, true], "aps.04.04": [153, true], "aps.04.05": [143, true], "aps.04.06": [78, true], "aps.04.07": [145, true], "aps.04.08": [42, true], "aps.04.09": [27, true], "aps.04.10": [80, true], "aps.04.11": [46, true], "aps.04.12": [164, true], "aps.04.13": [43, true], "aps.05.00": [148, true], "aps.06.00": [20, true], "aps.06.01": [30, true], "aps.06.02": [32, true], "aps.06.03": [34, true], "aps.06.04": [34, true], "aps.06.05": [36, true], "aps.06.06": [37, true], "aps.06.07": [38, true], "aps.06.08": [38, true], "aps.06.09": [37, true], "aps.07.00": [148, true], "aps.07.01": [55, true], "aps.07.02": [73, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [180, true], "aps.08.03": [85, true], "aps.08.04": [83, true], "aps.09.00": [34, true], "aps.09.01": [34, true], "aps.09.02": [80, true], "aps.09.03": [147, true], "aps.09.04": [133, true], "aps.09.05": [131, true], "aps.09.06": [151, true], "aps.10.00": [110, true], "aps.10.01": [173, true], "aps.10.02": [76, true], "aps.10.03": [71, true], "aps.10.04": [76, true], "aps.11.00": [72, true], "aps.11.01": [80, true], "aps.11.02": [21, true], "aps.11.03": [26, true], "aps.12.00": [81, true], "aps.12.01": [178, true], "aps.12.02": [81, true], "aps.12.03": [44, true], "aps.12.04": [49, true], "aps.12.05": [54, true], "aps.12.06": [61, true], "aps.12.07": [67, true], "aps.12.08": [157, true], "aps.12.09": [59, true], "aps.12.10": [52, true], "aps.12.11": [46, true], "aps.12.12": [41, true], "aps.12.13": [37, true], "aps.12.14": [33, true], "aps.12.15": [30, true], "aps.12.16": [26, true], "aps.12.17": [23, true], "aps.12.18": [21, true], "aps.13.00": [9, false], "aps.14.00": [71, true], "aps.14.01": [71, true], "aps.14.02": [71, true], "aps.14.03": [71, true], "aps.14.04": [71, true], "aps.14.05": [71, true], "aps.14.06": [71, true], "aps.14.07": [71, true], "aps.14.08": [71, true], "aps.14.09": [71, true], "aps.14.10": [71, true], "aps.14.11": [71, true], "aps.14.12": [71, true], "aps.14.13": [71, true], "aps.14.14": [71, true], "aps.14.15": [71, true], "aps.14.16": [71, true], "aps.14.17": [71, true], "aps.14.18": [71, true], "aps.14.19": [71, true], "aps.14.20": [71, true], "aps.14.21": [71, true], "aps.14.22": [71, true], "aps.14.23": [71, true], "aps.14.24": [71, true], "aps.14.25": [71, true], "aps.14.26": [71, true], "aps.14.27": [71, true], "aps.14.28": [71, true], "aps.14.29": [71, true], "aps.14.30": [71, true], "aps.14.31": [71, true], "aps.14.32": [71, true], "aps.14.33": [71, true], "aps.14.34": [71, true], "aps.14.35": [71, true], "aps.14.36": [71, true], "aps.14.37": [71, true], "aps.14.38": [71, true], "aps.14.39": [71, true], "aps.15.00": [157, true], "aps.15.01": [167, true], "aps.15.02": [80, true], "aps.15.03": [82, true], "aps.15.04": [79, true], "aps.15.05": [79, true], "aps.15.06": [76, true], "aps.15.07": [66, true], "aps.15.08": [74, true], "aps.15.09": [79, true], "aps.15.10": [79, true], "aps.15.11": [77, true], "aps.15.12": [84, true], "aps.15.13": [86, true], "aps.15.14": [172, true], "aps.15.15": [159, true], "aps.15.16": [151, true], "aps.15.17": [141, true], "aps.15.18": [136, true], "aps.15.19": [129, true], "aps.15.20": [60, true], "aps.15.21": [31, true], "aps.15.22": [47, true], "aps.15.23": [125, true], "aps.15.24": [81, true], "aps.15.25": [67, true], "aps.15.26": [81, true], "aps.15.27": [70, true], "aps.15.28": [48, true], "aps.15.29": [73, true], "aps.15.30": [68, true]}}, "CHA": {"total": 4072, "solved": 40, "n": 45, "over": 3, "per": {"fun1.1": [117, true], "fun1.2": [77, true], "fun1.3": [86, true], "fun1.4": [91, true], "fun1.5": [109, true], "fun2.1": [69, true], "fun2.2": [86, true], "fun2.3": [60, true], "fun2.4": [105, true], "fun2.5": [110, true], "fun3.1": [65, true], "fun3.2": [66, true], "fun3.3": [84, true], "fun3.4": [94, true], "fun3.5": [109, true], "fun4.1": [55, true], "fun4.2": [58, true], "fun4.3": [76, true], "fun4.4": [82, true], "fun4.5": [96, true], "fun5.1": [50, true], "fun5.2": [55, true], "fun5.3": [54, true], "fun5.4": [56, true], "fun5.5": [57, true], "fun6.1": [47, true], "fun6.2": [48, true], "fun6.3": [51, true], "fun6.4": [53, true], "fun6.5": [54, true], "fun7.1": [9, false], "fun7.2": [11, false], "fun7.3": [15, false], "fun7.4": [20, false], "fun7.5": [22, false], "fun8.1": [74, true], "fun8.2": [171, true], "fun8.3": [77, true], "fun8.4": [74, true], "fun8.5": [82, true], "fun9.1": [123, true], "fun9.2": [81, true], "fun9.3": [41, true], "fun9.4": [34, true], "fun9.5": [95, true]}}}, {"label": "pure.cosine.derived.none", "spec": ["pure", "cosine", "derived", "none"], "APS": {"total": 30800, "solved": 0, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.exp_abs.start.both", "spec": ["pure", "exp_abs", "start", "both"], "APS": {"total": 9588, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [59, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [52, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [61, true], "aps.04.01": [60, true], "aps.04.02": [59, true], "aps.04.03": [60, true], "aps.04.04": [58, true], "aps.04.05": [61, true], "aps.04.06": [61, true], "aps.04.07": [62, true], "aps.04.08": [63, true], "aps.04.09": [60, true], "aps.04.10": [65, true], "aps.04.11": [58, true], "aps.04.12": [63, true], "aps.04.13": [64, true], "aps.05.00": [60, true], "aps.06.00": [61, true], "aps.06.01": [61, true], "aps.06.02": [61, true], "aps.06.03": [61, true], "aps.06.04": [61, true], "aps.06.05": [59, true], "aps.06.06": [61, true], "aps.06.07": [61, true], "aps.06.08": [58, true], "aps.06.09": [58, true], "aps.07.00": [63, true], "aps.07.01": [66, true], "aps.07.02": [65, true], "aps.08.00": [3, true], "aps.08.01": [63, true], "aps.08.02": [60, true], "aps.08.03": [61, true], "aps.08.04": [59, true], "aps.09.00": [62, true], "aps.09.01": [61, true], "aps.09.02": [64, true], "aps.09.03": [64, true], "aps.09.04": [66, true], "aps.09.05": [65, true], "aps.09.06": [63, true], "aps.10.00": [62, true], "aps.10.01": [58, true], "aps.10.02": [58, true], "aps.10.03": [57, true], "aps.10.04": [57, true], "aps.11.00": [54, true], "aps.11.01": [58, true], "aps.11.02": [57, true], "aps.11.03": [59, true], "aps.12.00": [71, true], "aps.12.01": [66, true], "aps.12.02": [66, true], "aps.12.03": [64, true], "aps.12.04": [66, true], "aps.12.05": [66, true], "aps.12.06": [66, true], "aps.12.07": [66, true], "aps.12.08": [67, true], "aps.12.09": [63, true], "aps.12.10": [68, true], "aps.12.11": [67, true], "aps.12.12": [63, true], "aps.12.13": [68, true], "aps.12.14": [69, true], "aps.12.15": [67, true], "aps.12.16": [69, true], "aps.12.17": [68, true], "aps.12.18": [67, true], "aps.13.00": [11, false], "aps.14.00": [66, true], "aps.14.01": [66, true], "aps.14.02": [66, true], "aps.14.03": [66, true], "aps.14.04": [66, true], "aps.14.05": [66, true], "aps.14.06": [66, true], "aps.14.07": [66, true], "aps.14.08": [66, true], "aps.14.09": [66, true], "aps.14.10": [66, true], "aps.14.11": [66, true], "aps.14.12": [66, true], "aps.14.13": [66, true], "aps.14.14": [66, true], "aps.14.15": [66, true], "aps.14.16": [66, true], "aps.14.17": [66, true], "aps.14.18": [66, true], "aps.14.19": [66, true], "aps.14.20": [66, true], "aps.14.21": [66, true], "aps.14.22": [66, true], "aps.14.23": [66, true], "aps.14.24": [66, true], "aps.14.25": [66, true], "aps.14.26": [66, true], "aps.14.27": [66, true], "aps.14.28": [66, true], "aps.14.29": [66, true], "aps.14.30": [66, true], "aps.14.31": [66, true], "aps.14.32": [66, true], "aps.14.33": [66, true], "aps.14.34": [66, true], "aps.14.35": [66, true], "aps.14.36": [66, true], "aps.14.37": [66, true], "aps.14.38": [66, true], "aps.14.39": [66, true], "aps.15.00": [61, true], "aps.15.01": [64, true], "aps.15.02": [61, true], "aps.15.03": [63, true], "aps.15.04": [57, true], "aps.15.05": [60, true], "aps.15.06": [60, true], "aps.15.07": [51, true], "aps.15.08": [65, true], "aps.15.09": [62, true], "aps.15.10": [62, true], "aps.15.11": [59, true], "aps.15.12": [64, true], "aps.15.13": [64, true], "aps.15.14": [65, true], "aps.15.15": [60, true], "aps.15.16": [63, true], "aps.15.17": [64, true], "aps.15.18": [63, true], "aps.15.19": [62, true], "aps.15.20": [62, true], "aps.15.21": [61, true], "aps.15.22": [64, true], "aps.15.23": [59, true], "aps.15.24": [61, true], "aps.15.25": [60, true], "aps.15.26": [63, true], "aps.15.27": [58, true], "aps.15.28": [60, true], "aps.15.29": [57, true], "aps.15.30": [59, true]}}, "CHA": {"total": 3526, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [60, true], "fun1.2": [59, true], "fun1.3": [66, true], "fun1.4": [73, true], "fun1.5": [93, true], "fun2.1": [51, true], "fun2.2": [67, true], "fun2.3": [73, true], "fun2.4": [80, true], "fun2.5": [87, true], "fun3.1": [56, true], "fun3.2": [57, true], "fun3.3": [72, true], "fun3.4": [79, true], "fun3.5": [93, true], "fun4.1": [51, true], "fun4.2": [53, true], "fun4.3": [67, true], "fun4.4": [73, true], "fun4.5": [87, true], "fun5.1": [48, true], "fun5.2": [49, true], "fun5.3": [50, true], "fun5.4": [51, true], "fun5.5": [52, true], "fun6.1": [46, true], "fun6.2": [47, true], "fun6.3": [49, true], "fun6.4": [51, true], "fun6.5": [52, true], "fun7.1": [11, false], "fun7.2": [10, false], "fun7.3": [13, false], "fun7.4": [16, false], "fun7.5": [15, false], "fun8.1": [59, true], "fun8.2": [62, true], "fun8.3": [63, true], "fun8.4": [67, true], "fun8.5": [62, true], "fun9.1": [60, true], "fun9.2": [59, true], "fun9.3": [65, true], "fun9.4": [68, true], "fun9.5": [69, true]}}}, {"label": "pure.exp_abs.start.bracket", "spec": ["pure", "exp_abs", "start", "bracket"], "APS": {"total": 10577, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [66, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [52, true], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [70, true], "aps.04.01": [66, true], "aps.04.02": [68, true], "aps.04.03": [70, true], "aps.04.04": [68, true], "aps.04.05": [69, true], "aps.04.06": [53, true], "aps.04.07": [65, true], "aps.04.08": [67, true], "aps.04.09": [68, true], "aps.04.10": [66, true], "aps.04.11": [65, true], "aps.04.12": [68, true], "aps.04.13": [68, true], "aps.05.00": [66, true], "aps.06.00": [67, true], "aps.06.01": [68, true], "aps.06.02": [68, true], "aps.06.03": [67, true], "aps.06.04": [67, true], "aps.06.05": [66, true], "aps.06.06": [66, true], "aps.06.07": [66, true], "aps.06.08": [66, true], "aps.06.09": [66, true], "aps.07.00": [68, true], "aps.07.01": [71, true], "aps.07.02": [71, true], "aps.08.00": [67, true], "aps.08.01": [68, true], "aps.08.02": [68, true], "aps.08.03": [67, true], "aps.08.04": [68, true], "aps.09.00": [67, true], "aps.09.01": [66, true], "aps.09.02": [70, true], "aps.09.03": [71, true], "aps.09.04": [71, true], "aps.09.05": [70, true], "aps.09.06": [67, true], "aps.10.00": [68, true], "aps.10.01": [67, true], "aps.10.02": [67, true], "aps.10.03": [64, true], "aps.10.04": [63, true], "aps.11.00": [66, true], "aps.11.01": [65, true], "aps.11.02": [66, true], "aps.11.03": [65, true], "aps.12.00": [76, true], "aps.12.01": [74, true], "aps.12.02": [71, true], "aps.12.03": [73, true], "aps.12.04": [74, true], "aps.12.05": [74, true], "aps.12.06": [74, true], "aps.12.07": [75, true], "aps.12.08": [74, true], "aps.12.09": [75, true], "aps.12.10": [74, true], "aps.12.11": [74, true], "aps.12.12": [72, true], "aps.12.13": [73, true], "aps.12.14": [72, true], "aps.12.15": [73, true], "aps.12.16": [73, true], "aps.12.17": [72, true], "aps.12.18": [72, true], "aps.13.00": [10, false], "aps.14.00": [74, true], "aps.14.01": [74, true], "aps.14.02": [74, true], "aps.14.03": [74, true], "aps.14.04": [74, true], "aps.14.05": [74, true], "aps.14.06": [74, true], "aps.14.07": [74, true], "aps.14.08": [74, true], "aps.14.09": [74, true], "aps.14.10": [74, true], "aps.14.11": [74, true], "aps.14.12": [74, true], "aps.14.13": [74, true], "aps.14.14": [74, true], "aps.14.15": [74, true], "aps.14.16": [74, true], "aps.14.17": [74, true], "aps.14.18": [74, true], "aps.14.19": [74, true], "aps.14.20": [74, true], "aps.14.21": [74, true], "aps.14.22": [74, true], "aps.14.23": [74, true], "aps.14.24": [74, true], "aps.14.25": [74, true], "aps.14.26": [74, true], "aps.14.27": [74, true], "aps.14.28": [74, true], "aps.14.29": [74, true], "aps.14.30": [74, true], "aps.14.31": [74, true], "aps.14.32": [74, true], "aps.14.33": [74, true], "aps.14.34": [74, true], "aps.14.35": [74, true], "aps.14.36": [74, true], "aps.14.37": [74, true], "aps.14.38": [74, true], "aps.14.39": [74, true], "aps.15.00": [69, true], "aps.15.01": [68, true], "aps.15.02": [68, true], "aps.15.03": [68, true], "aps.15.04": [68, true], "aps.15.05": [68, true], "aps.15.06": [68, true], "aps.15.07": [68, true], "aps.15.08": [68, true], "aps.15.09": [68, true], "aps.15.10": [68, true], "aps.15.11": [68, true], "aps.15.12": [68, true], "aps.15.13": [68, true], "aps.15.14": [68, true], "aps.15.15": [67, true], "aps.15.16": [67, true], "aps.15.17": [67, true], "aps.15.18": [67, true], "aps.15.19": [67, true], "aps.15.20": [67, true], "aps.15.21": [63, true], "aps.15.22": [66, true], "aps.15.23": [64, true], "aps.15.24": [65, true], "aps.15.25": [65, true], "aps.15.26": [64, true], "aps.15.27": [63, true], "aps.15.28": [63, true], "aps.15.29": [64, true], "aps.15.30": [64, true]}}, "CHA": {"total": 3651, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [65, true], "fun1.2": [70, true], "fun1.3": [70, true], "fun1.4": [77, true], "fun1.5": [93, true], "fun2.1": [67, true], "fun2.2": [74, true], "fun2.3": [75, true], "fun2.4": [89, true], "fun2.5": [93, true], "fun3.1": [57, true], "fun3.2": [59, true], "fun3.3": [71, true], "fun3.4": [80, true], "fun3.5": [93, true], "fun4.1": [53, true], "fun4.2": [54, true], "fun4.3": [65, true], "fun4.4": [74, true], "fun4.5": [87, true], "fun5.1": [51, true], "fun5.2": [51, true], "fun5.3": [52, true], "fun5.4": [54, true], "fun5.5": [55, true], "fun6.1": [48, true], "fun6.2": [48, true], "fun6.3": [48, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [10, false], "fun7.2": [10, false], "fun7.3": [12, false], "fun7.4": [51, false], "fun7.5": [17, false], "fun8.1": [67, true], "fun8.2": [65, true], "fun8.3": [66, true], "fun8.4": [57, true], "fun8.5": [70, true], "fun9.1": [67, true], "fun9.2": [68, true], "fun9.3": [69, true], "fun9.4": [74, true], "fun9.5": [76, true]}}}, {"label": "pure.exp_abs.start.none", "spec": ["pure", "exp_abs", "start", "none"], "APS": {"total": 19730, "solved": 72, "n": 154, "over": 1, "per": {"aps.01.00": [55, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [200, false], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [28, true], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [38, true], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [53, true], "aps.04.13": [50, true], "aps.05.00": [17, true], "aps.06.00": [19, true], "aps.06.01": [31, true], "aps.06.02": [34, true], "aps.06.03": [35, true], "aps.06.04": [34, true], "aps.06.05": [36, true], "aps.06.06": [37, true], "aps.06.07": [38, true], "aps.06.08": [38, true], "aps.06.09": [38, true], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [68, true], "aps.08.00": [200, false], "aps.08.01": [48, true], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [34, true], "aps.09.01": [34, true], "aps.09.02": [200, false], "aps.09.03": [53, true], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [72, true], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [53, true], "aps.11.01": [200, false], "aps.11.02": [21, true], "aps.11.03": [26, true], "aps.12.00": [71, true], "aps.12.01": [200, false], "aps.12.02": [160, true], "aps.12.03": [43, true], "aps.12.04": [49, true], "aps.12.05": [54, true], "aps.12.06": [61, true], "aps.12.07": [67, true], "aps.12.08": [67, true], "aps.12.09": [58, true], "aps.12.10": [51, true], "aps.12.11": [45, true], "aps.12.12": [40, true], "aps.12.13": [37, true], "aps.12.14": [33, true], "aps.12.15": [29, true], "aps.12.16": [25, true], "aps.12.17": [22, true], "aps.12.18": [20, true], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [31, true], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [71, true], "aps.15.09": [63, true], "aps.15.10": [56, true], "aps.15.11": [50, true], "aps.15.12": [45, true], "aps.15.13": [41, true], "aps.15.14": [39, true], "aps.15.15": [42, true], "aps.15.16": [43, true], "aps.15.17": [43, true], "aps.15.18": [44, true], "aps.15.19": [46, true], "aps.15.20": [47, true], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [64, true], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [59, true], "aps.15.28": [69, true], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 8380, "solved": 4, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [32, true], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [61, true], "fun9.3": [41, true], "fun9.4": [200, false], "fun9.5": [46, true]}}}, {"label": "pure.exp_abs.bracket.step", "spec": ["pure", "exp_abs", "bracket", "step"], "APS": {"total": 5525, "solved": 153, "n": 154, "over": 11, "per": {"aps.01.00": [37, true], "aps.02.00": [16, true], "aps.02.01": [14, true], "aps.02.02": [14, true], "aps.02.03": [18, true], "aps.02.04": [14, true], "aps.02.05": [18, true], "aps.02.06": [15, true], "aps.02.07": [20, true], "aps.02.08": [22, true], "aps.02.09": [21, true], "aps.03.00": [100, true], "aps.03.01": [57, true], "aps.03.02": [60, true], "aps.04.00": [20, true], "aps.04.01": [44, true], "aps.04.02": [36, true], "aps.04.03": [27, true], "aps.04.04": [24, true], "aps.04.05": [39, true], "aps.04.06": [56, true], "aps.04.07": [74, true], "aps.04.08": [33, true], "aps.04.09": [23, true], "aps.04.10": [22, true], "aps.04.11": [22, true], "aps.04.12": [50, true], "aps.04.13": [55, true], "aps.05.00": [11, true], "aps.06.00": [20, true], "aps.06.01": [30, true], "aps.06.02": [32, true], "aps.06.03": [34, true], "aps.06.04": [34, true], "aps.06.05": [36, true], "aps.06.06": [37, true], "aps.06.07": [38, true], "aps.06.08": [38, true], "aps.06.09": [37, true], "aps.07.00": [13, true], "aps.07.01": [13, true], "aps.07.02": [15, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [121, true], "aps.08.03": [63, true], "aps.08.04": [18, true], "aps.09.00": [34, true], "aps.09.01": [34, true], "aps.09.02": [13, true], "aps.09.03": [14, true], "aps.09.04": [16, true], "aps.09.05": [18, true], "aps.09.06": [19, true], "aps.10.00": [51, true], "aps.10.01": [114, true], "aps.10.02": [15, true], "aps.10.03": [79, true], "aps.10.04": [103, true], "aps.11.00": [16, true], "aps.11.01": [31, true], "aps.11.02": [20, true], "aps.11.03": [19, true], "aps.12.00": [12, true], "aps.12.01": [31, true], "aps.12.02": [38, true], "aps.12.03": [44, true], "aps.12.04": [49, true], "aps.12.05": [54, true], "aps.12.06": [61, true], "aps.12.07": [67, true], "aps.12.08": [71, true], "aps.12.09": [76, true], "aps.12.10": [79, true], "aps.12.11": [114, true], "aps.12.12": [117, true], "aps.12.13": [119, true], "aps.12.14": [118, true], "aps.12.15": [119, true], "aps.12.16": [122, true], "aps.12.17": [117, true], "aps.12.18": [34, true], "aps.13.00": [11, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [25, true], "aps.15.01": [26, true], "aps.15.02": [26, true], "aps.15.03": [26, true], "aps.15.04": [26, true], "aps.15.05": [26, true], "aps.15.06": [26, true], "aps.15.07": [26, true], "aps.15.08": [26, true], "aps.15.09": [26, true], "aps.15.10": [26, true], "aps.15.11": [26, true], "aps.15.12": [26, true], "aps.15.13": [26, true], "aps.15.14": [26, true], "aps.15.15": [26, true], "aps.15.16": [26, true], "aps.15.17": [35, true], "aps.15.18": [36, true], "aps.15.19": [37, true], "aps.15.20": [39, true], "aps.15.21": [36, true], "aps.15.22": [31, true], "aps.15.23": [45, true], "aps.15.24": [32, true], "aps.15.25": [32, true], "aps.15.26": [31, true], "aps.15.27": [31, true], "aps.15.28": [32, true], "aps.15.29": [32, true], "aps.15.30": [45, true]}}, "CHA": {"total": 3556, "solved": 40, "n": 45, "over": 3, "per": {"fun1.1": [65, true], "fun1.2": [80, true], "fun1.3": [22, true], "fun1.4": [24, true], "fun1.5": [38, true], "fun2.1": [116, true], "fun2.2": [54, true], "fun2.3": [72, true], "fun2.4": [58, true], "fun2.5": [53, true], "fun3.1": [98, true], "fun3.2": [102, true], "fun3.3": [111, true], "fun3.4": [113, true], "fun3.5": [120, true], "fun4.1": [82, true], "fun4.2": [86, true], "fun4.3": [89, true], "fun4.4": [99, true], "fun4.5": [89, true], "fun5.1": [90, true], "fun5.2": [82, true], "fun5.3": [75, true], "fun5.4": [79, true], "fun5.5": [80, true], "fun6.1": [78, true], "fun6.2": [73, true], "fun6.3": [56, true], "fun6.4": [62, true], "fun6.5": [66, true], "fun7.1": [11, false], "fun7.2": [8, false], "fun7.3": [18, false], "fun7.4": [8, false], "fun7.5": [9, false], "fun8.1": [16, true], "fun8.2": [41, true], "fun8.3": [24, true], "fun8.4": [41, true], "fun8.5": [33, true], "fun9.1": [11, true], "fun9.2": [24, true], "fun9.3": [20, true], "fun9.4": [18, true], "fun9.5": [16, true]}}}, {"label": "pure.exp_abs.start.project", "spec": ["pure", "exp_abs", "start", "project"], "APS": {"total": 11650, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [94, true], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [28, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [89, true], "aps.04.07": [88, true], "aps.04.08": [38, true], "aps.04.09": [88, true], "aps.04.10": [89, true], "aps.04.11": [89, true], "aps.04.12": [53, true], "aps.04.13": [50, true], "aps.05.00": [17, true], "aps.06.00": [19, true], "aps.06.01": [31, true], "aps.06.02": [34, true], "aps.06.03": [35, true], "aps.06.04": [34, true], "aps.06.05": [36, true], "aps.06.06": [37, true], "aps.06.07": [38, true], "aps.06.08": [38, true], "aps.06.09": [38, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [83, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [34, true], "aps.09.01": [34, true], "aps.09.02": [82, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [83, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [21, true], "aps.11.03": [26, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [43, true], "aps.12.04": [49, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [51, true], "aps.12.11": [45, true], "aps.12.12": [40, true], "aps.12.13": [37, true], "aps.12.14": [33, true], "aps.12.15": [29, true], "aps.12.16": [25, true], "aps.12.17": [22, true], "aps.12.18": [20, true], "aps.13.00": [52, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [31, true], "aps.15.01": [103, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [103, true], "aps.15.05": [103, true], "aps.15.06": [103, true], "aps.15.07": [103, true], "aps.15.08": [71, true], "aps.15.09": [63, true], "aps.15.10": [56, true], "aps.15.11": [50, true], "aps.15.12": [45, true], "aps.15.13": [41, true], "aps.15.14": [39, true], "aps.15.15": [42, true], "aps.15.16": [43, true], "aps.15.17": [43, true], "aps.15.18": [44, true], "aps.15.19": [46, true], "aps.15.20": [47, true], "aps.15.21": [103, true], "aps.15.22": [103, true], "aps.15.23": [103, true], "aps.15.24": [64, true], "aps.15.25": [103, true], "aps.15.26": [102, true], "aps.15.27": [59, true], "aps.15.28": [69, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 4970, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [152, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [123, true], "fun2.4": [150, true], "fun2.5": [163, true], "fun3.1": [89, true], "fun3.2": [92, true], "fun3.3": [113, true], "fun3.4": [124, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [52, false], "fun7.2": [51, false], "fun7.3": [54, false], "fun7.4": [57, false], "fun7.5": [97, false], "fun8.1": [32, true], "fun8.2": [87, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [97, true], "fun9.1": [83, true], "fun9.2": [87, true], "fun9.3": [41, true], "fun9.4": [92, true], "fun9.5": [46, true]}}}, {"label": "pure.exp_abs.start.safe", "spec": ["pure", "exp_abs", "start", "safe"], "APS": {"total": 11684, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [53, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [88, true], "aps.04.01": [83, true], "aps.04.02": [86, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [78, true], "aps.04.07": [89, true], "aps.04.08": [42, true], "aps.04.09": [27, true], "aps.04.10": [80, true], "aps.04.11": [46, true], "aps.04.12": [89, true], "aps.04.13": [43, true], "aps.05.00": [84, true], "aps.06.00": [20, true], "aps.06.01": [30, true], "aps.06.02": [32, true], "aps.06.03": [34, true], "aps.06.04": [34, true], "aps.06.05": [36, true], "aps.06.06": [37, true], "aps.06.07": [38, true], "aps.06.08": [38, true], "aps.06.09": [37, true], "aps.07.00": [83, true], "aps.07.01": [83, true], "aps.07.02": [73, true], "aps.08.00": [3, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [34, true], "aps.09.01": [34, true], "aps.09.02": [80, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [83, true], "aps.10.00": [82, true], "aps.10.01": [83, true], "aps.10.02": [76, true], "aps.10.03": [71, true], "aps.10.04": [76, true], "aps.11.00": [72, true], "aps.11.01": [80, true], "aps.11.02": [21, true], "aps.11.03": [26, true], "aps.12.00": [81, true], "aps.12.01": [97, true], "aps.12.02": [81, true], "aps.12.03": [44, true], "aps.12.04": [49, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [52, true], "aps.12.11": [46, true], "aps.12.12": [41, true], "aps.12.13": [37, true], "aps.12.14": [33, true], "aps.12.15": [30, true], "aps.12.16": [26, true], "aps.12.17": [23, true], "aps.12.18": [21, true], "aps.13.00": [9, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [103, true], "aps.15.01": [103, true], "aps.15.02": [80, true], "aps.15.03": [82, true], "aps.15.04": [79, true], "aps.15.05": [79, true], "aps.15.06": [76, true], "aps.15.07": [66, true], "aps.15.08": [74, true], "aps.15.09": [79, true], "aps.15.10": [79, true], "aps.15.11": [77, true], "aps.15.12": [84, true], "aps.15.13": [86, true], "aps.15.14": [103, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [60, true], "aps.15.21": [31, true], "aps.15.22": [47, true], "aps.15.23": [103, true], "aps.15.24": [81, true], "aps.15.25": [67, true], "aps.15.26": [81, true], "aps.15.27": [70, true], "aps.15.28": [48, true], "aps.15.29": [73, true], "aps.15.30": [68, true]}}, "CHA": {"total": 3913, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [77, true], "fun1.3": [86, true], "fun1.4": [91, true], "fun1.5": [109, true], "fun2.1": [69, true], "fun2.2": [86, true], "fun2.3": [60, true], "fun2.4": [105, true], "fun2.5": [110, true], "fun3.1": [65, true], "fun3.2": [66, true], "fun3.3": [84, true], "fun3.4": [94, true], "fun3.5": [109, true], "fun4.1": [55, true], "fun4.2": [58, true], "fun4.3": [76, true], "fun4.4": [82, true], "fun4.5": [96, true], "fun5.1": [50, true], "fun5.2": [55, true], "fun5.3": [54, true], "fun5.4": [56, true], "fun5.5": [57, true], "fun6.1": [47, true], "fun6.2": [48, true], "fun6.3": [51, true], "fun6.4": [53, true], "fun6.5": [54, true], "fun7.1": [9, false], "fun7.2": [11, false], "fun7.3": [15, false], "fun7.4": [20, false], "fun7.5": [22, false], "fun8.1": [74, true], "fun8.2": [87, true], "fun8.3": [77, true], "fun8.4": [74, true], "fun8.5": [82, true], "fun9.1": [82, true], "fun9.2": [81, true], "fun9.3": [41, true], "fun9.4": [34, true], "fun9.5": [95, true]}}}, {"label": "pure.exp_abs.bracket.both", "spec": ["pure", "exp_abs", "bracket", "both"], "APS": {"total": 3461, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [14, true], "aps.02.00": [18, true], "aps.02.01": [18, true], "aps.02.02": [14, true], "aps.02.03": [35, true], "aps.02.04": [19, true], "aps.02.05": [18, true], "aps.02.06": [26, true], "aps.02.07": [21, true], "aps.02.08": [26, true], "aps.02.09": [14, true], "aps.03.00": [25, true], "aps.03.01": [18, true], "aps.03.02": [19, true], "aps.04.00": [26, true], "aps.04.01": [20, true], "aps.04.02": [29, true], "aps.04.03": [17, true], "aps.04.04": [28, true], "aps.04.05": [27, true], "aps.04.06": [18, true], "aps.04.07": [23, true], "aps.04.08": [22, true], "aps.04.09": [29, true], "aps.04.10": [19, true], "aps.04.11": [33, true], "aps.04.12": [20, true], "aps.04.13": [20, true], "aps.05.00": [11, true], "aps.06.00": [16, true], "aps.06.01": [15, true], "aps.06.02": [13, true], "aps.06.03": [16, true], "aps.06.04": [17, true], "aps.06.05": [14, true], "aps.06.06": [21, true], "aps.06.07": [17, true], "aps.06.08": [18, true], "aps.06.09": [17, true], "aps.07.00": [15, true], "aps.07.01": [17, true], "aps.07.02": [15, true], "aps.08.00": [3, true], "aps.08.01": [20, true], "aps.08.02": [14, true], "aps.08.03": [13, true], "aps.08.04": [22, true], "aps.09.00": [17, true], "aps.09.01": [15, true], "aps.09.02": [20, true], "aps.09.03": [18, true], "aps.09.04": [16, true], "aps.09.05": [23, true], "aps.09.06": [19, true], "aps.10.00": [16, true], "aps.10.01": [16, true], "aps.10.02": [14, true], "aps.10.03": [25, true], "aps.10.04": [21, true], "aps.11.00": [18, true], "aps.11.01": [17, true], "aps.11.02": [30, true], "aps.11.03": [20, true], "aps.12.00": [12, true], "aps.12.01": [36, true], "aps.12.02": [17, true], "aps.12.03": [21, true], "aps.12.04": [34, true], "aps.12.05": [15, true], "aps.12.06": [15, true], "aps.12.07": [15, true], "aps.12.08": [22, true], "aps.12.09": [18, true], "aps.12.10": [19, true], "aps.12.11": [15, true], "aps.12.12": [15, true], "aps.12.13": [15, true], "aps.12.14": [15, true], "aps.12.15": [33, true], "aps.12.16": [18, true], "aps.12.17": [14, true], "aps.12.18": [16, true], "aps.13.00": [8, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [25, true], "aps.15.01": [26, true], "aps.15.02": [26, true], "aps.15.03": [26, true], "aps.15.04": [26, true], "aps.15.05": [26, true], "aps.15.06": [26, true], "aps.15.07": [26, true], "aps.15.08": [29, true], "aps.15.09": [28, true], "aps.15.10": [29, true], "aps.15.11": [28, true], "aps.15.12": [26, true], "aps.15.13": [35, true], "aps.15.14": [30, true], "aps.15.15": [30, true], "aps.15.16": [28, true], "aps.15.17": [27, true], "aps.15.18": [27, true], "aps.15.19": [26, true], "aps.15.20": [37, true], "aps.15.21": [29, true], "aps.15.22": [38, true], "aps.15.23": [31, true], "aps.15.24": [35, true], "aps.15.25": [33, true], "aps.15.26": [31, true], "aps.15.27": [31, true], "aps.15.28": [33, true], "aps.15.29": [40, true], "aps.15.30": [33, true]}}, "CHA": {"total": 2733, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [14, true], "fun1.2": [16, true], "fun1.3": [19, true], "fun1.4": [33, true], "fun1.5": [40, true], "fun2.1": [18, true], "fun2.2": [40, true], "fun2.3": [52, true], "fun2.4": [53, true], "fun2.5": [55, true], "fun3.1": [54, true], "fun3.2": [55, true], "fun3.3": [56, true], "fun3.4": [61, true], "fun3.5": [72, true], "fun4.1": [73, true], "fun4.2": [56, true], "fun4.3": [61, true], "fun4.4": [62, true], "fun4.5": [70, true], "fun5.1": [60, true], "fun5.2": [62, true], "fun5.3": [53, true], "fun5.4": [56, true], "fun5.5": [57, true], "fun6.1": [60, true], "fun6.2": [56, true], "fun6.3": [48, true], "fun6.4": [51, true], "fun6.5": [54, true], "fun7.1": [8, false], "fun7.2": [8, false], "fun7.3": [10, false], "fun7.4": [8, false], "fun7.5": [8, false], "fun8.1": [17, true], "fun8.2": [18, true], "fun8.3": [26, true], "fun8.4": [37, true], "fun8.5": [26, true], "fun9.1": [11, true], "fun9.2": [16, true], "fun9.3": [29, true], "fun9.4": [17, true], "fun9.5": [19, true]}}}, {"label": "pure.exp_abs.bracket.none", "spec": ["pure", "exp_abs", "bracket", "none"], "APS": {"total": 9917, "solved": 127, "n": 154, "over": 5, "per": {"aps.01.00": [37, true], "aps.02.00": [200, false], "aps.02.01": [53, true], "aps.02.02": [200, false], "aps.02.03": [60, true], "aps.02.04": [45, true], "aps.02.05": [18, true], "aps.02.06": [14, true], "aps.02.07": [44, true], "aps.02.08": [19, true], "aps.02.09": [18, true], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [18, true], "aps.06.00": [19, true], "aps.06.01": [31, true], "aps.06.02": [34, true], "aps.06.03": [35, true], "aps.06.04": [34, true], "aps.06.05": [36, true], "aps.06.06": [37, true], "aps.06.07": [38, true], "aps.06.08": [38, true], "aps.06.09": [38, true], "aps.07.00": [13, true], "aps.07.01": [14, true], "aps.07.02": [16, true], "aps.08.00": [11, true], "aps.08.01": [48, true], "aps.08.02": [124, true], "aps.08.03": [176, true], "aps.08.04": [200, false], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [13, true], "aps.09.03": [15, true], "aps.09.04": [17, true], "aps.09.05": [18, true], "aps.09.06": [20, true], "aps.10.00": [51, true], "aps.10.01": [120, true], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, true], "aps.12.00": [12, true], "aps.12.01": [31, true], "aps.12.02": [38, true], "aps.12.03": [44, true], "aps.12.04": [49, true], "aps.12.05": [54, true], "aps.12.06": [61, true], "aps.12.07": [68, true], "aps.12.08": [71, true], "aps.12.09": [76, true], "aps.12.10": [79, true], "aps.12.11": [83, true], "aps.12.12": [86, true], "aps.12.13": [88, true], "aps.12.14": [91, true], "aps.12.15": [94, true], "aps.12.16": [95, true], "aps.12.17": [97, true], "aps.12.18": [99, true], "aps.13.00": [200, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [31, true], "aps.15.01": [26, true], "aps.15.02": [26, true], "aps.15.03": [27, true], "aps.15.04": [27, true], "aps.15.05": [27, true], "aps.15.06": [27, true], "aps.15.07": [27, true], "aps.15.08": [27, true], "aps.15.09": [27, true], "aps.15.10": [27, true], "aps.15.11": [27, true], "aps.15.12": [27, true], "aps.15.13": [39, true], "aps.15.14": [27, true], "aps.15.15": [27, true], "aps.15.16": [27, true], "aps.15.17": [27, true], "aps.15.18": [28, true], "aps.15.19": [28, true], "aps.15.20": [28, true], "aps.15.21": [31, true], "aps.15.22": [29, true], "aps.15.23": [30, true], "aps.15.24": [31, true], "aps.15.25": [31, true], "aps.15.26": [31, true], "aps.15.27": [30, true], "aps.15.28": [31, true], "aps.15.29": [31, true], "aps.15.30": [31, true]}}, "CHA": {"total": 8051, "solved": 7, "n": 45, "over": 2, "per": {"fun1.1": [64, true], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [116, true], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [46, true], "fun2.5": [52, true], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [8, false], "fun7.3": [200, false], "fun7.4": [8, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [11, true], "fun9.2": [145, true], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [17, true]}}}, {"label": "pure.exp_abs.bracket.bracket", "spec": ["pure", "exp_abs", "bracket", "bracket"], "APS": {"total": 3401, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [19, true], "aps.02.00": [13, true], "aps.02.01": [16, true], "aps.02.02": [14, true], "aps.02.03": [20, true], "aps.02.04": [21, true], "aps.02.05": [18, true], "aps.02.06": [14, true], "aps.02.07": [21, true], "aps.02.08": [30, true], "aps.02.09": [18, true], "aps.03.00": [26, true], "aps.03.01": [21, true], "aps.03.02": [21, true], "aps.04.00": [18, true], "aps.04.01": [24, true], "aps.04.02": [19, true], "aps.04.03": [18, true], "aps.04.04": [20, true], "aps.04.05": [16, true], "aps.04.06": [16, true], "aps.04.07": [17, true], "aps.04.08": [17, true], "aps.04.09": [17, true], "aps.04.10": [20, true], "aps.04.11": [20, true], "aps.04.12": [24, true], "aps.04.13": [24, true], "aps.05.00": [18, true], "aps.06.00": [12, true], "aps.06.01": [17, true], "aps.06.02": [17, true], "aps.06.03": [14, true], "aps.06.04": [24, true], "aps.06.05": [21, true], "aps.06.06": [17, true], "aps.06.07": [17, true], "aps.06.08": [17, true], "aps.06.09": [23, true], "aps.07.00": [12, true], "aps.07.01": [15, true], "aps.07.02": [23, true], "aps.08.00": [30, true], "aps.08.01": [12, true], "aps.08.02": [17, true], "aps.08.03": [19, true], "aps.08.04": [15, true], "aps.09.00": [21, true], "aps.09.01": [23, true], "aps.09.02": [15, true], "aps.09.03": [16, true], "aps.09.04": [21, true], "aps.09.05": [20, true], "aps.09.06": [25, true], "aps.10.00": [12, true], "aps.10.01": [21, true], "aps.10.02": [19, true], "aps.10.03": [15, true], "aps.10.04": [35, true], "aps.11.00": [18, true], "aps.11.01": [17, true], "aps.11.02": [33, true], "aps.11.03": [19, true], "aps.12.00": [12, true], "aps.12.01": [17, true], "aps.12.02": [15, true], "aps.12.03": [21, true], "aps.12.04": [34, true], "aps.12.05": [15, true], "aps.12.06": [15, true], "aps.12.07": [15, true], "aps.12.08": [14, true], "aps.12.09": [13, true], "aps.12.10": [13, true], "aps.12.11": [24, true], "aps.12.12": [18, true], "aps.12.13": [14, true], "aps.12.14": [15, true], "aps.12.15": [15, true], "aps.12.16": [19, true], "aps.12.17": [26, true], "aps.12.18": [14, true], "aps.13.00": [9, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [31, true], "aps.15.01": [34, true], "aps.15.02": [26, true], "aps.15.03": [28, true], "aps.15.04": [27, true], "aps.15.05": [26, true], "aps.15.06": [31, true], "aps.15.07": [30, true], "aps.15.08": [30, true], "aps.15.09": [37, true], "aps.15.10": [30, true], "aps.15.11": [27, true], "aps.15.12": [31, true], "aps.15.13": [28, true], "aps.15.14": [42, true], "aps.15.15": [26, true], "aps.15.16": [27, true], "aps.15.17": [27, true], "aps.15.18": [27, true], "aps.15.19": [27, true], "aps.15.20": [27, true], "aps.15.21": [28, true], "aps.15.22": [36, true], "aps.15.23": [29, true], "aps.15.24": [30, true], "aps.15.25": [31, true], "aps.15.26": [44, true], "aps.15.27": [34, true], "aps.15.28": [29, true], "aps.15.29": [30, true], "aps.15.30": [30, true]}}, "CHA": {"total": 2818, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [24, true], "fun1.2": [16, true], "fun1.3": [18, true], "fun1.4": [30, true], "fun1.5": [45, true], "fun2.1": [13, true], "fun2.2": [39, true], "fun2.3": [55, true], "fun2.4": [46, true], "fun2.5": [63, true], "fun3.1": [48, true], "fun3.2": [49, true], "fun3.3": [59, true], "fun3.4": [66, true], "fun3.5": [75, true], "fun4.1": [82, true], "fun4.2": [84, true], "fun4.3": [90, true], "fun4.4": [95, true], "fun4.5": [78, true], "fun5.1": [49, true], "fun5.2": [59, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [50, true], "fun6.2": [61, true], "fun6.3": [54, true], "fun6.4": [56, true], "fun6.5": [58, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [8, false], "fun7.4": [8, false], "fun7.5": [11, false], "fun8.1": [19, true], "fun8.2": [16, true], "fun8.3": [23, true], "fun8.4": [24, true], "fun8.5": [25, true], "fun9.1": [12, true], "fun9.2": [18, true], "fun9.3": [35, true], "fun9.4": [21, true], "fun9.5": [17, true]}}}, {"label": "pure.cosine.derived3.project", "spec": ["pure", "cosine", "derived3", "project"], "APS": {"total": 14684, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [91, true], "aps.02.04": [90, true], "aps.02.05": [90, true], "aps.02.06": [90, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [93, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [89, true], "aps.04.03": [88, true], "aps.04.04": [89, true], "aps.04.05": [88, true], "aps.04.06": [77, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [83, true], "aps.06.01": [83, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [83, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [83, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [83, true], "aps.11.01": [82, true], "aps.11.02": [82, true], "aps.11.03": [83, true], "aps.12.00": [97, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [96, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [97, true], "aps.12.12": [97, true], "aps.12.13": [97, true], "aps.12.14": [97, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [95, true], "aps.12.18": [96, true], "aps.13.00": [51, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [103, true], "aps.15.01": [103, true], "aps.15.02": [102, true], "aps.15.03": [103, true], "aps.15.04": [103, true], "aps.15.05": [102, true], "aps.15.06": [103, true], "aps.15.07": [102, true], "aps.15.08": [102, true], "aps.15.09": [103, true], "aps.15.10": [103, true], "aps.15.11": [103, true], "aps.15.12": [103, true], "aps.15.13": [103, true], "aps.15.14": [103, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [103, true], "aps.15.18": [102, true], "aps.15.19": [103, true], "aps.15.20": [102, true], "aps.15.21": [103, true], "aps.15.22": [103, true], "aps.15.23": [103, true], "aps.15.24": [103, true], "aps.15.25": [103, true], "aps.15.26": [102, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 5100, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [83, true], "fun2.2": [110, true], "fun2.3": [123, true], "fun2.4": [150, true], "fun2.5": [162, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [152, true], "fun4.1": [89, true], "fun4.2": [78, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [52, false], "fun7.3": [54, false], "fun7.4": [57, false], "fun7.5": [59, false], "fun8.1": [84, true], "fun8.2": [87, true], "fun8.3": [90, true], "fun8.4": [93, true], "fun8.5": [96, true], "fun9.1": [83, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.exp_abs.derived.none", "spec": ["pure", "exp_abs", "derived", "none"], "APS": {"total": 3276, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [13, true], "aps.02.01": [11, true], "aps.02.02": [27, true], "aps.02.03": [12, true], "aps.02.04": [16, true], "aps.02.05": [12, true], "aps.02.06": [12, true], "aps.02.07": [14, true], "aps.02.08": [15, true], "aps.02.09": [15, true], "aps.03.00": [18, true], "aps.03.01": [22, true], "aps.03.02": [27, true], "aps.04.00": [14, true], "aps.04.01": [38, true], "aps.04.02": [14, true], "aps.04.03": [13, true], "aps.04.04": [14, true], "aps.04.05": [12, true], "aps.04.06": [12, true], "aps.04.07": [13, true], "aps.04.08": [13, true], "aps.04.09": [13, true], "aps.04.10": [20, true], "aps.04.11": [18, true], "aps.04.12": [22, true], "aps.04.13": [14, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [14, true], "aps.06.06": [15, true], "aps.06.07": [16, true], "aps.06.08": [16, true], "aps.06.09": [16, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [14, true], "aps.08.00": [35, true], "aps.08.01": [10, true], "aps.08.02": [11, true], "aps.08.03": [11, true], "aps.08.04": [12, true], "aps.09.00": [11, true], "aps.09.01": [26, true], "aps.09.02": [12, true], "aps.09.03": [13, true], "aps.09.04": [15, true], "aps.09.05": [18, true], "aps.09.06": [19, true], "aps.10.00": [36, true], "aps.10.01": [28, true], "aps.10.02": [33, true], "aps.10.03": [13, true], "aps.10.04": [37, true], "aps.11.00": [12, true], "aps.11.01": [16, true], "aps.11.02": [20, true], "aps.11.03": [20, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [12, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [12, true], "aps.12.06": [12, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [10, true], "aps.13.00": [200, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [33, true], "aps.15.01": [33, true], "aps.15.02": [33, true], "aps.15.03": [34, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [35, true], "aps.15.08": [35, true], "aps.15.09": [35, true], "aps.15.10": [34, true], "aps.15.11": [34, true], "aps.15.12": [34, true], "aps.15.13": [34, true], "aps.15.14": [34, true], "aps.15.15": [34, true], "aps.15.16": [34, true], "aps.15.17": [34, true], "aps.15.18": [34, true], "aps.15.19": [35, true], "aps.15.20": [34, true], "aps.15.21": [34, true], "aps.15.22": [34, true], "aps.15.23": [36, true], "aps.15.24": [34, true], "aps.15.25": [37, true], "aps.15.26": [38, true], "aps.15.27": [38, true], "aps.15.28": [36, true], "aps.15.29": [37, true], "aps.15.30": [36, true]}}, "CHA": {"total": 5661, "solved": 20, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [13, true], "fun1.3": [14, true], "fun1.4": [92, true], "fun1.5": [95, true], "fun2.1": [11, true], "fun2.2": [30, true], "fun2.3": [39, true], "fun2.4": [48, true], "fun2.5": [52, true], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [13, true], "fun8.2": [15, true], "fun8.3": [20, true], "fun8.4": [27, true], "fun8.5": [35, true], "fun9.1": [9, true], "fun9.2": [11, true], "fun9.3": [26, true], "fun9.4": [47, true], "fun9.5": [34, true]}}}, {"label": "pure.exp_abs.bracket.safe", "spec": ["pure", "exp_abs", "bracket", "safe"], "APS": {"total": 5185, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [37, true], "aps.02.00": [16, true], "aps.02.01": [14, true], "aps.02.02": [14, true], "aps.02.03": [18, true], "aps.02.04": [14, true], "aps.02.05": [18, true], "aps.02.06": [15, true], "aps.02.07": [20, true], "aps.02.08": [22, true], "aps.02.09": [21, true], "aps.03.00": [82, true], "aps.03.01": [57, true], "aps.03.02": [60, true], "aps.04.00": [20, true], "aps.04.01": [44, true], "aps.04.02": [36, true], "aps.04.03": [27, true], "aps.04.04": [24, true], "aps.04.05": [39, true], "aps.04.06": [77, true], "aps.04.07": [75, true], "aps.04.08": [33, true], "aps.04.09": [23, true], "aps.04.10": [22, true], "aps.04.11": [22, true], "aps.04.12": [50, true], "aps.04.13": [76, true], "aps.05.00": [11, true], "aps.06.00": [20, true], "aps.06.01": [30, true], "aps.06.02": [32, true], "aps.06.03": [34, true], "aps.06.04": [34, true], "aps.06.05": [36, true], "aps.06.06": [37, true], "aps.06.07": [38, true], "aps.06.08": [38, true], "aps.06.09": [37, true], "aps.07.00": [13, true], "aps.07.01": [13, true], "aps.07.02": [15, true], "aps.08.00": [3, true], "aps.08.01": [70, true], "aps.08.02": [65, true], "aps.08.03": [63, true], "aps.08.04": [18, true], "aps.09.00": [34, true], "aps.09.01": [34, true], "aps.09.02": [13, true], "aps.09.03": [14, true], "aps.09.04": [16, true], "aps.09.05": [18, true], "aps.09.06": [19, true], "aps.10.00": [51, true], "aps.10.01": [64, true], "aps.10.02": [15, true], "aps.10.03": [70, true], "aps.10.04": [66, true], "aps.11.00": [16, true], "aps.11.01": [31, true], "aps.11.02": [20, true], "aps.11.03": [19, true], "aps.12.00": [12, true], "aps.12.01": [31, true], "aps.12.02": [38, true], "aps.12.03": [44, true], "aps.12.04": [49, true], "aps.12.05": [84, true], "aps.12.06": [84, true], "aps.12.07": [80, true], "aps.12.08": [80, true], "aps.12.09": [79, true], "aps.12.10": [79, true], "aps.12.11": [71, true], "aps.12.12": [73, true], "aps.12.13": [75, true], "aps.12.14": [74, true], "aps.12.15": [73, true], "aps.12.16": [73, true], "aps.12.17": [74, true], "aps.12.18": [34, true], "aps.13.00": [11, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [25, true], "aps.15.01": [26, true], "aps.15.02": [26, true], "aps.15.03": [26, true], "aps.15.04": [26, true], "aps.15.05": [26, true], "aps.15.06": [26, true], "aps.15.07": [26, true], "aps.15.08": [26, true], "aps.15.09": [26, true], "aps.15.10": [26, true], "aps.15.11": [26, true], "aps.15.12": [26, true], "aps.15.13": [26, true], "aps.15.14": [26, true], "aps.15.15": [26, true], "aps.15.16": [26, true], "aps.15.17": [35, true], "aps.15.18": [36, true], "aps.15.19": [37, true], "aps.15.20": [39, true], "aps.15.21": [36, true], "aps.15.22": [31, true], "aps.15.23": [45, true], "aps.15.24": [32, true], "aps.15.25": [32, true], "aps.15.26": [31, true], "aps.15.27": [31, true], "aps.15.28": [32, true], "aps.15.29": [32, true], "aps.15.30": [45, true]}}, "CHA": {"total": 3478, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [65, true], "fun1.2": [76, true], "fun1.3": [22, true], "fun1.4": [24, true], "fun1.5": [38, true], "fun2.1": [64, true], "fun2.2": [54, true], "fun2.3": [72, true], "fun2.4": [58, true], "fun2.5": [53, true], "fun3.1": [88, true], "fun3.2": [92, true], "fun3.3": [111, true], "fun3.4": [113, true], "fun3.5": [120, true], "fun4.1": [82, true], "fun4.2": [86, true], "fun4.3": [89, true], "fun4.4": [99, true], "fun4.5": [89, true], "fun5.1": [88, true], "fun5.2": [82, true], "fun5.3": [75, true], "fun5.4": [79, true], "fun5.5": [80, true], "fun6.1": [78, true], "fun6.2": [73, true], "fun6.3": [56, true], "fun6.4": [62, true], "fun6.5": [66, true], "fun7.1": [11, false], "fun7.2": [8, false], "fun7.3": [18, false], "fun7.4": [8, false], "fun7.5": [9, false], "fun8.1": [16, true], "fun8.2": [41, true], "fun8.3": [24, true], "fun8.4": [41, true], "fun8.5": [33, true], "fun9.1": [11, true], "fun9.2": [24, true], "fun9.3": [20, true], "fun9.4": [18, true], "fun9.5": [16, true]}}}, {"label": "pure.exp_abs.bracket.credit", "spec": ["pure", "exp_abs", "bracket", "credit"], "APS": {"total": 4353, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [13, true], "aps.02.00": [45, true], "aps.02.01": [20, true], "aps.02.02": [46, true], "aps.02.03": [22, true], "aps.02.04": [12, true], "aps.02.05": [16, true], "aps.02.06": [14, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [16, true], "aps.06.00": [18, true], "aps.06.01": [20, true], "aps.06.02": [17, true], "aps.06.03": [14, true], "aps.06.04": [14, true], "aps.06.05": [15, true], "aps.06.06": [15, true], "aps.06.07": [19, true], "aps.06.08": [18, true], "aps.06.09": [21, true], "aps.07.00": [13, true], "aps.07.01": [14, true], "aps.07.02": [16, true], "aps.08.00": [11, true], "aps.08.01": [15, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [13, true], "aps.09.01": [14, true], "aps.09.02": [13, true], "aps.09.03": [15, true], "aps.09.04": [17, true], "aps.09.05": [18, true], "aps.09.06": [20, true], "aps.10.00": [14, true], "aps.10.01": [19, true], "aps.10.02": [16, true], "aps.10.03": [15, true], "aps.10.04": [16, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [12, true], "aps.12.01": [19, true], "aps.12.02": [21, true], "aps.12.03": [17, true], "aps.12.04": [18, true], "aps.12.05": [50, true], "aps.12.06": [17, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [15, true], "aps.12.10": [19, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [16, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [45, true], "aps.15.01": [26, true], "aps.15.02": [26, true], "aps.15.03": [27, true], "aps.15.04": [27, true], "aps.15.05": [27, true], "aps.15.06": [27, true], "aps.15.07": [27, true], "aps.15.08": [27, true], "aps.15.09": [27, true], "aps.15.10": [27, true], "aps.15.11": [27, true], "aps.15.12": [27, true], "aps.15.13": [45, true], "aps.15.14": [27, true], "aps.15.15": [27, true], "aps.15.16": [27, true], "aps.15.17": [27, true], "aps.15.18": [28, true], "aps.15.19": [28, true], "aps.15.20": [28, true], "aps.15.21": [31, true], "aps.15.22": [29, true], "aps.15.23": [30, true], "aps.15.24": [31, true], "aps.15.25": [31, true], "aps.15.26": [31, true], "aps.15.27": [30, true], "aps.15.28": [31, true], "aps.15.29": [31, true], "aps.15.30": [31, true]}}, "CHA": {"total": 2907, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [18, true], "fun1.2": [27, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [54, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [52, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [7, false], "fun7.3": [10, false], "fun7.4": [8, false], "fun7.5": [11, false], "fun8.1": [20, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [11, true], "fun9.2": [15, true], "fun9.3": [47, true], "fun9.4": [44, true], "fun9.5": [17, true]}}}, {"label": "pure.exp_abs.derived.project", "spec": ["pure", "exp_abs", "derived", "project"], "APS": {"total": 3276, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [13, true], "aps.02.01": [11, true], "aps.02.02": [27, true], "aps.02.03": [12, true], "aps.02.04": [16, true], "aps.02.05": [12, true], "aps.02.06": [12, true], "aps.02.07": [14, true], "aps.02.08": [15, true], "aps.02.09": [15, true], "aps.03.00": [18, true], "aps.03.01": [22, true], "aps.03.02": [27, true], "aps.04.00": [14, true], "aps.04.01": [38, true], "aps.04.02": [14, true], "aps.04.03": [13, true], "aps.04.04": [14, true], "aps.04.05": [12, true], "aps.04.06": [12, true], "aps.04.07": [13, true], "aps.04.08": [13, true], "aps.04.09": [13, true], "aps.04.10": [20, true], "aps.04.11": [18, true], "aps.04.12": [22, true], "aps.04.13": [14, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [14, true], "aps.06.06": [15, true], "aps.06.07": [16, true], "aps.06.08": [16, true], "aps.06.09": [16, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [14, true], "aps.08.00": [35, true], "aps.08.01": [10, true], "aps.08.02": [11, true], "aps.08.03": [11, true], "aps.08.04": [12, true], "aps.09.00": [11, true], "aps.09.01": [26, true], "aps.09.02": [12, true], "aps.09.03": [13, true], "aps.09.04": [15, true], "aps.09.05": [18, true], "aps.09.06": [19, true], "aps.10.00": [36, true], "aps.10.01": [28, true], "aps.10.02": [33, true], "aps.10.03": [13, true], "aps.10.04": [37, true], "aps.11.00": [12, true], "aps.11.01": [16, true], "aps.11.02": [20, true], "aps.11.03": [20, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [12, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [12, true], "aps.12.06": [12, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [10, true], "aps.13.00": [51, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [33, true], "aps.15.01": [33, true], "aps.15.02": [33, true], "aps.15.03": [34, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [35, true], "aps.15.08": [35, true], "aps.15.09": [35, true], "aps.15.10": [34, true], "aps.15.11": [34, true], "aps.15.12": [34, true], "aps.15.13": [34, true], "aps.15.14": [34, true], "aps.15.15": [34, true], "aps.15.16": [34, true], "aps.15.17": [34, true], "aps.15.18": [34, true], "aps.15.19": [35, true], "aps.15.20": [34, true], "aps.15.21": [34, true], "aps.15.22": [34, true], "aps.15.23": [36, true], "aps.15.24": [34, true], "aps.15.25": [37, true], "aps.15.26": [38, true], "aps.15.27": [38, true], "aps.15.28": [36, true], "aps.15.29": [37, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3770, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [13, true], "fun1.3": [14, true], "fun1.4": [92, true], "fun1.5": [153, true], "fun2.1": [11, true], "fun2.2": [30, true], "fun2.3": [39, true], "fun2.4": [48, true], "fun2.5": [52, true], "fun3.1": [88, true], "fun3.2": [93, true], "fun3.3": [112, true], "fun3.4": [124, true], "fun3.5": [152, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [124, true], "fun4.5": [153, true], "fun5.1": [89, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [48, false], "fun7.3": [54, false], "fun7.4": [57, false], "fun7.5": [59, false], "fun8.1": [13, true], "fun8.2": [15, true], "fun8.3": [20, true], "fun8.4": [27, true], "fun8.5": [35, true], "fun9.1": [9, true], "fun9.2": [11, true], "fun9.3": [26, true], "fun9.4": [47, true], "fun9.5": [34, true]}}}, {"label": "pure.exp_abs.derived.bracket", "spec": ["pure", "exp_abs", "derived", "bracket"], "APS": {"total": 8024, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [47, true], "aps.02.00": [46, true], "aps.02.01": [49, true], "aps.02.02": [47, true], "aps.02.03": [50, true], "aps.02.04": [50, true], "aps.02.05": [50, true], "aps.02.06": [51, true], "aps.02.07": [50, true], "aps.02.08": [51, true], "aps.02.09": [51, true], "aps.03.00": [53, true], "aps.03.01": [52, true], "aps.03.02": [50, true], "aps.04.00": [49, true], "aps.04.01": [48, true], "aps.04.02": [51, true], "aps.04.03": [51, true], "aps.04.04": [52, true], "aps.04.05": [50, true], "aps.04.06": [50, true], "aps.04.07": [50, true], "aps.04.08": [52, true], "aps.04.09": [52, true], "aps.04.10": [52, true], "aps.04.11": [53, true], "aps.04.12": [53, true], "aps.04.13": [51, true], "aps.05.00": [43, true], "aps.06.00": [46, true], "aps.06.01": [46, true], "aps.06.02": [46, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [47, true], "aps.06.06": [46, true], "aps.06.07": [45, true], "aps.06.08": [46, true], "aps.06.09": [46, true], "aps.07.00": [41, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [46, true], "aps.08.01": [44, true], "aps.08.02": [45, true], "aps.08.03": [44, true], "aps.08.04": [43, true], "aps.09.00": [46, true], "aps.09.01": [42, true], "aps.09.02": [44, true], "aps.09.03": [44, true], "aps.09.04": [42, true], "aps.09.05": [42, true], "aps.09.06": [40, true], "aps.10.00": [45, true], "aps.10.01": [46, true], "aps.10.02": [46, true], "aps.10.03": [45, true], "aps.10.04": [46, true], "aps.11.00": [33, true], "aps.11.01": [48, true], "aps.11.02": [49, true], "aps.11.03": [51, true], "aps.12.00": [45, true], "aps.12.01": [46, true], "aps.12.02": [47, true], "aps.12.03": [49, true], "aps.12.04": [49, true], "aps.12.05": [50, true], "aps.12.06": [49, true], "aps.12.07": [51, true], "aps.12.08": [49, true], "aps.12.09": [53, true], "aps.12.10": [54, true], "aps.12.11": [53, true], "aps.12.12": [54, true], "aps.12.13": [51, true], "aps.12.14": [52, true], "aps.12.15": [51, true], "aps.12.16": [48, true], "aps.12.17": [52, true], "aps.12.18": [52, true], "aps.13.00": [10, false], "aps.14.00": [56, true], "aps.14.01": [56, true], "aps.14.02": [56, true], "aps.14.03": [56, true], "aps.14.04": [56, true], "aps.14.05": [56, true], "aps.14.06": [56, true], "aps.14.07": [56, true], "aps.14.08": [56, true], "aps.14.09": [56, true], "aps.14.10": [56, true], "aps.14.11": [56, true], "aps.14.12": [56, true], "aps.14.13": [56, true], "aps.14.14": [56, true], "aps.14.15": [56, true], "aps.14.16": [56, true], "aps.14.17": [56, true], "aps.14.18": [56, true], "aps.14.19": [56, true], "aps.14.20": [56, true], "aps.14.21": [56, true], "aps.14.22": [56, true], "aps.14.23": [56, true], "aps.14.24": [56, true], "aps.14.25": [56, true], "aps.14.26": [56, true], "aps.14.27": [56, true], "aps.14.28": [56, true], "aps.14.29": [56, true], "aps.14.30": [56, true], "aps.14.31": [56, true], "aps.14.32": [56, true], "aps.14.33": [56, true], "aps.14.34": [56, true], "aps.14.35": [56, true], "aps.14.36": [56, true], "aps.14.37": [56, true], "aps.14.38": [56, true], "aps.14.39": [56, true], "aps.15.00": [55, true], "aps.15.01": [55, true], "aps.15.02": [52, true], "aps.15.03": [55, true], "aps.15.04": [55, true], "aps.15.05": [55, true], "aps.15.06": [55, true], "aps.15.07": [55, true], "aps.15.08": [55, true], "aps.15.09": [55, true], "aps.15.10": [55, true], "aps.15.11": [54, true], "aps.15.12": [54, true], "aps.15.13": [54, true], "aps.15.14": [55, true], "aps.15.15": [54, true], "aps.15.16": [54, true], "aps.15.17": [53, true], "aps.15.18": [54, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [55, true], "aps.15.22": [52, true], "aps.15.23": [55, true], "aps.15.24": [45, true], "aps.15.25": [52, true], "aps.15.26": [54, true], "aps.15.27": [55, true], "aps.15.28": [55, true], "aps.15.29": [54, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3667, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [47, true], "fun1.2": [51, true], "fun1.3": [52, true], "fun1.4": [62, true], "fun1.5": [89, true], "fun2.1": [46, true], "fun2.2": [64, true], "fun2.3": [69, true], "fun2.4": [81, true], "fun2.5": [87, true], "fun3.1": [58, true], "fun3.2": [61, true], "fun3.3": [75, true], "fun3.4": [81, true], "fun3.5": [99, true], "fun4.1": [82, true], "fun4.2": [86, true], "fun4.3": [97, true], "fun4.4": [108, true], "fun4.5": [134, true], "fun5.1": [65, true], "fun5.2": [67, true], "fun5.3": [67, true], "fun5.4": [73, true], "fun5.5": [75, true], "fun6.1": [54, true], "fun6.2": [48, true], "fun6.3": [57, true], "fun6.4": [59, true], "fun6.5": [60, true], "fun7.1": [10, false], "fun7.2": [7, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [15, false], "fun8.1": [45, true], "fun8.2": [48, true], "fun8.3": [51, true], "fun8.4": [55, true], "fun8.5": [57, true], "fun9.1": [45, true], "fun9.2": [49, true], "fun9.3": [52, true], "fun9.4": [54, true], "fun9.5": [57, true]}}}, {"label": "pure.exp_abs.bracket.project", "spec": ["pure", "exp_abs", "bracket", "project"], "APS": {"total": 6379, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [37, true], "aps.02.00": [57, true], "aps.02.01": [53, true], "aps.02.02": [61, true], "aps.02.03": [60, true], "aps.02.04": [45, true], "aps.02.05": [18, true], "aps.02.06": [14, true], "aps.02.07": [44, true], "aps.02.08": [19, true], "aps.02.09": [18, true], "aps.03.00": [94, true], "aps.03.01": [67, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [18, true], "aps.06.00": [19, true], "aps.06.01": [31, true], "aps.06.02": [34, true], "aps.06.03": [35, true], "aps.06.04": [34, true], "aps.06.05": [36, true], "aps.06.06": [37, true], "aps.06.07": [38, true], "aps.06.08": [38, true], "aps.06.09": [38, true], "aps.07.00": [13, true], "aps.07.01": [14, true], "aps.07.02": [16, true], "aps.08.00": [11, true], "aps.08.01": [69, true], "aps.08.02": [64, true], "aps.08.03": [60, true], "aps.08.04": [56, true], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [13, true], "aps.09.03": [15, true], "aps.09.04": [17, true], "aps.09.05": [18, true], "aps.09.06": [20, true], "aps.10.00": [51, true], "aps.10.01": [65, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [52, true], "aps.11.00": [82, true], "aps.11.01": [72, true], "aps.11.02": [58, true], "aps.11.03": [57, true], "aps.12.00": [12, true], "aps.12.01": [31, true], "aps.12.02": [38, true], "aps.12.03": [44, true], "aps.12.04": [49, true], "aps.12.05": [83, true], "aps.12.06": [83, true], "aps.12.07": [80, true], "aps.12.08": [80, true], "aps.12.09": [78, true], "aps.12.10": [78, true], "aps.12.11": [73, true], "aps.12.12": [74, true], "aps.12.13": [74, true], "aps.12.14": [73, true], "aps.12.15": [73, true], "aps.12.16": [74, true], "aps.12.17": [73, true], "aps.12.18": [72, true], "aps.13.00": [51, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [31, true], "aps.15.01": [26, true], "aps.15.02": [26, true], "aps.15.03": [27, true], "aps.15.04": [27, true], "aps.15.05": [27, true], "aps.15.06": [27, true], "aps.15.07": [27, true], "aps.15.08": [27, true], "aps.15.09": [27, true], "aps.15.10": [27, true], "aps.15.11": [27, true], "aps.15.12": [27, true], "aps.15.13": [39, true], "aps.15.14": [27, true], "aps.15.15": [27, true], "aps.15.16": [27, true], "aps.15.17": [27, true], "aps.15.18": [28, true], "aps.15.19": [28, true], "aps.15.20": [28, true], "aps.15.21": [31, true], "aps.15.22": [29, true], "aps.15.23": [30, true], "aps.15.24": [31, true], "aps.15.25": [31, true], "aps.15.26": [31, true], "aps.15.27": [30, true], "aps.15.28": [31, true], "aps.15.29": [31, true], "aps.15.30": [31, true]}}, "CHA": {"total": 4595, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [64, true], "fun1.2": [59, true], "fun1.3": [69, true], "fun1.4": [112, true], "fun1.5": [152, true], "fun2.1": [63, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [46, true], "fun2.5": [52, true], "fun3.1": [88, true], "fun3.2": [92, true], "fun3.3": [112, true], "fun3.4": [124, true], "fun3.5": [152, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [8, false], "fun7.3": [53, false], "fun7.4": [8, false], "fun7.5": [60, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [11, true], "fun9.2": [61, true], "fun9.3": [90, true], "fun9.4": [70, true], "fun9.5": [17, true]}}}, {"label": "pure.exp_abs.derived.both", "spec": ["pure", "exp_abs", "derived", "both"], "APS": {"total": 8099, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [49, true], "aps.02.00": [48, true], "aps.02.01": [49, true], "aps.02.02": [47, true], "aps.02.03": [51, true], "aps.02.04": [51, true], "aps.02.05": [51, true], "aps.02.06": [51, true], "aps.02.07": [51, true], "aps.02.08": [52, true], "aps.02.09": [52, true], "aps.03.00": [46, true], "aps.03.01": [54, true], "aps.03.02": [49, true], "aps.04.00": [52, true], "aps.04.01": [51, true], "aps.04.02": [50, true], "aps.04.03": [47, true], "aps.04.04": [50, true], "aps.04.05": [50, true], "aps.04.06": [50, true], "aps.04.07": [51, true], "aps.04.08": [51, true], "aps.04.09": [51, true], "aps.04.10": [49, true], "aps.04.11": [51, true], "aps.04.12": [51, true], "aps.04.13": [50, true], "aps.05.00": [42, true], "aps.06.00": [46, true], "aps.06.01": [47, true], "aps.06.02": [46, true], "aps.06.03": [44, true], "aps.06.04": [44, true], "aps.06.05": [46, true], "aps.06.06": [47, true], "aps.06.07": [45, true], "aps.06.08": [46, true], "aps.06.09": [46, true], "aps.07.00": [42, true], "aps.07.01": [44, true], "aps.07.02": [43, true], "aps.08.00": [47, true], "aps.08.01": [47, true], "aps.08.02": [47, true], "aps.08.03": [42, true], "aps.08.04": [43, true], "aps.09.00": [48, true], "aps.09.01": [44, true], "aps.09.02": [44, true], "aps.09.03": [45, true], "aps.09.04": [43, true], "aps.09.05": [42, true], "aps.09.06": [40, true], "aps.10.00": [46, true], "aps.10.01": [47, true], "aps.10.02": [47, true], "aps.10.03": [47, true], "aps.10.04": [46, true], "aps.11.00": [34, true], "aps.11.01": [47, true], "aps.11.02": [43, true], "aps.11.03": [49, true], "aps.12.00": [46, true], "aps.12.01": [46, true], "aps.12.02": [48, true], "aps.12.03": [49, true], "aps.12.04": [49, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [53, true], "aps.12.08": [52, true], "aps.12.09": [52, true], "aps.12.10": [50, true], "aps.12.11": [52, true], "aps.12.12": [51, true], "aps.12.13": [53, true], "aps.12.14": [52, true], "aps.12.15": [54, true], "aps.12.16": [54, true], "aps.12.17": [52, true], "aps.12.18": [52, true], "aps.13.00": [6, false], "aps.14.00": [57, true], "aps.14.01": [57, true], "aps.14.02": [57, true], "aps.14.03": [57, true], "aps.14.04": [57, true], "aps.14.05": [57, true], "aps.14.06": [57, true], "aps.14.07": [57, true], "aps.14.08": [57, true], "aps.14.09": [57, true], "aps.14.10": [57, true], "aps.14.11": [57, true], "aps.14.12": [57, true], "aps.14.13": [57, true], "aps.14.14": [57, true], "aps.14.15": [57, true], "aps.14.16": [57, true], "aps.14.17": [57, true], "aps.14.18": [57, true], "aps.14.19": [57, true], "aps.14.20": [57, true], "aps.14.21": [57, true], "aps.14.22": [57, true], "aps.14.23": [57, true], "aps.14.24": [57, true], "aps.14.25": [57, true], "aps.14.26": [57, true], "aps.14.27": [57, true], "aps.14.28": [57, true], "aps.14.29": [57, true], "aps.14.30": [57, true], "aps.14.31": [57, true], "aps.14.32": [57, true], "aps.14.33": [57, true], "aps.14.34": [57, true], "aps.14.35": [57, true], "aps.14.36": [57, true], "aps.14.37": [57, true], "aps.14.38": [57, true], "aps.14.39": [57, true], "aps.15.00": [56, true], "aps.15.01": [56, true], "aps.15.02": [53, true], "aps.15.03": [56, true], "aps.15.04": [56, true], "aps.15.05": [57, true], "aps.15.06": [56, true], "aps.15.07": [56, true], "aps.15.08": [56, true], "aps.15.09": [55, true], "aps.15.10": [55, true], "aps.15.11": [55, true], "aps.15.12": [55, true], "aps.15.13": [55, true], "aps.15.14": [55, true], "aps.15.15": [55, true], "aps.15.16": [54, true], "aps.15.17": [54, true], "aps.15.18": [54, true], "aps.15.19": [54, true], "aps.15.20": [53, true], "aps.15.21": [55, true], "aps.15.22": [54, true], "aps.15.23": [55, true], "aps.15.24": [46, true], "aps.15.25": [52, true], "aps.15.26": [55, true], "aps.15.27": [54, true], "aps.15.28": [55, true], "aps.15.29": [54, true], "aps.15.30": [47, true]}}, "CHA": {"total": 3614, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [46, true], "fun1.2": [53, true], "fun1.3": [55, true], "fun1.4": [66, true], "fun1.5": [96, true], "fun2.1": [47, true], "fun2.2": [65, true], "fun2.3": [68, true], "fun2.4": [82, true], "fun2.5": [79, true], "fun3.1": [65, true], "fun3.2": [69, true], "fun3.3": [83, true], "fun3.4": [88, true], "fun3.5": [108, true], "fun4.1": [69, true], "fun4.2": [63, true], "fun4.3": [78, true], "fun4.4": [91, true], "fun4.5": [112, true], "fun5.1": [69, true], "fun5.2": [68, true], "fun5.3": [72, true], "fun5.4": [77, true], "fun5.5": [79, true], "fun6.1": [54, true], "fun6.2": [57, true], "fun6.3": [50, true], "fun6.4": [50, true], "fun6.5": [50, true], "fun7.1": [6, false], "fun7.2": [9, false], "fun7.3": [8, false], "fun7.4": [14, false], "fun7.5": [12, false], "fun8.1": [37, true], "fun8.2": [50, true], "fun8.3": [49, true], "fun8.4": [55, true], "fun8.5": [58, true], "fun9.1": [45, true], "fun9.2": [49, true], "fun9.3": [53, true], "fun9.4": [54, true], "fun9.5": [55, true]}}}, {"label": "pure.exp_abs.derived.safe", "spec": ["pure", "exp_abs", "derived", "safe"], "APS": {"total": 3316, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [15, true], "aps.02.01": [30, true], "aps.02.02": [12, true], "aps.02.03": [14, true], "aps.02.04": [13, true], "aps.02.05": [14, true], "aps.02.06": [41, true], "aps.02.07": [13, true], "aps.02.08": [12, true], "aps.02.09": [12, true], "aps.03.00": [18, true], "aps.03.01": [19, true], "aps.03.02": [20, true], "aps.04.00": [16, true], "aps.04.01": [40, true], "aps.04.02": [34, true], "aps.04.03": [15, true], "aps.04.04": [15, true], "aps.04.05": [16, true], "aps.04.06": [15, true], "aps.04.07": [16, true], "aps.04.08": [16, true], "aps.04.09": [17, true], "aps.04.10": [18, true], "aps.04.11": [17, true], "aps.04.12": [17, true], "aps.04.13": [18, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [15, true], "aps.06.07": [16, true], "aps.06.08": [16, true], "aps.06.09": [16, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [14, true], "aps.08.00": [35, true], "aps.08.01": [10, true], "aps.08.02": [11, true], "aps.08.03": [16, true], "aps.08.04": [12, true], "aps.09.00": [11, true], "aps.09.01": [26, true], "aps.09.02": [12, true], "aps.09.03": [13, true], "aps.09.04": [15, true], "aps.09.05": [18, true], "aps.09.06": [19, true], "aps.10.00": [36, true], "aps.10.01": [28, true], "aps.10.02": [16, true], "aps.10.03": [17, true], "aps.10.04": [38, true], "aps.11.00": [10, true], "aps.11.01": [12, true], "aps.11.02": [18, true], "aps.11.03": [19, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [12, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [12, true], "aps.12.06": [12, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [33, true], "aps.15.01": [33, true], "aps.15.02": [33, true], "aps.15.03": [34, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [35, true], "aps.15.08": [35, true], "aps.15.09": [35, true], "aps.15.10": [34, true], "aps.15.11": [34, true], "aps.15.12": [34, true], "aps.15.13": [34, true], "aps.15.14": [34, true], "aps.15.15": [34, true], "aps.15.16": [34, true], "aps.15.17": [34, true], "aps.15.18": [34, true], "aps.15.19": [35, true], "aps.15.20": [34, true], "aps.15.21": [34, true], "aps.15.22": [34, true], "aps.15.23": [36, true], "aps.15.24": [34, true], "aps.15.25": [37, true], "aps.15.26": [38, true], "aps.15.27": [38, true], "aps.15.28": [36, true], "aps.15.29": [37, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3439, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [38, true], "fun1.3": [38, true], "fun1.4": [32, true], "fun1.5": [80, true], "fun2.1": [12, true], "fun2.2": [29, true], "fun2.3": [36, true], "fun2.4": [47, true], "fun2.5": [57, true], "fun3.1": [87, true], "fun3.2": [91, true], "fun3.3": [111, true], "fun3.4": [122, true], "fun3.5": [146, true], "fun4.1": [88, true], "fun4.2": [93, true], "fun4.3": [112, true], "fun4.4": [124, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [61, true], "fun6.2": [52, true], "fun6.3": [60, true], "fun6.4": [64, true], "fun6.5": [64, true], "fun7.1": [10, false], "fun7.2": [12, false], "fun7.3": [13, false], "fun7.4": [17, false], "fun7.5": [15, false], "fun8.1": [12, true], "fun8.2": [12, true], "fun8.3": [17, true], "fun8.4": [17, true], "fun8.5": [22, true], "fun9.1": [9, true], "fun9.2": [12, true], "fun9.3": [16, true], "fun9.4": [20, true], "fun9.5": [19, true]}}}, {"label": "pure.cosine.derived3.safe", "spec": ["pure", "cosine", "derived3", "safe"], "APS": {"total": 14031, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [85, true], "aps.02.02": [89, true], "aps.02.03": [88, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [88, true], "aps.04.07": [89, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [89, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [85, true], "aps.06.00": [83, true], "aps.06.01": [82, true], "aps.06.02": [82, true], "aps.06.03": [83, true], "aps.06.04": [81, true], "aps.06.05": [83, true], "aps.06.06": [81, true], "aps.06.07": [80, true], "aps.06.08": [80, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [79, true], "aps.08.00": [82, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [81, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [82, true], "aps.11.02": [82, true], "aps.11.03": [83, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [96, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [96, true], "aps.12.12": [96, true], "aps.12.13": [97, true], "aps.12.14": [95, true], "aps.12.15": [96, true], "aps.12.16": [97, true], "aps.12.17": [96, true], "aps.12.18": [97, true], "aps.13.00": [11, false], "aps.14.00": [101, true], "aps.14.01": [101, true], "aps.14.02": [101, true], "aps.14.03": [101, true], "aps.14.04": [101, true], "aps.14.05": [101, true], "aps.14.06": [101, true], "aps.14.07": [101, true], "aps.14.08": [101, true], "aps.14.09": [101, true], "aps.14.10": [101, true], "aps.14.11": [101, true], "aps.14.12": [101, true], "aps.14.13": [101, true], "aps.14.14": [101, true], "aps.14.15": [101, true], "aps.14.16": [101, true], "aps.14.17": [101, true], "aps.14.18": [101, true], "aps.14.19": [101, true], "aps.14.20": [101, true], "aps.14.21": [101, true], "aps.14.22": [101, true], "aps.14.23": [101, true], "aps.14.24": [101, true], "aps.14.25": [101, true], "aps.14.26": [101, true], "aps.14.27": [101, true], "aps.14.28": [101, true], "aps.14.29": [101, true], "aps.14.30": [101, true], "aps.14.31": [101, true], "aps.14.32": [101, true], "aps.14.33": [101, true], "aps.14.34": [101, true], "aps.14.35": [101, true], "aps.14.36": [101, true], "aps.14.37": [101, true], "aps.14.38": [101, true], "aps.14.39": [101, true], "aps.15.00": [82, true], "aps.15.01": [82, true], "aps.15.02": [84, true], "aps.15.03": [84, true], "aps.15.04": [80, true], "aps.15.05": [83, true], "aps.15.06": [86, true], "aps.15.07": [85, true], "aps.15.08": [84, true], "aps.15.09": [86, true], "aps.15.10": [85, true], "aps.15.11": [80, true], "aps.15.12": [85, true], "aps.15.13": [85, true], "aps.15.14": [81, true], "aps.15.15": [85, true], "aps.15.16": [83, true], "aps.15.17": [84, true], "aps.15.18": [85, true], "aps.15.19": [83, true], "aps.15.20": [85, true], "aps.15.21": [82, true], "aps.15.22": [86, true], "aps.15.23": [81, true], "aps.15.24": [86, true], "aps.15.25": [80, true], "aps.15.26": [85, true], "aps.15.27": [81, true], "aps.15.28": [80, true], "aps.15.29": [84, true], "aps.15.30": [83, true]}}, "CHA": {"total": 4773, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [89, true], "fun1.3": [96, true], "fun1.4": [112, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [104, true], "fun2.3": [104, true], "fun2.4": [129, true], "fun2.5": [129, true], "fun3.1": [78, true], "fun3.2": [93, true], "fun3.3": [107, true], "fun3.4": [124, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [42, true], "fun6.2": [47, true], "fun6.3": [44, true], "fun6.4": [47, true], "fun6.5": [49, true], "fun7.1": [11, false], "fun7.2": [7, false], "fun7.3": [14, false], "fun7.4": [22, false], "fun7.5": [22, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [91, true], "fun8.4": [89, true], "fun8.5": [88, true], "fun9.1": [79, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.exp_abs.derived.credit", "spec": ["pure", "exp_abs", "derived", "credit"], "APS": {"total": 6092, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [34, true], "aps.02.04": [47, true], "aps.02.05": [44, true], "aps.02.06": [27, true], "aps.02.07": [38, true], "aps.02.08": [10, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [30, true], "aps.06.00": [24, true], "aps.06.01": [36, true], "aps.06.02": [10, true], "aps.06.03": [24, true], "aps.06.04": [11, true], "aps.06.05": [42, true], "aps.06.06": [38, true], "aps.06.07": [43, true], "aps.06.08": [41, true], "aps.06.09": [43, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [14, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [39, true], "aps.09.00": [38, true], "aps.09.01": [21, true], "aps.09.02": [22, true], "aps.09.03": [31, true], "aps.09.04": [34, true], "aps.09.05": [18, true], "aps.09.06": [19, true], "aps.10.00": [38, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [40, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [12, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [12, true], "aps.12.06": [22, true], "aps.12.07": [37, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [45, true], "aps.12.17": [50, true], "aps.12.18": [48, true], "aps.13.00": [9, false], "aps.14.00": [35, true], "aps.14.01": [35, true], "aps.14.02": [35, true], "aps.14.03": [35, true], "aps.14.04": [35, true], "aps.14.05": [35, true], "aps.14.06": [35, true], "aps.14.07": [35, true], "aps.14.08": [35, true], "aps.14.09": [35, true], "aps.14.10": [35, true], "aps.14.11": [35, true], "aps.14.12": [35, true], "aps.14.13": [35, true], "aps.14.14": [35, true], "aps.14.15": [35, true], "aps.14.16": [35, true], "aps.14.17": [35, true], "aps.14.18": [35, true], "aps.14.19": [35, true], "aps.14.20": [35, true], "aps.14.21": [35, true], "aps.14.22": [35, true], "aps.14.23": [35, true], "aps.14.24": [35, true], "aps.14.25": [35, true], "aps.14.26": [35, true], "aps.14.27": [35, true], "aps.14.28": [35, true], "aps.14.29": [35, true], "aps.14.30": [35, true], "aps.14.31": [35, true], "aps.14.32": [35, true], "aps.14.33": [35, true], "aps.14.34": [35, true], "aps.14.35": [35, true], "aps.14.36": [35, true], "aps.14.37": [35, true], "aps.14.38": [35, true], "aps.14.39": [35, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [48, true], "aps.15.05": [51, true], "aps.15.06": [50, true], "aps.15.07": [42, true], "aps.15.08": [47, true], "aps.15.09": [52, true], "aps.15.10": [52, true], "aps.15.11": [40, true], "aps.15.12": [46, true], "aps.15.13": [50, true], "aps.15.14": [47, true], "aps.15.15": [53, true], "aps.15.16": [50, true], "aps.15.17": [50, true], "aps.15.18": [47, true], "aps.15.19": [48, true], "aps.15.20": [47, true], "aps.15.21": [51, true], "aps.15.22": [49, true], "aps.15.23": [52, true], "aps.15.24": [34, true], "aps.15.25": [37, true], "aps.15.26": [47, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [48, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3069, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [14, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [26, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.exp_abs.derived3.step", "spec": ["pure", "exp_abs", "derived3", "step"], "APS": {"total": 3312, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [15, true], "aps.02.01": [14, true], "aps.02.02": [41, true], "aps.02.03": [16, true], "aps.02.04": [16, true], "aps.02.05": [25, true], "aps.02.06": [39, true], "aps.02.07": [29, true], "aps.02.08": [27, true], "aps.02.09": [24, true], "aps.03.00": [28, true], "aps.03.01": [26, true], "aps.03.02": [40, true], "aps.04.00": [17, true], "aps.04.01": [19, true], "aps.04.02": [44, true], "aps.04.03": [18, true], "aps.04.04": [24, true], "aps.04.05": [12, true], "aps.04.06": [15, true], "aps.04.07": [15, true], "aps.04.08": [17, true], "aps.04.09": [17, true], "aps.04.10": [16, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [16, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [11, true], "aps.06.06": [13, true], "aps.06.07": [13, true], "aps.06.08": [13, true], "aps.06.09": [14, true], "aps.07.00": [11, true], "aps.07.01": [11, true], "aps.07.02": [12, true], "aps.08.00": [35, true], "aps.08.01": [10, true], "aps.08.02": [10, true], "aps.08.03": [30, true], "aps.08.04": [11, true], "aps.09.00": [31, true], "aps.09.01": [12, true], "aps.09.02": [12, true], "aps.09.03": [11, true], "aps.09.04": [14, true], "aps.09.05": [16, true], "aps.09.06": [17, true], "aps.10.00": [9, true], "aps.10.01": [10, true], "aps.10.02": [33, true], "aps.10.03": [38, true], "aps.10.04": [18, true], "aps.11.00": [12, true], "aps.11.01": [12, true], "aps.11.02": [17, true], "aps.11.03": [16, true], "aps.12.00": [10, true], "aps.12.01": [10, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [9, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [11, true], "aps.12.18": [11, true], "aps.13.00": [10, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [32, true], "aps.15.01": [33, true], "aps.15.02": [32, true], "aps.15.03": [32, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [32, true], "aps.15.09": [32, true], "aps.15.10": [33, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [32, true], "aps.15.15": [32, true], "aps.15.16": [33, true], "aps.15.17": [33, true], "aps.15.18": [32, true], "aps.15.19": [33, true], "aps.15.20": [32, true], "aps.15.21": [31, true], "aps.15.22": [34, true], "aps.15.23": [34, true], "aps.15.24": [34, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [35, true], "aps.15.28": [36, true], "aps.15.29": [37, true], "aps.15.30": [37, true]}}, "CHA": {"total": 3580, "solved": 40, "n": 45, "over": 10, "per": {"fun1.1": [10, true], "fun1.2": [29, true], "fun1.3": [27, true], "fun1.4": [34, true], "fun1.5": [95, true], "fun2.1": [9, true], "fun2.2": [27, true], "fun2.3": [34, true], "fun2.4": [45, true], "fun2.5": [53, true], "fun3.1": [85, true], "fun3.2": [89, true], "fun3.3": [104, true], "fun3.4": [115, true], "fun3.5": [140, true], "fun4.1": [94, true], "fun4.2": [99, true], "fun4.3": [119, true], "fun4.4": [138, true], "fun4.5": [162, true], "fun5.1": [96, true], "fun5.2": [99, true], "fun5.3": [104, true], "fun5.4": [109, true], "fun5.5": [112, true], "fun6.1": [76, true], "fun6.2": [83, true], "fun6.3": [79, true], "fun6.4": [85, true], "fun6.5": [82, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [11, false], "fun7.4": [16, false], "fun7.5": [18, false], "fun8.1": [13, true], "fun8.2": [11, true], "fun8.3": [13, true], "fun8.4": [17, true], "fun8.5": [18, true], "fun9.1": [8, true], "fun9.2": [12, true], "fun9.3": [19, true], "fun9.4": [18, true], "fun9.5": [18, true]}}}, {"label": "pure.exp_abs.derived3.none", "spec": ["pure", "exp_abs", "derived3", "none"], "APS": {"total": 3264, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [20, true], "aps.02.01": [12, true], "aps.02.02": [34, true], "aps.02.03": [17, true], "aps.02.04": [19, true], "aps.02.05": [20, true], "aps.02.06": [37, true], "aps.02.07": [20, true], "aps.02.08": [20, true], "aps.02.09": [20, true], "aps.03.00": [19, true], "aps.03.01": [20, true], "aps.03.02": [42, true], "aps.04.00": [39, true], "aps.04.01": [16, true], "aps.04.02": [17, true], "aps.04.03": [20, true], "aps.04.04": [42, true], "aps.04.05": [12, true], "aps.04.06": [17, true], "aps.04.07": [17, true], "aps.04.08": [18, true], "aps.04.09": [16, true], "aps.04.10": [18, true], "aps.04.11": [16, true], "aps.04.12": [14, true], "aps.04.13": [20, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [11, true], "aps.06.06": [13, true], "aps.06.07": [13, true], "aps.06.08": [13, true], "aps.06.09": [14, true], "aps.07.00": [11, true], "aps.07.01": [11, true], "aps.07.02": [12, true], "aps.08.00": [35, true], "aps.08.01": [10, true], "aps.08.02": [10, true], "aps.08.03": [35, true], "aps.08.04": [13, true], "aps.09.00": [31, true], "aps.09.01": [12, true], "aps.09.02": [12, true], "aps.09.03": [11, true], "aps.09.04": [14, true], "aps.09.05": [16, true], "aps.09.06": [17, true], "aps.10.00": [9, true], "aps.10.01": [10, true], "aps.10.02": [11, true], "aps.10.03": [20, true], "aps.10.04": [17, true], "aps.11.00": [9, true], "aps.11.01": [12, true], "aps.11.02": [13, true], "aps.11.03": [14, true], "aps.12.00": [10, true], "aps.12.01": [10, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [9, true], "aps.12.18": [9, true], "aps.13.00": [144, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [32, true], "aps.15.01": [33, true], "aps.15.02": [32, true], "aps.15.03": [32, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [32, true], "aps.15.09": [32, true], "aps.15.10": [33, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [32, true], "aps.15.15": [32, true], "aps.15.16": [33, true], "aps.15.17": [33, true], "aps.15.18": [32, true], "aps.15.19": [33, true], "aps.15.20": [32, true], "aps.15.21": [31, true], "aps.15.22": [34, true], "aps.15.23": [34, true], "aps.15.24": [34, true], "aps.15.25": [38, true], "aps.15.26": [40, true], "aps.15.27": [39, true], "aps.15.28": [40, true], "aps.15.29": [39, true], "aps.15.30": [39, true]}}, "CHA": {"total": 4182, "solved": 35, "n": 45, "over": 10, "per": {"fun1.1": [10, true], "fun1.2": [25, true], "fun1.3": [32, true], "fun1.4": [43, true], "fun1.5": [46, true], "fun2.1": [9, true], "fun2.2": [27, true], "fun2.3": [33, true], "fun2.4": [45, true], "fun2.5": [51, true], "fun3.1": [58, true], "fun3.2": [81, true], "fun3.3": [83, true], "fun3.4": [95, true], "fun3.5": [86, true], "fun4.1": [93, true], "fun4.2": [107, true], "fun4.3": [131, true], "fun4.4": [143, true], "fun4.5": [182, true], "fun5.1": [126, true], "fun5.2": [111, true], "fun5.3": [110, true], "fun5.4": [137, true], "fun5.5": [137, true], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [74, false], "fun7.2": [51, false], "fun7.3": [200, false], "fun7.4": [128, false], "fun7.5": [200, false], "fun8.1": [10, true], "fun8.2": [11, true], "fun8.3": [14, true], "fun8.4": [18, true], "fun8.5": [21, true], "fun9.1": [8, true], "fun9.2": [11, true], "fun9.3": [21, true], "fun9.4": [38, true], "fun9.5": [29, true]}}}, {"label": "pure.exp_abs.derived3.project", "spec": ["pure", "exp_abs", "derived3", "project"], "APS": {"total": 3264, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [20, true], "aps.02.01": [12, true], "aps.02.02": [34, true], "aps.02.03": [17, true], "aps.02.04": [19, true], "aps.02.05": [20, true], "aps.02.06": [37, true], "aps.02.07": [20, true], "aps.02.08": [20, true], "aps.02.09": [20, true], "aps.03.00": [19, true], "aps.03.01": [20, true], "aps.03.02": [42, true], "aps.04.00": [39, true], "aps.04.01": [16, true], "aps.04.02": [17, true], "aps.04.03": [20, true], "aps.04.04": [42, true], "aps.04.05": [12, true], "aps.04.06": [17, true], "aps.04.07": [17, true], "aps.04.08": [18, true], "aps.04.09": [16, true], "aps.04.10": [18, true], "aps.04.11": [16, true], "aps.04.12": [14, true], "aps.04.13": [20, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [11, true], "aps.06.06": [13, true], "aps.06.07": [13, true], "aps.06.08": [13, true], "aps.06.09": [14, true], "aps.07.00": [11, true], "aps.07.01": [11, true], "aps.07.02": [12, true], "aps.08.00": [35, true], "aps.08.01": [10, true], "aps.08.02": [10, true], "aps.08.03": [35, true], "aps.08.04": [13, true], "aps.09.00": [31, true], "aps.09.01": [12, true], "aps.09.02": [12, true], "aps.09.03": [11, true], "aps.09.04": [14, true], "aps.09.05": [16, true], "aps.09.06": [17, true], "aps.10.00": [9, true], "aps.10.01": [10, true], "aps.10.02": [11, true], "aps.10.03": [20, true], "aps.10.04": [17, true], "aps.11.00": [9, true], "aps.11.01": [12, true], "aps.11.02": [13, true], "aps.11.03": [14, true], "aps.12.00": [10, true], "aps.12.01": [10, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [9, true], "aps.12.18": [9, true], "aps.13.00": [52, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [32, true], "aps.15.01": [33, true], "aps.15.02": [32, true], "aps.15.03": [32, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [32, true], "aps.15.09": [32, true], "aps.15.10": [33, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [32, true], "aps.15.15": [32, true], "aps.15.16": [33, true], "aps.15.17": [33, true], "aps.15.18": [32, true], "aps.15.19": [33, true], "aps.15.20": [32, true], "aps.15.21": [31, true], "aps.15.22": [34, true], "aps.15.23": [34, true], "aps.15.24": [34, true], "aps.15.25": [38, true], "aps.15.26": [40, true], "aps.15.27": [39, true], "aps.15.28": [40, true], "aps.15.29": [39, true], "aps.15.30": [39, true]}}, "CHA": {"total": 3388, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [10, true], "fun1.2": [25, true], "fun1.3": [32, true], "fun1.4": [43, true], "fun1.5": [46, true], "fun2.1": [9, true], "fun2.2": [27, true], "fun2.3": [33, true], "fun2.4": [45, true], "fun2.5": [51, true], "fun3.1": [58, true], "fun3.2": [81, true], "fun3.3": [83, true], "fun3.4": [95, true], "fun3.5": [86, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [52, false], "fun7.2": [52, false], "fun7.3": [53, false], "fun7.4": [57, false], "fun7.5": [60, false], "fun8.1": [10, true], "fun8.2": [11, true], "fun8.3": [14, true], "fun8.4": [18, true], "fun8.5": [21, true], "fun9.1": [8, true], "fun9.2": [11, true], "fun9.3": [21, true], "fun9.4": [38, true], "fun9.5": [29, true]}}}, {"label": "pure.exp_abs.derived3.bracket", "spec": ["pure", "exp_abs", "derived3", "bracket"], "APS": {"total": 8036, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [48, true], "aps.02.00": [47, true], "aps.02.01": [48, true], "aps.02.02": [50, true], "aps.02.03": [51, true], "aps.02.04": [50, true], "aps.02.05": [51, true], "aps.02.06": [51, true], "aps.02.07": [52, true], "aps.02.08": [52, true], "aps.02.09": [52, true], "aps.03.00": [54, true], "aps.03.01": [53, true], "aps.03.02": [50, true], "aps.04.00": [51, true], "aps.04.01": [50, true], "aps.04.02": [50, true], "aps.04.03": [51, true], "aps.04.04": [48, true], "aps.04.05": [50, true], "aps.04.06": [49, true], "aps.04.07": [51, true], "aps.04.08": [51, true], "aps.04.09": [49, true], "aps.04.10": [50, true], "aps.04.11": [49, true], "aps.04.12": [48, true], "aps.04.13": [49, true], "aps.05.00": [46, true], "aps.06.00": [45, true], "aps.06.01": [46, true], "aps.06.02": [43, true], "aps.06.03": [46, true], "aps.06.04": [45, true], "aps.06.05": [45, true], "aps.06.06": [45, true], "aps.06.07": [44, true], "aps.06.08": [45, true], "aps.06.09": [46, true], "aps.07.00": [44, true], "aps.07.01": [43, true], "aps.07.02": [41, true], "aps.08.00": [46, true], "aps.08.01": [46, true], "aps.08.02": [46, true], "aps.08.03": [44, true], "aps.08.04": [40, true], "aps.09.00": [46, true], "aps.09.01": [46, true], "aps.09.02": [42, true], "aps.09.03": [42, true], "aps.09.04": [40, true], "aps.09.05": [39, true], "aps.09.06": [38, true], "aps.10.00": [45, true], "aps.10.01": [47, true], "aps.10.02": [44, true], "aps.10.03": [48, true], "aps.10.04": [47, true], "aps.11.00": [33, true], "aps.11.01": [48, true], "aps.11.02": [46, true], "aps.11.03": [49, true], "aps.12.00": [50, true], "aps.12.01": [51, true], "aps.12.02": [51, true], "aps.12.03": [44, true], "aps.12.04": [49, true], "aps.12.05": [50, true], "aps.12.06": [49, true], "aps.12.07": [49, true], "aps.12.08": [53, true], "aps.12.09": [53, true], "aps.12.10": [54, true], "aps.12.11": [53, true], "aps.12.12": [50, true], "aps.12.13": [49, true], "aps.12.14": [48, true], "aps.12.15": [47, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [51, true], "aps.13.00": [11, false], "aps.14.00": [56, true], "aps.14.01": [56, true], "aps.14.02": [56, true], "aps.14.03": [56, true], "aps.14.04": [56, true], "aps.14.05": [56, true], "aps.14.06": [56, true], "aps.14.07": [56, true], "aps.14.08": [56, true], "aps.14.09": [56, true], "aps.14.10": [56, true], "aps.14.11": [56, true], "aps.14.12": [56, true], "aps.14.13": [56, true], "aps.14.14": [56, true], "aps.14.15": [56, true], "aps.14.16": [56, true], "aps.14.17": [56, true], "aps.14.18": [56, true], "aps.14.19": [56, true], "aps.14.20": [56, true], "aps.14.21": [56, true], "aps.14.22": [56, true], "aps.14.23": [56, true], "aps.14.24": [56, true], "aps.14.25": [56, true], "aps.14.26": [56, true], "aps.14.27": [56, true], "aps.14.28": [56, true], "aps.14.29": [56, true], "aps.14.30": [56, true], "aps.14.31": [56, true], "aps.14.32": [56, true], "aps.14.33": [56, true], "aps.14.34": [56, true], "aps.14.35": [56, true], "aps.14.36": [56, true], "aps.14.37": [56, true], "aps.14.38": [56, true], "aps.14.39": [56, true], "aps.15.00": [56, true], "aps.15.01": [55, true], "aps.15.02": [55, true], "aps.15.03": [55, true], "aps.15.04": [54, true], "aps.15.05": [53, true], "aps.15.06": [55, true], "aps.15.07": [55, true], "aps.15.08": [55, true], "aps.15.09": [54, true], "aps.15.10": [55, true], "aps.15.11": [54, true], "aps.15.12": [54, true], "aps.15.13": [55, true], "aps.15.14": [54, true], "aps.15.15": [54, true], "aps.15.16": [54, true], "aps.15.17": [54, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [52, true], "aps.15.21": [53, true], "aps.15.22": [52, true], "aps.15.23": [55, true], "aps.15.24": [56, true], "aps.15.25": [55, true], "aps.15.26": [57, true], "aps.15.27": [57, true], "aps.15.28": [57, true], "aps.15.29": [57, true], "aps.15.30": [56, true]}}, "CHA": {"total": 3809, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [46, true], "fun1.2": [43, true], "fun1.3": [53, true], "fun1.4": [66, true], "fun1.5": [104, true], "fun2.1": [43, true], "fun2.2": [63, true], "fun2.3": [68, true], "fun2.4": [79, true], "fun2.5": [87, true], "fun3.1": [70, true], "fun3.2": [63, true], "fun3.3": [100, true], "fun3.4": [111, true], "fun3.5": [135, true], "fun4.1": [74, true], "fun4.2": [77, true], "fun4.3": [92, true], "fun4.4": [100, true], "fun4.5": [121, true], "fun5.1": [71, true], "fun5.2": [78, true], "fun5.3": [79, true], "fun5.4": [77, true], "fun5.5": [79, true], "fun6.1": [61, true], "fun6.2": [62, true], "fun6.3": [67, true], "fun6.4": [69, true], "fun6.5": [70, true], "fun7.1": [11, false], "fun7.2": [8, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [45, true], "fun8.2": [49, true], "fun8.3": [50, true], "fun8.4": [53, true], "fun8.5": [59, true], "fun9.1": [44, true], "fun9.2": [44, true], "fun9.3": [47, true], "fun9.4": [55, true], "fun9.5": [55, true]}}}, {"label": "pure.exp_abs.derived3.safe", "spec": ["pure", "exp_abs", "derived3", "safe"], "APS": {"total": 3312, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [15, true], "aps.02.01": [14, true], "aps.02.02": [41, true], "aps.02.03": [16, true], "aps.02.04": [16, true], "aps.02.05": [25, true], "aps.02.06": [39, true], "aps.02.07": [29, true], "aps.02.08": [27, true], "aps.02.09": [24, true], "aps.03.00": [28, true], "aps.03.01": [26, true], "aps.03.02": [40, true], "aps.04.00": [17, true], "aps.04.01": [19, true], "aps.04.02": [44, true], "aps.04.03": [18, true], "aps.04.04": [24, true], "aps.04.05": [12, true], "aps.04.06": [15, true], "aps.04.07": [15, true], "aps.04.08": [17, true], "aps.04.09": [17, true], "aps.04.10": [16, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [16, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [11, true], "aps.06.06": [13, true], "aps.06.07": [13, true], "aps.06.08": [13, true], "aps.06.09": [14, true], "aps.07.00": [11, true], "aps.07.01": [11, true], "aps.07.02": [12, true], "aps.08.00": [35, true], "aps.08.01": [10, true], "aps.08.02": [10, true], "aps.08.03": [30, true], "aps.08.04": [11, true], "aps.09.00": [31, true], "aps.09.01": [12, true], "aps.09.02": [12, true], "aps.09.03": [11, true], "aps.09.04": [14, true], "aps.09.05": [16, true], "aps.09.06": [17, true], "aps.10.00": [9, true], "aps.10.01": [10, true], "aps.10.02": [33, true], "aps.10.03": [38, true], "aps.10.04": [18, true], "aps.11.00": [12, true], "aps.11.01": [12, true], "aps.11.02": [17, true], "aps.11.03": [16, true], "aps.12.00": [10, true], "aps.12.01": [10, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [9, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [11, true], "aps.12.18": [11, true], "aps.13.00": [10, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [32, true], "aps.15.01": [33, true], "aps.15.02": [32, true], "aps.15.03": [32, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [32, true], "aps.15.09": [32, true], "aps.15.10": [33, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [32, true], "aps.15.15": [32, true], "aps.15.16": [33, true], "aps.15.17": [33, true], "aps.15.18": [32, true], "aps.15.19": [33, true], "aps.15.20": [32, true], "aps.15.21": [31, true], "aps.15.22": [34, true], "aps.15.23": [34, true], "aps.15.24": [34, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [35, true], "aps.15.28": [36, true], "aps.15.29": [37, true], "aps.15.30": [37, true]}}, "CHA": {"total": 3480, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [10, true], "fun1.2": [29, true], "fun1.3": [27, true], "fun1.4": [34, true], "fun1.5": [95, true], "fun2.1": [9, true], "fun2.2": [27, true], "fun2.3": [34, true], "fun2.4": [45, true], "fun2.5": [53, true], "fun3.1": [85, true], "fun3.2": [89, true], "fun3.3": [104, true], "fun3.4": [115, true], "fun3.5": [140, true], "fun4.1": [89, true], "fun4.2": [93, true], "fun4.3": [113, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [76, true], "fun6.2": [88, true], "fun6.3": [79, true], "fun6.4": [85, true], "fun6.5": [82, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [11, false], "fun7.4": [16, false], "fun7.5": [18, false], "fun8.1": [13, true], "fun8.2": [11, true], "fun8.3": [13, true], "fun8.4": [17, true], "fun8.5": [18, true], "fun9.1": [8, true], "fun9.2": [12, true], "fun9.3": [19, true], "fun9.4": [18, true], "fun9.5": [18, true]}}}, {"label": "pure.exp_sq.start.bracket", "spec": ["pure", "exp_sq", "start", "bracket"], "APS": {"total": 9543, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [59, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [51, true], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [62, true], "aps.04.01": [57, true], "aps.04.02": [57, true], "aps.04.03": [61, true], "aps.04.04": [60, true], "aps.04.05": [62, true], "aps.04.06": [60, true], "aps.04.07": [60, true], "aps.04.08": [60, true], "aps.04.09": [59, true], "aps.04.10": [62, true], "aps.04.11": [62, true], "aps.04.12": [62, true], "aps.04.13": [59, true], "aps.05.00": [59, true], "aps.06.00": [59, true], "aps.06.01": [59, true], "aps.06.02": [60, true], "aps.06.03": [60, true], "aps.06.04": [60, true], "aps.06.05": [59, true], "aps.06.06": [58, true], "aps.06.07": [59, true], "aps.06.08": [59, true], "aps.06.09": [58, true], "aps.07.00": [62, true], "aps.07.01": [60, true], "aps.07.02": [60, true], "aps.08.00": [59, true], "aps.08.01": [60, true], "aps.08.02": [60, true], "aps.08.03": [60, true], "aps.08.04": [60, true], "aps.09.00": [59, true], "aps.09.01": [58, true], "aps.09.02": [60, true], "aps.09.03": [61, true], "aps.09.04": [61, true], "aps.09.05": [61, true], "aps.09.06": [61, true], "aps.10.00": [60, true], "aps.10.01": [58, true], "aps.10.02": [56, true], "aps.10.03": [54, true], "aps.10.04": [52, true], "aps.11.00": [59, true], "aps.11.01": [59, true], "aps.11.02": [59, true], "aps.11.03": [58, true], "aps.12.00": [66, true], "aps.12.01": [67, true], "aps.12.02": [68, true], "aps.12.03": [66, true], "aps.12.04": [65, true], "aps.12.05": [66, true], "aps.12.06": [67, true], "aps.12.07": [67, true], "aps.12.08": [66, true], "aps.12.09": [66, true], "aps.12.10": [66, true], "aps.12.11": [65, true], "aps.12.12": [66, true], "aps.12.13": [65, true], "aps.12.14": [66, true], "aps.12.15": [66, true], "aps.12.16": [64, true], "aps.12.17": [64, true], "aps.12.18": [66, true], "aps.13.00": [8, false], "aps.14.00": [65, true], "aps.14.01": [65, true], "aps.14.02": [65, true], "aps.14.03": [65, true], "aps.14.04": [65, true], "aps.14.05": [65, true], "aps.14.06": [65, true], "aps.14.07": [65, true], "aps.14.08": [65, true], "aps.14.09": [65, true], "aps.14.10": [65, true], "aps.14.11": [65, true], "aps.14.12": [65, true], "aps.14.13": [65, true], "aps.14.14": [65, true], "aps.14.15": [65, true], "aps.14.16": [65, true], "aps.14.17": [65, true], "aps.14.18": [65, true], "aps.14.19": [65, true], "aps.14.20": [65, true], "aps.14.21": [65, true], "aps.14.22": [65, true], "aps.14.23": [65, true], "aps.14.24": [65, true], "aps.14.25": [65, true], "aps.14.26": [65, true], "aps.14.27": [65, true], "aps.14.28": [65, true], "aps.14.29": [65, true], "aps.14.30": [65, true], "aps.14.31": [65, true], "aps.14.32": [65, true], "aps.14.33": [65, true], "aps.14.34": [65, true], "aps.14.35": [65, true], "aps.14.36": [65, true], "aps.14.37": [65, true], "aps.14.38": [65, true], "aps.14.39": [65, true], "aps.15.00": [61, true], "aps.15.01": [61, true], "aps.15.02": [61, true], "aps.15.03": [62, true], "aps.15.04": [62, true], "aps.15.05": [62, true], "aps.15.06": [62, true], "aps.15.07": [62, true], "aps.15.08": [62, true], "aps.15.09": [62, true], "aps.15.10": [62, true], "aps.15.11": [62, true], "aps.15.12": [62, true], "aps.15.13": [62, true], "aps.15.14": [62, true], "aps.15.15": [62, true], "aps.15.16": [62, true], "aps.15.17": [63, true], "aps.15.18": [62, true], "aps.15.19": [62, true], "aps.15.20": [62, true], "aps.15.21": [61, true], "aps.15.22": [62, true], "aps.15.23": [62, true], "aps.15.24": [62, true], "aps.15.25": [61, true], "aps.15.26": [61, true], "aps.15.27": [62, true], "aps.15.28": [62, true], "aps.15.29": [62, true], "aps.15.30": [61, true]}}, "CHA": {"total": 3443, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [57, true], "fun1.2": [61, true], "fun1.3": [66, true], "fun1.4": [64, true], "fun1.5": [84, true], "fun2.1": [58, true], "fun2.2": [69, true], "fun2.3": [73, true], "fun2.4": [82, true], "fun2.5": [87, true], "fun3.1": [51, true], "fun3.2": [53, true], "fun3.3": [64, true], "fun3.4": [70, true], "fun3.5": [84, true], "fun4.1": [48, true], "fun4.2": [51, true], "fun4.3": [61, true], "fun4.4": [68, true], "fun4.5": [81, true], "fun5.1": [48, true], "fun5.2": [48, true], "fun5.3": [49, true], "fun5.4": [51, true], "fun5.5": [52, true], "fun6.1": [46, true], "fun6.2": [47, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [8, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [16, false], "fun7.5": [18, false], "fun8.1": [60, true], "fun8.2": [61, true], "fun8.3": [62, true], "fun8.4": [62, true], "fun8.5": [65, true], "fun9.1": [59, true], "fun9.2": [59, true], "fun9.3": [63, true], "fun9.4": [66, true], "fun9.5": [67, true]}}}, {"label": "pure.exp_abs.derived3.credit", "spec": ["pure", "exp_abs", "derived3", "credit"], "APS": {"total": 6703, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [43, true], "aps.02.06": [33, true], "aps.02.07": [41, true], "aps.02.08": [41, true], "aps.02.09": [19, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [10, true], "aps.06.00": [23, true], "aps.06.01": [30, true], "aps.06.02": [43, true], "aps.06.03": [41, true], "aps.06.04": [35, true], "aps.06.05": [20, true], "aps.06.06": [20, true], "aps.06.07": [41, true], "aps.06.08": [30, true], "aps.06.09": [40, true], "aps.07.00": [26, true], "aps.07.01": [32, true], "aps.07.02": [12, true], "aps.08.00": [4, true], "aps.08.01": [39, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [40, true], "aps.09.00": [36, true], "aps.09.01": [33, true], "aps.09.02": [32, true], "aps.09.03": [11, true], "aps.09.04": [14, true], "aps.09.05": [16, true], "aps.09.06": [17, true], "aps.10.00": [32, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [31, true], "aps.12.00": [10, true], "aps.12.01": [10, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [50, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [50, true], "aps.12.12": [42, true], "aps.12.13": [38, true], "aps.12.14": [27, true], "aps.12.15": [33, true], "aps.12.16": [25, true], "aps.12.17": [41, true], "aps.12.18": [25, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [49, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [50, true], "aps.15.04": [49, true], "aps.15.05": [53, true], "aps.15.06": [49, true], "aps.15.07": [52, true], "aps.15.08": [51, true], "aps.15.09": [52, true], "aps.15.10": [43, true], "aps.15.11": [52, true], "aps.15.12": [52, true], "aps.15.13": [53, true], "aps.15.14": [50, true], "aps.15.15": [52, true], "aps.15.16": [53, true], "aps.15.17": [49, true], "aps.15.18": [50, true], "aps.15.19": [49, true], "aps.15.20": [47, true], "aps.15.21": [47, true], "aps.15.22": [34, true], "aps.15.23": [52, true], "aps.15.24": [48, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3049, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [27, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [12, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [24, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.exp_sq.start.step", "spec": ["pure", "exp_sq", "start", "step"], "APS": {"total": 10798, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [73, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [54, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [70, true], "aps.04.01": [70, true], "aps.04.02": [73, true], "aps.04.03": [75, true], "aps.04.04": [72, true], "aps.04.05": [73, true], "aps.04.06": [72, true], "aps.04.07": [71, true], "aps.04.08": [74, true], "aps.04.09": [59, true], "aps.04.10": [75, true], "aps.04.11": [73, true], "aps.04.12": [68, true], "aps.04.13": [72, true], "aps.05.00": [70, true], "aps.06.00": [66, true], "aps.06.01": [71, true], "aps.06.02": [69, true], "aps.06.03": [71, true], "aps.06.04": [71, true], "aps.06.05": [64, true], "aps.06.06": [70, true], "aps.06.07": [63, true], "aps.06.08": [66, true], "aps.06.09": [69, true], "aps.07.00": [70, true], "aps.07.01": [70, true], "aps.07.02": [70, true], "aps.08.00": [3, true], "aps.08.01": [69, true], "aps.08.02": [67, true], "aps.08.03": [70, true], "aps.08.04": [68, true], "aps.09.00": [70, true], "aps.09.01": [64, true], "aps.09.02": [66, true], "aps.09.03": [74, true], "aps.09.04": [69, true], "aps.09.05": [68, true], "aps.09.06": [67, true], "aps.10.00": [65, true], "aps.10.01": [68, true], "aps.10.02": [64, true], "aps.10.03": [58, true], "aps.10.04": [55, true], "aps.11.00": [69, true], "aps.11.01": [69, true], "aps.11.02": [66, true], "aps.11.03": [67, true], "aps.12.00": [75, true], "aps.12.01": [79, true], "aps.12.02": [74, true], "aps.12.03": [70, true], "aps.12.04": [66, true], "aps.12.05": [73, true], "aps.12.06": [77, true], "aps.12.07": [75, true], "aps.12.08": [76, true], "aps.12.09": [79, true], "aps.12.10": [80, true], "aps.12.11": [75, true], "aps.12.12": [79, true], "aps.12.13": [75, true], "aps.12.14": [73, true], "aps.12.15": [78, true], "aps.12.16": [78, true], "aps.12.17": [74, true], "aps.12.18": [74, true], "aps.13.00": [11, false], "aps.14.00": [74, true], "aps.14.01": [74, true], "aps.14.02": [74, true], "aps.14.03": [74, true], "aps.14.04": [74, true], "aps.14.05": [74, true], "aps.14.06": [74, true], "aps.14.07": [74, true], "aps.14.08": [74, true], "aps.14.09": [74, true], "aps.14.10": [74, true], "aps.14.11": [74, true], "aps.14.12": [74, true], "aps.14.13": [74, true], "aps.14.14": [74, true], "aps.14.15": [74, true], "aps.14.16": [74, true], "aps.14.17": [74, true], "aps.14.18": [74, true], "aps.14.19": [74, true], "aps.14.20": [74, true], "aps.14.21": [74, true], "aps.14.22": [74, true], "aps.14.23": [74, true], "aps.14.24": [74, true], "aps.14.25": [74, true], "aps.14.26": [74, true], "aps.14.27": [74, true], "aps.14.28": [74, true], "aps.14.29": [74, true], "aps.14.30": [74, true], "aps.14.31": [74, true], "aps.14.32": [74, true], "aps.14.33": [74, true], "aps.14.34": [74, true], "aps.14.35": [74, true], "aps.14.36": [74, true], "aps.14.37": [74, true], "aps.14.38": [74, true], "aps.14.39": [74, true], "aps.15.00": [73, true], "aps.15.01": [69, true], "aps.15.02": [73, true], "aps.15.03": [73, true], "aps.15.04": [69, true], "aps.15.05": [70, true], "aps.15.06": [71, true], "aps.15.07": [73, true], "aps.15.08": [75, true], "aps.15.09": [75, true], "aps.15.10": [77, true], "aps.15.11": [72, true], "aps.15.12": [77, true], "aps.15.13": [65, true], "aps.15.14": [63, true], "aps.15.15": [66, true], "aps.15.16": [71, true], "aps.15.17": [70, true], "aps.15.18": [77, true], "aps.15.19": [72, true], "aps.15.20": [70, true], "aps.15.21": [72, true], "aps.15.22": [76, true], "aps.15.23": [69, true], "aps.15.24": [77, true], "aps.15.25": [75, true], "aps.15.26": [69, true], "aps.15.27": [70, true], "aps.15.28": [79, true], "aps.15.29": [73, true], "aps.15.30": [73, true]}}, "CHA": {"total": 3742, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [71, true], "fun1.2": [69, true], "fun1.3": [74, true], "fun1.4": [72, true], "fun1.5": [92, true], "fun2.1": [67, true], "fun2.2": [84, true], "fun2.3": [87, true], "fun2.4": [94, true], "fun2.5": [100, true], "fun3.1": [53, true], "fun3.2": [61, true], "fun3.3": [72, true], "fun3.4": [78, true], "fun3.5": [92, true], "fun4.1": [49, true], "fun4.2": [51, true], "fun4.3": [66, true], "fun4.4": [72, true], "fun4.5": [86, true], "fun5.1": [47, true], "fun5.2": [49, true], "fun5.3": [51, true], "fun5.4": [53, true], "fun5.5": [54, true], "fun6.1": [46, true], "fun6.2": [47, true], "fun6.3": [48, true], "fun6.4": [50, true], "fun6.5": [51, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [17, false], "fun7.5": [21, false], "fun8.1": [75, true], "fun8.2": [78, true], "fun8.3": [76, true], "fun8.4": [77, true], "fun8.5": [77, true], "fun9.1": [71, true], "fun9.2": [73, true], "fun9.3": [74, true], "fun9.4": [77, true], "fun9.5": [78, true]}}}, {"label": "pure.exp_abs.derived.step", "spec": ["pure", "exp_abs", "derived", "step"], "APS": {"total": 3316, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [15, true], "aps.02.01": [30, true], "aps.02.02": [12, true], "aps.02.03": [14, true], "aps.02.04": [13, true], "aps.02.05": [14, true], "aps.02.06": [41, true], "aps.02.07": [13, true], "aps.02.08": [12, true], "aps.02.09": [12, true], "aps.03.00": [18, true], "aps.03.01": [19, true], "aps.03.02": [20, true], "aps.04.00": [16, true], "aps.04.01": [40, true], "aps.04.02": [34, true], "aps.04.03": [15, true], "aps.04.04": [15, true], "aps.04.05": [16, true], "aps.04.06": [15, true], "aps.04.07": [16, true], "aps.04.08": [16, true], "aps.04.09": [17, true], "aps.04.10": [18, true], "aps.04.11": [17, true], "aps.04.12": [17, true], "aps.04.13": [18, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [15, true], "aps.06.07": [16, true], "aps.06.08": [16, true], "aps.06.09": [16, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [14, true], "aps.08.00": [35, true], "aps.08.01": [10, true], "aps.08.02": [11, true], "aps.08.03": [16, true], "aps.08.04": [12, true], "aps.09.00": [11, true], "aps.09.01": [26, true], "aps.09.02": [12, true], "aps.09.03": [13, true], "aps.09.04": [15, true], "aps.09.05": [18, true], "aps.09.06": [19, true], "aps.10.00": [36, true], "aps.10.01": [28, true], "aps.10.02": [16, true], "aps.10.03": [17, true], "aps.10.04": [38, true], "aps.11.00": [10, true], "aps.11.01": [12, true], "aps.11.02": [18, true], "aps.11.03": [19, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [12, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [12, true], "aps.12.06": [12, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [33, true], "aps.15.01": [33, true], "aps.15.02": [33, true], "aps.15.03": [34, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [35, true], "aps.15.08": [35, true], "aps.15.09": [35, true], "aps.15.10": [34, true], "aps.15.11": [34, true], "aps.15.12": [34, true], "aps.15.13": [34, true], "aps.15.14": [34, true], "aps.15.15": [34, true], "aps.15.16": [34, true], "aps.15.17": [34, true], "aps.15.18": [34, true], "aps.15.19": [35, true], "aps.15.20": [34, true], "aps.15.21": [34, true], "aps.15.22": [34, true], "aps.15.23": [36, true], "aps.15.24": [34, true], "aps.15.25": [37, true], "aps.15.26": [38, true], "aps.15.27": [38, true], "aps.15.28": [36, true], "aps.15.29": [37, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3506, "solved": 40, "n": 45, "over": 8, "per": {"fun1.1": [30, true], "fun1.2": [38, true], "fun1.3": [38, true], "fun1.4": [32, true], "fun1.5": [80, true], "fun2.1": [12, true], "fun2.2": [29, true], "fun2.3": [36, true], "fun2.4": [47, true], "fun2.5": [57, true], "fun3.1": [87, true], "fun3.2": [91, true], "fun3.3": [111, true], "fun3.4": [122, true], "fun3.5": [146, true], "fun4.1": [88, true], "fun4.2": [94, true], "fun4.3": [116, true], "fun4.4": [128, true], "fun4.5": [157, true], "fun5.1": [96, true], "fun5.2": [99, true], "fun5.3": [100, true], "fun5.4": [106, true], "fun5.5": [109, true], "fun6.1": [61, true], "fun6.2": [52, true], "fun6.3": [60, true], "fun6.4": [64, true], "fun6.5": [64, true], "fun7.1": [10, false], "fun7.2": [12, false], "fun7.3": [13, false], "fun7.4": [17, false], "fun7.5": [15, false], "fun8.1": [12, true], "fun8.2": [12, true], "fun8.3": [17, true], "fun8.4": [17, true], "fun8.5": [22, true], "fun9.1": [9, true], "fun9.2": [12, true], "fun9.3": [16, true], "fun9.4": [20, true], "fun9.5": [19, true]}}}, {"label": "pure.exp_sq.start.both", "spec": ["pure", "exp_sq", "start", "both"], "APS": {"total": 8966, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [57, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [51, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [57, true], "aps.04.01": [57, true], "aps.04.02": [54, true], "aps.04.03": [57, true], "aps.04.04": [54, true], "aps.04.05": [56, true], "aps.04.06": [56, true], "aps.04.07": [56, true], "aps.04.08": [54, true], "aps.04.09": [56, true], "aps.04.10": [59, true], "aps.04.11": [57, true], "aps.04.12": [56, true], "aps.04.13": [58, true], "aps.05.00": [57, true], "aps.06.00": [55, true], "aps.06.01": [54, true], "aps.06.02": [55, true], "aps.06.03": [55, true], "aps.06.04": [55, true], "aps.06.05": [53, true], "aps.06.06": [53, true], "aps.06.07": [53, true], "aps.06.08": [54, true], "aps.06.09": [55, true], "aps.07.00": [57, true], "aps.07.01": [53, true], "aps.07.02": [56, true], "aps.08.00": [3, true], "aps.08.01": [54, true], "aps.08.02": [54, true], "aps.08.03": [54, true], "aps.08.04": [52, true], "aps.09.00": [56, true], "aps.09.01": [54, true], "aps.09.02": [57, true], "aps.09.03": [57, true], "aps.09.04": [56, true], "aps.09.05": [57, true], "aps.09.06": [55, true], "aps.10.00": [55, true], "aps.10.01": [53, true], "aps.10.02": [52, true], "aps.10.03": [50, true], "aps.10.04": [49, true], "aps.11.00": [54, true], "aps.11.01": [56, true], "aps.11.02": [52, true], "aps.11.03": [54, true], "aps.12.00": [64, true], "aps.12.01": [62, true], "aps.12.02": [60, true], "aps.12.03": [64, true], "aps.12.04": [62, true], "aps.12.05": [58, true], "aps.12.06": [62, true], "aps.12.07": [60, true], "aps.12.08": [63, true], "aps.12.09": [59, true], "aps.12.10": [61, true], "aps.12.11": [63, true], "aps.12.12": [62, true], "aps.12.13": [63, true], "aps.12.14": [63, true], "aps.12.15": [58, true], "aps.12.16": [64, true], "aps.12.17": [60, true], "aps.12.18": [62, true], "aps.13.00": [10, false], "aps.14.00": [63, true], "aps.14.01": [63, true], "aps.14.02": [63, true], "aps.14.03": [63, true], "aps.14.04": [63, true], "aps.14.05": [63, true], "aps.14.06": [63, true], "aps.14.07": [63, true], "aps.14.08": [63, true], "aps.14.09": [63, true], "aps.14.10": [63, true], "aps.14.11": [63, true], "aps.14.12": [63, true], "aps.14.13": [63, true], "aps.14.14": [63, true], "aps.14.15": [63, true], "aps.14.16": [63, true], "aps.14.17": [63, true], "aps.14.18": [63, true], "aps.14.19": [63, true], "aps.14.20": [63, true], "aps.14.21": [63, true], "aps.14.22": [63, true], "aps.14.23": [63, true], "aps.14.24": [63, true], "aps.14.25": [63, true], "aps.14.26": [63, true], "aps.14.27": [63, true], "aps.14.28": [63, true], "aps.14.29": [63, true], "aps.14.30": [63, true], "aps.14.31": [63, true], "aps.14.32": [63, true], "aps.14.33": [63, true], "aps.14.34": [63, true], "aps.14.35": [63, true], "aps.14.36": [63, true], "aps.14.37": [63, true], "aps.14.38": [63, true], "aps.14.39": [63, true], "aps.15.00": [58, true], "aps.15.01": [55, true], "aps.15.02": [58, true], "aps.15.03": [56, true], "aps.15.04": [57, true], "aps.15.05": [57, true], "aps.15.06": [58, true], "aps.15.07": [57, true], "aps.15.08": [58, true], "aps.15.09": [57, true], "aps.15.10": [57, true], "aps.15.11": [56, true], "aps.15.12": [57, true], "aps.15.13": [54, true], "aps.15.14": [60, true], "aps.15.15": [57, true], "aps.15.16": [57, true], "aps.15.17": [55, true], "aps.15.18": [55, true], "aps.15.19": [57, true], "aps.15.20": [56, true], "aps.15.21": [58, true], "aps.15.22": [59, true], "aps.15.23": [60, true], "aps.15.24": [60, true], "aps.15.25": [58, true], "aps.15.26": [58, true], "aps.15.27": [58, true], "aps.15.28": [58, true], "aps.15.29": [59, true], "aps.15.30": [58, true]}}, "CHA": {"total": 3367, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [56, true], "fun1.2": [58, true], "fun1.3": [60, true], "fun1.4": [65, true], "fun1.5": [85, true], "fun2.1": [57, true], "fun2.2": [63, true], "fun2.3": [68, true], "fun2.4": [77, true], "fun2.5": [82, true], "fun3.1": [48, true], "fun3.2": [52, true], "fun3.3": [65, true], "fun3.4": [71, true], "fun3.5": [85, true], "fun4.1": [47, true], "fun4.2": [49, true], "fun4.3": [62, true], "fun4.4": [68, true], "fun4.5": [82, true], "fun5.1": [46, true], "fun5.2": [47, true], "fun5.3": [49, true], "fun5.4": [51, true], "fun5.5": [52, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [10, false], "fun7.2": [10, false], "fun7.3": [10, false], "fun7.4": [54, false], "fun7.5": [18, false], "fun8.1": [57, true], "fun8.2": [55, true], "fun8.3": [58, true], "fun8.4": [59, true], "fun8.5": [61, true], "fun9.1": [55, true], "fun9.2": [60, true], "fun9.3": [57, true], "fun9.4": [60, true], "fun9.5": [62, true]}}}, {"label": "pure.exp_sq.start.credit", "spec": ["pure", "exp_sq", "start", "credit"], "APS": {"total": 7676, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [44, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [48, true], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [7, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [7, false], "fun7.2": [8, false], "fun7.3": [8, false], "fun7.4": [13, false], "fun7.5": [9, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.exp_abs.start.credit", "spec": ["pure", "exp_abs", "start", "credit"], "APS": {"total": 7712, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [44, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [43, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [49, true], "aps.12.16": [50, true], "aps.12.17": [47, true], "aps.12.18": [50, true], "aps.13.00": [7, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [7, false], "fun7.2": [10, false], "fun7.3": [8, false], "fun7.4": [12, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.exp_sq.start.safe", "spec": ["pure", "exp_sq", "start", "safe"], "APS": {"total": 10798, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [73, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [54, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [70, true], "aps.04.01": [68, true], "aps.04.02": [73, true], "aps.04.03": [75, true], "aps.04.04": [72, true], "aps.04.05": [73, true], "aps.04.06": [72, true], "aps.04.07": [71, true], "aps.04.08": [74, true], "aps.04.09": [59, true], "aps.04.10": [75, true], "aps.04.11": [73, true], "aps.04.12": [68, true], "aps.04.13": [72, true], "aps.05.00": [70, true], "aps.06.00": [66, true], "aps.06.01": [71, true], "aps.06.02": [69, true], "aps.06.03": [71, true], "aps.06.04": [71, true], "aps.06.05": [64, true], "aps.06.06": [70, true], "aps.06.07": [63, true], "aps.06.08": [66, true], "aps.06.09": [69, true], "aps.07.00": [70, true], "aps.07.01": [70, true], "aps.07.02": [70, true], "aps.08.00": [3, true], "aps.08.01": [69, true], "aps.08.02": [67, true], "aps.08.03": [70, true], "aps.08.04": [68, true], "aps.09.00": [70, true], "aps.09.01": [64, true], "aps.09.02": [66, true], "aps.09.03": [74, true], "aps.09.04": [69, true], "aps.09.05": [68, true], "aps.09.06": [67, true], "aps.10.00": [67, true], "aps.10.01": [68, true], "aps.10.02": [64, true], "aps.10.03": [58, true], "aps.10.04": [55, true], "aps.11.00": [69, true], "aps.11.01": [69, true], "aps.11.02": [66, true], "aps.11.03": [67, true], "aps.12.00": [75, true], "aps.12.01": [79, true], "aps.12.02": [74, true], "aps.12.03": [70, true], "aps.12.04": [66, true], "aps.12.05": [73, true], "aps.12.06": [77, true], "aps.12.07": [75, true], "aps.12.08": [76, true], "aps.12.09": [79, true], "aps.12.10": [80, true], "aps.12.11": [75, true], "aps.12.12": [79, true], "aps.12.13": [75, true], "aps.12.14": [73, true], "aps.12.15": [78, true], "aps.12.16": [78, true], "aps.12.17": [74, true], "aps.12.18": [74, true], "aps.13.00": [11, false], "aps.14.00": [74, true], "aps.14.01": [74, true], "aps.14.02": [74, true], "aps.14.03": [74, true], "aps.14.04": [74, true], "aps.14.05": [74, true], "aps.14.06": [74, true], "aps.14.07": [74, true], "aps.14.08": [74, true], "aps.14.09": [74, true], "aps.14.10": [74, true], "aps.14.11": [74, true], "aps.14.12": [74, true], "aps.14.13": [74, true], "aps.14.14": [74, true], "aps.14.15": [74, true], "aps.14.16": [74, true], "aps.14.17": [74, true], "aps.14.18": [74, true], "aps.14.19": [74, true], "aps.14.20": [74, true], "aps.14.21": [74, true], "aps.14.22": [74, true], "aps.14.23": [74, true], "aps.14.24": [74, true], "aps.14.25": [74, true], "aps.14.26": [74, true], "aps.14.27": [74, true], "aps.14.28": [74, true], "aps.14.29": [74, true], "aps.14.30": [74, true], "aps.14.31": [74, true], "aps.14.32": [74, true], "aps.14.33": [74, true], "aps.14.34": [74, true], "aps.14.35": [74, true], "aps.14.36": [74, true], "aps.14.37": [74, true], "aps.14.38": [74, true], "aps.14.39": [74, true], "aps.15.00": [73, true], "aps.15.01": [69, true], "aps.15.02": [73, true], "aps.15.03": [73, true], "aps.15.04": [69, true], "aps.15.05": [70, true], "aps.15.06": [71, true], "aps.15.07": [73, true], "aps.15.08": [75, true], "aps.15.09": [75, true], "aps.15.10": [77, true], "aps.15.11": [72, true], "aps.15.12": [77, true], "aps.15.13": [65, true], "aps.15.14": [63, true], "aps.15.15": [66, true], "aps.15.16": [71, true], "aps.15.17": [70, true], "aps.15.18": [77, true], "aps.15.19": [72, true], "aps.15.20": [70, true], "aps.15.21": [72, true], "aps.15.22": [76, true], "aps.15.23": [69, true], "aps.15.24": [77, true], "aps.15.25": [75, true], "aps.15.26": [69, true], "aps.15.27": [70, true], "aps.15.28": [79, true], "aps.15.29": [73, true], "aps.15.30": [73, true]}}, "CHA": {"total": 3742, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [71, true], "fun1.2": [69, true], "fun1.3": [74, true], "fun1.4": [72, true], "fun1.5": [92, true], "fun2.1": [67, true], "fun2.2": [84, true], "fun2.3": [87, true], "fun2.4": [94, true], "fun2.5": [100, true], "fun3.1": [53, true], "fun3.2": [61, true], "fun3.3": [72, true], "fun3.4": [78, true], "fun3.5": [92, true], "fun4.1": [49, true], "fun4.2": [51, true], "fun4.3": [66, true], "fun4.4": [72, true], "fun4.5": [86, true], "fun5.1": [47, true], "fun5.2": [49, true], "fun5.3": [51, true], "fun5.4": [53, true], "fun5.5": [54, true], "fun6.1": [46, true], "fun6.2": [47, true], "fun6.3": [48, true], "fun6.4": [50, true], "fun6.5": [51, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [17, false], "fun7.5": [21, false], "fun8.1": [75, true], "fun8.2": [78, true], "fun8.3": [76, true], "fun8.4": [77, true], "fun8.5": [77, true], "fun9.1": [71, true], "fun9.2": [73, true], "fun9.3": [74, true], "fun9.4": [77, true], "fun9.5": [78, true]}}}, {"label": "pure.exp_sq.start.project", "spec": ["pure", "exp_sq", "start", "project"], "APS": {"total": 14150, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [94, true], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [89, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [89, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [82, true], "aps.06.09": [82, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [83, true], "aps.10.00": [83, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [83, true], "aps.11.01": [83, true], "aps.11.02": [82, true], "aps.11.03": [82, true], "aps.12.00": [97, true], "aps.12.01": [96, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [96, true], "aps.12.12": [96, true], "aps.12.13": [96, true], "aps.12.14": [97, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [96, true], "aps.12.18": [97, true], "aps.13.00": [51, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [102, true], "aps.15.01": [103, true], "aps.15.02": [102, true], "aps.15.03": [102, true], "aps.15.04": [103, true], "aps.15.05": [103, true], "aps.15.06": [103, true], "aps.15.07": [102, true], "aps.15.08": [102, true], "aps.15.09": [103, true], "aps.15.10": [102, true], "aps.15.11": [103, true], "aps.15.12": [102, true], "aps.15.13": [103, true], "aps.15.14": [103, true], "aps.15.15": [102, true], "aps.15.16": [103, true], "aps.15.17": [102, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [102, true], "aps.15.21": [103, true], "aps.15.22": [103, true], "aps.15.23": [103, true], "aps.15.24": [102, true], "aps.15.25": [102, true], "aps.15.26": [103, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [102, true], "aps.15.30": [103, true]}}, "CHA": {"total": 5110, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [123, true], "fun2.4": [150, true], "fun2.5": [163, true], "fun3.1": [89, true], "fun3.2": [80, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [152, true], "fun4.1": [89, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [51, false], "fun7.2": [49, false], "fun7.3": [52, false], "fun7.4": [57, false], "fun7.5": [60, false], "fun8.1": [84, true], "fun8.2": [87, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [97, true], "fun9.1": [83, true], "fun9.2": [87, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.exp_sq.bracket.step", "spec": ["pure", "exp_sq", "bracket", "step"], "APS": {"total": 10430, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [64, true], "aps.02.00": [62, true], "aps.02.01": [63, true], "aps.02.02": [66, true], "aps.02.03": [73, true], "aps.02.04": [72, true], "aps.02.05": [63, true], "aps.02.06": [69, true], "aps.02.07": [67, true], "aps.02.08": [66, true], "aps.02.09": [66, true], "aps.03.00": [73, true], "aps.03.01": [69, true], "aps.03.02": [67, true], "aps.04.00": [64, true], "aps.04.01": [71, true], "aps.04.02": [66, true], "aps.04.03": [62, true], "aps.04.04": [58, true], "aps.04.05": [74, true], "aps.04.06": [72, true], "aps.04.07": [70, true], "aps.04.08": [66, true], "aps.04.09": [61, true], "aps.04.10": [71, true], "aps.04.11": [69, true], "aps.04.12": [63, true], "aps.04.13": [68, true], "aps.05.00": [66, true], "aps.06.00": [60, true], "aps.06.01": [68, true], "aps.06.02": [66, true], "aps.06.03": [70, true], "aps.06.04": [61, true], "aps.06.05": [66, true], "aps.06.06": [66, true], "aps.06.07": [67, true], "aps.06.08": [62, true], "aps.06.09": [63, true], "aps.07.00": [60, true], "aps.07.01": [63, true], "aps.07.02": [60, true], "aps.08.00": [3, true], "aps.08.01": [63, true], "aps.08.02": [67, true], "aps.08.03": [70, true], "aps.08.04": [64, true], "aps.09.00": [70, true], "aps.09.01": [66, true], "aps.09.02": [61, true], "aps.09.03": [57, true], "aps.09.04": [53, true], "aps.09.05": [53, true], "aps.09.06": [50, true], "aps.10.00": [67, true], "aps.10.01": [61, true], "aps.10.02": [63, true], "aps.10.03": [62, true], "aps.10.04": [67, true], "aps.11.00": [60, true], "aps.11.01": [67, true], "aps.11.02": [72, true], "aps.11.03": [71, true], "aps.12.00": [67, true], "aps.12.01": [66, true], "aps.12.02": [73, true], "aps.12.03": [66, true], "aps.12.04": [72, true], "aps.12.05": [71, true], "aps.12.06": [70, true], "aps.12.07": [73, true], "aps.12.08": [80, true], "aps.12.09": [74, true], "aps.12.10": [73, true], "aps.12.11": [79, true], "aps.12.12": [77, true], "aps.12.13": [72, true], "aps.12.14": [75, true], "aps.12.15": [71, true], "aps.12.16": [81, true], "aps.12.17": [78, true], "aps.12.18": [74, true], "aps.13.00": [10, false], "aps.14.00": [74, true], "aps.14.01": [74, true], "aps.14.02": [74, true], "aps.14.03": [74, true], "aps.14.04": [74, true], "aps.14.05": [74, true], "aps.14.06": [74, true], "aps.14.07": [74, true], "aps.14.08": [74, true], "aps.14.09": [74, true], "aps.14.10": [74, true], "aps.14.11": [74, true], "aps.14.12": [74, true], "aps.14.13": [74, true], "aps.14.14": [74, true], "aps.14.15": [74, true], "aps.14.16": [74, true], "aps.14.17": [74, true], "aps.14.18": [74, true], "aps.14.19": [74, true], "aps.14.20": [74, true], "aps.14.21": [74, true], "aps.14.22": [74, true], "aps.14.23": [74, true], "aps.14.24": [74, true], "aps.14.25": [74, true], "aps.14.26": [74, true], "aps.14.27": [74, true], "aps.14.28": [74, true], "aps.14.29": [74, true], "aps.14.30": [74, true], "aps.14.31": [74, true], "aps.14.32": [74, true], "aps.14.33": [74, true], "aps.14.34": [74, true], "aps.14.35": [74, true], "aps.14.36": [74, true], "aps.14.37": [74, true], "aps.14.38": [74, true], "aps.14.39": [74, true], "aps.15.00": [62, true], "aps.15.01": [62, true], "aps.15.02": [61, true], "aps.15.03": [62, true], "aps.15.04": [64, true], "aps.15.05": [59, true], "aps.15.06": [64, true], "aps.15.07": [58, true], "aps.15.08": [59, true], "aps.15.09": [62, true], "aps.15.10": [60, true], "aps.15.11": [59, true], "aps.15.12": [63, true], "aps.15.13": [55, true], "aps.15.14": [57, true], "aps.15.15": [62, true], "aps.15.16": [60, true], "aps.15.17": [52, true], "aps.15.18": [60, true], "aps.15.19": [59, true], "aps.15.20": [60, true], "aps.15.21": [57, true], "aps.15.22": [56, true], "aps.15.23": [56, true], "aps.15.24": [63, true], "aps.15.25": [59, true], "aps.15.26": [60, true], "aps.15.27": [56, true], "aps.15.28": [58, true], "aps.15.29": [58, true], "aps.15.30": [55, true]}}, "CHA": {"total": 3884, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [62, true], "fun1.2": [64, true], "fun1.3": [65, true], "fun1.4": [75, true], "fun1.5": [89, true], "fun2.1": [61, true], "fun2.2": [99, true], "fun2.3": [81, true], "fun2.4": [96, true], "fun2.5": [102, true], "fun3.1": [79, true], "fun3.2": [77, true], "fun3.3": [70, true], "fun3.4": [83, true], "fun3.5": [89, true], "fun4.1": [72, true], "fun4.2": [73, true], "fun4.3": [77, true], "fun4.4": [80, true], "fun4.5": [94, true], "fun5.1": [89, true], "fun5.2": [73, true], "fun5.3": [61, true], "fun5.4": [62, true], "fun5.5": [63, true], "fun6.1": [49, true], "fun6.2": [53, true], "fun6.3": [49, true], "fun6.4": [53, true], "fun6.5": [54, true], "fun7.1": [10, false], "fun7.2": [16, false], "fun7.3": [11, false], "fun7.4": [19, false], "fun7.5": [14, false], "fun8.1": [65, true], "fun8.2": [65, true], "fun8.3": [71, true], "fun8.4": [73, true], "fun8.5": [73, true], "fun9.1": [59, true], "fun9.2": [71, true], "fun9.3": [76, true], "fun9.4": [72, true], "fun9.5": [65, true]}}}, {"label": "pure.exp_sq.bracket.bracket", "spec": ["pure", "exp_sq", "bracket", "bracket"], "APS": {"total": 7559, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [41, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [50, true], "aps.02.03": [46, true], "aps.02.04": [52, true], "aps.02.05": [49, true], "aps.02.06": [46, true], "aps.02.07": [44, true], "aps.02.08": [47, true], "aps.02.09": [50, true], "aps.03.00": [51, true], "aps.03.01": [51, true], "aps.03.02": [51, true], "aps.04.00": [48, true], "aps.04.01": [47, true], "aps.04.02": [47, true], "aps.04.03": [43, true], "aps.04.04": [47, true], "aps.04.05": [48, true], "aps.04.06": [47, true], "aps.04.07": [45, true], "aps.04.08": [44, true], "aps.04.09": [48, true], "aps.04.10": [45, true], "aps.04.11": [47, true], "aps.04.12": [48, true], "aps.04.13": [46, true], "aps.05.00": [48, true], "aps.06.00": [45, true], "aps.06.01": [43, true], "aps.06.02": [47, true], "aps.06.03": [42, true], "aps.06.04": [44, true], "aps.06.05": [43, true], "aps.06.06": [44, true], "aps.06.07": [40, true], "aps.06.08": [45, true], "aps.06.09": [42, true], "aps.07.00": [40, true], "aps.07.01": [45, true], "aps.07.02": [40, true], "aps.08.00": [42, true], "aps.08.01": [43, true], "aps.08.02": [46, true], "aps.08.03": [44, true], "aps.08.04": [43, true], "aps.09.00": [48, true], "aps.09.01": [44, true], "aps.09.02": [44, true], "aps.09.03": [39, true], "aps.09.04": [41, true], "aps.09.05": [42, true], "aps.09.06": [40, true], "aps.10.00": [45, true], "aps.10.01": [46, true], "aps.10.02": [39, true], "aps.10.03": [44, true], "aps.10.04": [45, true], "aps.11.00": [46, true], "aps.11.01": [49, true], "aps.11.02": [49, true], "aps.11.03": [48, true], "aps.12.00": [51, true], "aps.12.01": [52, true], "aps.12.02": [49, true], "aps.12.03": [49, true], "aps.12.04": [49, true], "aps.12.05": [49, true], "aps.12.06": [52, true], "aps.12.07": [52, true], "aps.12.08": [52, true], "aps.12.09": [50, true], "aps.12.10": [49, true], "aps.12.11": [54, true], "aps.12.12": [52, true], "aps.12.13": [52, true], "aps.12.14": [54, true], "aps.12.15": [53, true], "aps.12.16": [52, true], "aps.12.17": [53, true], "aps.12.18": [52, true], "aps.13.00": [41, false], "aps.14.00": [52, true], "aps.14.01": [52, true], "aps.14.02": [52, true], "aps.14.03": [52, true], "aps.14.04": [52, true], "aps.14.05": [52, true], "aps.14.06": [52, true], "aps.14.07": [52, true], "aps.14.08": [52, true], "aps.14.09": [52, true], "aps.14.10": [52, true], "aps.14.11": [52, true], "aps.14.12": [52, true], "aps.14.13": [52, true], "aps.14.14": [52, true], "aps.14.15": [52, true], "aps.14.16": [52, true], "aps.14.17": [52, true], "aps.14.18": [52, true], "aps.14.19": [52, true], "aps.14.20": [52, true], "aps.14.21": [52, true], "aps.14.22": [52, true], "aps.14.23": [52, true], "aps.14.24": [52, true], "aps.14.25": [52, true], "aps.14.26": [52, true], "aps.14.27": [52, true], "aps.14.28": [52, true], "aps.14.29": [52, true], "aps.14.30": [52, true], "aps.14.31": [52, true], "aps.14.32": [52, true], "aps.14.33": [52, true], "aps.14.34": [52, true], "aps.14.35": [52, true], "aps.14.36": [52, true], "aps.14.37": [52, true], "aps.14.38": [52, true], "aps.14.39": [52, true], "aps.15.00": [47, true], "aps.15.01": [44, true], "aps.15.02": [48, true], "aps.15.03": [48, true], "aps.15.04": [47, true], "aps.15.05": [45, true], "aps.15.06": [46, true], "aps.15.07": [45, true], "aps.15.08": [44, true], "aps.15.09": [48, true], "aps.15.10": [47, true], "aps.15.11": [46, true], "aps.15.12": [49, true], "aps.15.13": [46, true], "aps.15.14": [48, true], "aps.15.15": [47, true], "aps.15.16": [47, true], "aps.15.17": [48, true], "aps.15.18": [47, true], "aps.15.19": [49, true], "aps.15.20": [49, true], "aps.15.21": [46, true], "aps.15.22": [47, true], "aps.15.23": [45, true], "aps.15.24": [45, true], "aps.15.25": [47, true], "aps.15.26": [49, true], "aps.15.27": [47, true], "aps.15.28": [46, true], "aps.15.29": [46, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3487, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [49, true], "fun1.3": [47, true], "fun1.4": [60, true], "fun1.5": [93, true], "fun2.1": [45, true], "fun2.2": [68, true], "fun2.3": [62, true], "fun2.4": [79, true], "fun2.5": [83, true], "fun3.1": [82, true], "fun3.2": [86, true], "fun3.3": [76, true], "fun3.4": [107, true], "fun3.5": [130, true], "fun4.1": [49, true], "fun4.2": [60, true], "fun4.3": [62, true], "fun4.4": [82, true], "fun4.5": [77, true], "fun5.1": [51, true], "fun5.2": [56, true], "fun5.3": [56, true], "fun5.4": [58, true], "fun5.5": [59, true], "fun6.1": [46, true], "fun6.2": [51, true], "fun6.3": [58, true], "fun6.4": [58, true], "fun6.5": [61, true], "fun7.1": [41, false], "fun7.2": [8, false], "fun7.3": [8, false], "fun7.4": [14, false], "fun7.5": [14, false], "fun8.1": [45, true], "fun8.2": [47, true], "fun8.3": [54, true], "fun8.4": [55, true], "fun8.5": [56, true], "fun9.1": [43, true], "fun9.2": [46, true], "fun9.3": [51, true], "fun9.4": [47, true], "fun9.5": [49, true]}}}, {"label": "pure.exp_sq.bracket.both", "spec": ["pure", "exp_sq", "bracket", "both"], "APS": {"total": 7778, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [47, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [54, true], "aps.02.03": [50, true], "aps.02.04": [53, true], "aps.02.05": [52, true], "aps.02.06": [50, true], "aps.02.07": [49, true], "aps.02.08": [47, true], "aps.02.09": [48, true], "aps.03.00": [50, true], "aps.03.01": [53, true], "aps.03.02": [53, true], "aps.04.00": [48, true], "aps.04.01": [52, true], "aps.04.02": [48, true], "aps.04.03": [49, true], "aps.04.04": [48, true], "aps.04.05": [53, true], "aps.04.06": [50, true], "aps.04.07": [48, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [52, true], "aps.04.11": [49, true], "aps.04.12": [51, true], "aps.04.13": [51, true], "aps.05.00": [49, true], "aps.06.00": [45, true], "aps.06.01": [44, true], "aps.06.02": [43, true], "aps.06.03": [45, true], "aps.06.04": [46, true], "aps.06.05": [46, true], "aps.06.06": [44, true], "aps.06.07": [47, true], "aps.06.08": [44, true], "aps.06.09": [44, true], "aps.07.00": [44, true], "aps.07.01": [46, true], "aps.07.02": [42, true], "aps.08.00": [3, true], "aps.08.01": [50, true], "aps.08.02": [45, true], "aps.08.03": [51, true], "aps.08.04": [46, true], "aps.09.00": [49, true], "aps.09.01": [49, true], "aps.09.02": [43, true], "aps.09.03": [42, true], "aps.09.04": [43, true], "aps.09.05": [41, true], "aps.09.06": [40, true], "aps.10.00": [48, true], "aps.10.01": [48, true], "aps.10.02": [48, true], "aps.10.03": [44, true], "aps.10.04": [47, true], "aps.11.00": [47, true], "aps.11.01": [48, true], "aps.11.02": [48, true], "aps.11.03": [51, true], "aps.12.00": [55, true], "aps.12.01": [52, true], "aps.12.02": [51, true], "aps.12.03": [52, true], "aps.12.04": [49, true], "aps.12.05": [53, true], "aps.12.06": [52, true], "aps.12.07": [51, true], "aps.12.08": [55, true], "aps.12.09": [52, true], "aps.12.10": [52, true], "aps.12.11": [56, true], "aps.12.12": [53, true], "aps.12.13": [58, true], "aps.12.14": [54, true], "aps.12.15": [58, true], "aps.12.16": [53, true], "aps.12.17": [54, true], "aps.12.18": [54, true], "aps.13.00": [8, false], "aps.14.00": [54, true], "aps.14.01": [54, true], "aps.14.02": [53, true], "aps.14.03": [54, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [54, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [54, true], "aps.14.11": [53, true], "aps.14.12": [54, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [54, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [54, true], "aps.14.21": [54, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [54, true], "aps.14.26": [54, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [54, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [54, true], "aps.14.37": [53, true], "aps.14.38": [54, true], "aps.14.39": [53, true], "aps.15.00": [49, true], "aps.15.01": [49, true], "aps.15.02": [47, true], "aps.15.03": [47, true], "aps.15.04": [51, true], "aps.15.05": [49, true], "aps.15.06": [48, true], "aps.15.07": [48, true], "aps.15.08": [46, true], "aps.15.09": [47, true], "aps.15.10": [49, true], "aps.15.11": [47, true], "aps.15.12": [46, true], "aps.15.13": [46, true], "aps.15.14": [47, true], "aps.15.15": [49, true], "aps.15.16": [48, true], "aps.15.17": [46, true], "aps.15.18": [48, true], "aps.15.19": [47, true], "aps.15.20": [48, true], "aps.15.21": [51, true], "aps.15.22": [48, true], "aps.15.23": [46, true], "aps.15.24": [51, true], "aps.15.25": [46, true], "aps.15.26": [49, true], "aps.15.27": [47, true], "aps.15.28": [46, true], "aps.15.29": [47, true], "aps.15.30": [49, true]}}, "CHA": {"total": 3245, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [44, true], "fun1.2": [50, true], "fun1.3": [50, true], "fun1.4": [55, true], "fun1.5": [74, true], "fun2.1": [45, true], "fun2.2": [69, true], "fun2.3": [68, true], "fun2.4": [81, true], "fun2.5": [84, true], "fun3.1": [57, true], "fun3.2": [60, true], "fun3.3": [55, true], "fun3.4": [74, true], "fun3.5": [76, true], "fun4.1": [45, true], "fun4.2": [56, true], "fun4.3": [58, true], "fun4.4": [67, true], "fun4.5": [65, true], "fun5.1": [65, true], "fun5.2": [61, true], "fun5.3": [46, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [43, true], "fun6.2": [47, true], "fun6.3": [43, true], "fun6.4": [47, true], "fun6.5": [48, true], "fun7.1": [8, false], "fun7.2": [10, false], "fun7.3": [12, false], "fun7.4": [13, false], "fun7.5": [15, false], "fun8.1": [46, true], "fun8.2": [50, true], "fun8.3": [52, true], "fun8.4": [57, true], "fun8.5": [54, true], "fun9.1": [45, true], "fun9.2": [49, true], "fun9.3": [54, true], "fun9.4": [52, true], "fun9.5": [54, true]}}}, {"label": "pure.exp_sq.bracket.safe", "spec": ["pure", "exp_sq", "bracket", "safe"], "APS": {"total": 10433, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [64, true], "aps.02.00": [62, true], "aps.02.01": [63, true], "aps.02.02": [66, true], "aps.02.03": [76, true], "aps.02.04": [72, true], "aps.02.05": [63, true], "aps.02.06": [69, true], "aps.02.07": [67, true], "aps.02.08": [66, true], "aps.02.09": [66, true], "aps.03.00": [73, true], "aps.03.01": [69, true], "aps.03.02": [67, true], "aps.04.00": [64, true], "aps.04.01": [71, true], "aps.04.02": [66, true], "aps.04.03": [62, true], "aps.04.04": [58, true], "aps.04.05": [74, true], "aps.04.06": [72, true], "aps.04.07": [70, true], "aps.04.08": [66, true], "aps.04.09": [61, true], "aps.04.10": [71, true], "aps.04.11": [69, true], "aps.04.12": [63, true], "aps.04.13": [68, true], "aps.05.00": [66, true], "aps.06.00": [60, true], "aps.06.01": [68, true], "aps.06.02": [66, true], "aps.06.03": [70, true], "aps.06.04": [61, true], "aps.06.05": [66, true], "aps.06.06": [66, true], "aps.06.07": [67, true], "aps.06.08": [62, true], "aps.06.09": [63, true], "aps.07.00": [60, true], "aps.07.01": [63, true], "aps.07.02": [60, true], "aps.08.00": [3, true], "aps.08.01": [63, true], "aps.08.02": [67, true], "aps.08.03": [70, true], "aps.08.04": [64, true], "aps.09.00": [70, true], "aps.09.01": [66, true], "aps.09.02": [61, true], "aps.09.03": [57, true], "aps.09.04": [53, true], "aps.09.05": [53, true], "aps.09.06": [50, true], "aps.10.00": [67, true], "aps.10.01": [61, true], "aps.10.02": [63, true], "aps.10.03": [62, true], "aps.10.04": [67, true], "aps.11.00": [60, true], "aps.11.01": [67, true], "aps.11.02": [72, true], "aps.11.03": [71, true], "aps.12.00": [67, true], "aps.12.01": [66, true], "aps.12.02": [73, true], "aps.12.03": [66, true], "aps.12.04": [72, true], "aps.12.05": [71, true], "aps.12.06": [70, true], "aps.12.07": [73, true], "aps.12.08": [80, true], "aps.12.09": [74, true], "aps.12.10": [73, true], "aps.12.11": [79, true], "aps.12.12": [77, true], "aps.12.13": [72, true], "aps.12.14": [75, true], "aps.12.15": [71, true], "aps.12.16": [81, true], "aps.12.17": [78, true], "aps.12.18": [74, true], "aps.13.00": [10, false], "aps.14.00": [74, true], "aps.14.01": [74, true], "aps.14.02": [74, true], "aps.14.03": [74, true], "aps.14.04": [74, true], "aps.14.05": [74, true], "aps.14.06": [74, true], "aps.14.07": [74, true], "aps.14.08": [74, true], "aps.14.09": [74, true], "aps.14.10": [74, true], "aps.14.11": [74, true], "aps.14.12": [74, true], "aps.14.13": [74, true], "aps.14.14": [74, true], "aps.14.15": [74, true], "aps.14.16": [74, true], "aps.14.17": [74, true], "aps.14.18": [74, true], "aps.14.19": [74, true], "aps.14.20": [74, true], "aps.14.21": [74, true], "aps.14.22": [74, true], "aps.14.23": [74, true], "aps.14.24": [74, true], "aps.14.25": [74, true], "aps.14.26": [74, true], "aps.14.27": [74, true], "aps.14.28": [74, true], "aps.14.29": [74, true], "aps.14.30": [74, true], "aps.14.31": [74, true], "aps.14.32": [74, true], "aps.14.33": [74, true], "aps.14.34": [74, true], "aps.14.35": [74, true], "aps.14.36": [74, true], "aps.14.37": [74, true], "aps.14.38": [74, true], "aps.14.39": [74, true], "aps.15.00": [62, true], "aps.15.01": [62, true], "aps.15.02": [61, true], "aps.15.03": [62, true], "aps.15.04": [64, true], "aps.15.05": [59, true], "aps.15.06": [64, true], "aps.15.07": [58, true], "aps.15.08": [59, true], "aps.15.09": [62, true], "aps.15.10": [60, true], "aps.15.11": [59, true], "aps.15.12": [63, true], "aps.15.13": [55, true], "aps.15.14": [57, true], "aps.15.15": [62, true], "aps.15.16": [60, true], "aps.15.17": [52, true], "aps.15.18": [60, true], "aps.15.19": [59, true], "aps.15.20": [60, true], "aps.15.21": [57, true], "aps.15.22": [56, true], "aps.15.23": [56, true], "aps.15.24": [63, true], "aps.15.25": [59, true], "aps.15.26": [60, true], "aps.15.27": [56, true], "aps.15.28": [58, true], "aps.15.29": [58, true], "aps.15.30": [55, true]}}, "CHA": {"total": 3883, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [62, true], "fun1.2": [64, true], "fun1.3": [65, true], "fun1.4": [75, true], "fun1.5": [89, true], "fun2.1": [61, true], "fun2.2": [99, true], "fun2.3": [81, true], "fun2.4": [96, true], "fun2.5": [102, true], "fun3.1": [79, true], "fun3.2": [77, true], "fun3.3": [70, true], "fun3.4": [83, true], "fun3.5": [89, true], "fun4.1": [72, true], "fun4.2": [73, true], "fun4.3": [77, true], "fun4.4": [80, true], "fun4.5": [94, true], "fun5.1": [88, true], "fun5.2": [73, true], "fun5.3": [61, true], "fun5.4": [62, true], "fun5.5": [63, true], "fun6.1": [49, true], "fun6.2": [53, true], "fun6.3": [49, true], "fun6.4": [53, true], "fun6.5": [54, true], "fun7.1": [10, false], "fun7.2": [16, false], "fun7.3": [11, false], "fun7.4": [19, false], "fun7.5": [14, false], "fun8.1": [65, true], "fun8.2": [65, true], "fun8.3": [71, true], "fun8.4": [73, true], "fun8.5": [73, true], "fun9.1": [59, true], "fun9.2": [71, true], "fun9.3": [76, true], "fun9.4": [72, true], "fun9.5": [65, true]}}}, {"label": "pure.exp_sq.bracket.credit", "spec": ["pure", "exp_sq", "bracket", "credit"], "APS": {"total": 7662, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [46, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [44, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [42, true], "aps.09.06": [42, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [7, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [52, true], "aps.15.07": [52, true], "aps.15.08": [52, true], "aps.15.09": [53, true], "aps.15.10": [51, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [52, true], "aps.15.14": [53, true], "aps.15.15": [52, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [52, true], "aps.15.21": [53, true], "aps.15.22": [52, true], "aps.15.23": [52, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [47, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3128, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [7, false], "fun7.2": [8, false], "fun7.3": [8, false], "fun7.4": [10, false], "fun7.5": [12, false], "fun8.1": [43, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [49, true]}}}, {"label": "pure.exp_abs.derived3.both", "spec": ["pure", "exp_abs", "derived3", "both"], "APS": {"total": 8067, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [48, true], "aps.02.00": [49, true], "aps.02.01": [49, true], "aps.02.02": [50, true], "aps.02.03": [51, true], "aps.02.04": [50, true], "aps.02.05": [51, true], "aps.02.06": [50, true], "aps.02.07": [52, true], "aps.02.08": [51, true], "aps.02.09": [52, true], "aps.03.00": [54, true], "aps.03.01": [54, true], "aps.03.02": [54, true], "aps.04.00": [51, true], "aps.04.01": [51, true], "aps.04.02": [52, true], "aps.04.03": [35, true], "aps.04.04": [51, true], "aps.04.05": [50, true], "aps.04.06": [50, true], "aps.04.07": [51, true], "aps.04.08": [45, true], "aps.04.09": [52, true], "aps.04.10": [50, true], "aps.04.11": [48, true], "aps.04.12": [49, true], "aps.04.13": [50, true], "aps.05.00": [48, true], "aps.06.00": [46, true], "aps.06.01": [46, true], "aps.06.02": [45, true], "aps.06.03": [46, true], "aps.06.04": [46, true], "aps.06.05": [46, true], "aps.06.06": [46, true], "aps.06.07": [47, true], "aps.06.08": [46, true], "aps.06.09": [46, true], "aps.07.00": [44, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [47, true], "aps.08.01": [45, true], "aps.08.02": [46, true], "aps.08.03": [47, true], "aps.08.04": [41, true], "aps.09.00": [45, true], "aps.09.01": [45, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [41, true], "aps.09.05": [39, true], "aps.09.06": [39, true], "aps.10.00": [46, true], "aps.10.01": [48, true], "aps.10.02": [48, true], "aps.10.03": [49, true], "aps.10.04": [49, true], "aps.11.00": [34, true], "aps.11.01": [47, true], "aps.11.02": [47, true], "aps.11.03": [42, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [51, true], "aps.12.03": [45, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [51, true], "aps.12.08": [50, true], "aps.12.09": [52, true], "aps.12.10": [48, true], "aps.12.11": [51, true], "aps.12.12": [51, true], "aps.12.13": [53, true], "aps.12.14": [50, true], "aps.12.15": [48, true], "aps.12.16": [51, true], "aps.12.17": [53, true], "aps.12.18": [52, true], "aps.13.00": [6, false], "aps.14.00": [56, true], "aps.14.01": [56, true], "aps.14.02": [56, true], "aps.14.03": [56, true], "aps.14.04": [56, true], "aps.14.05": [56, true], "aps.14.06": [56, true], "aps.14.07": [56, true], "aps.14.08": [57, true], "aps.14.09": [56, true], "aps.14.10": [57, true], "aps.14.11": [56, true], "aps.14.12": [56, true], "aps.14.13": [56, true], "aps.14.14": [56, true], "aps.14.15": [56, true], "aps.14.16": [56, true], "aps.14.17": [57, true], "aps.14.18": [56, true], "aps.14.19": [56, true], "aps.14.20": [56, true], "aps.14.21": [57, true], "aps.14.22": [56, true], "aps.14.23": [56, true], "aps.14.24": [56, true], "aps.14.25": [56, true], "aps.14.26": [56, true], "aps.14.27": [56, true], "aps.14.28": [56, true], "aps.14.29": [56, true], "aps.14.30": [56, true], "aps.14.31": [56, true], "aps.14.32": [57, true], "aps.14.33": [56, true], "aps.14.34": [56, true], "aps.14.35": [57, true], "aps.14.36": [56, true], "aps.14.37": [56, true], "aps.14.38": [56, true], "aps.14.39": [56, true], "aps.15.00": [56, true], "aps.15.01": [55, true], "aps.15.02": [55, true], "aps.15.03": [55, true], "aps.15.04": [55, true], "aps.15.05": [54, true], "aps.15.06": [56, true], "aps.15.07": [55, true], "aps.15.08": [55, true], "aps.15.09": [55, true], "aps.15.10": [54, true], "aps.15.11": [55, true], "aps.15.12": [54, true], "aps.15.13": [55, true], "aps.15.14": [55, true], "aps.15.15": [54, true], "aps.15.16": [54, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [55, true], "aps.15.24": [56, true], "aps.15.25": [56, true], "aps.15.26": [56, true], "aps.15.27": [55, true], "aps.15.28": [54, true], "aps.15.29": [57, true], "aps.15.30": [57, true]}}, "CHA": {"total": 3699, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [47, true], "fun1.2": [49, true], "fun1.3": [54, true], "fun1.4": [68, true], "fun1.5": [93, true], "fun2.1": [44, true], "fun2.2": [65, true], "fun2.3": [71, true], "fun2.4": [80, true], "fun2.5": [90, true], "fun3.1": [64, true], "fun3.2": [68, true], "fun3.3": [84, true], "fun3.4": [92, true], "fun3.5": [109, true], "fun4.1": [69, true], "fun4.2": [68, true], "fun4.3": [87, true], "fun4.4": [96, true], "fun4.5": [120, true], "fun5.1": [70, true], "fun5.2": [74, true], "fun5.3": [73, true], "fun5.4": [76, true], "fun5.5": [77, true], "fun6.1": [54, true], "fun6.2": [63, true], "fun6.3": [56, true], "fun6.4": [64, true], "fun6.5": [64, true], "fun7.1": [6, false], "fun7.2": [11, false], "fun7.3": [8, false], "fun7.4": [13, false], "fun7.5": [38, false], "fun8.1": [48, true], "fun8.2": [48, true], "fun8.3": [49, true], "fun8.4": [54, true], "fun8.5": [57, true], "fun9.1": [46, true], "fun9.2": [48, true], "fun9.3": [51, true], "fun9.4": [54, true], "fun9.5": [55, true]}}}, {"label": "pure.exp_sq.bracket.project", "spec": ["pure", "exp_sq", "bracket", "project"], "APS": {"total": 14555, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [86, true], "aps.02.01": [88, true], "aps.02.02": [88, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [90, true], "aps.02.06": [87, true], "aps.02.07": [91, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [78, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [82, true], "aps.06.03": [83, true], "aps.06.04": [81, true], "aps.06.05": [82, true], "aps.06.06": [83, true], "aps.06.07": [82, true], "aps.06.08": [82, true], "aps.06.09": [81, true], "aps.07.00": [82, true], "aps.07.01": [82, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [82, true], "aps.08.02": [82, true], "aps.08.03": [82, true], "aps.08.04": [82, true], "aps.09.00": [82, true], "aps.09.01": [82, true], "aps.09.02": [82, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [81, true], "aps.09.06": [82, true], "aps.10.00": [81, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [72, true], "aps.11.02": [82, true], "aps.11.03": [82, true], "aps.12.00": [95, true], "aps.12.01": [96, true], "aps.12.02": [95, true], "aps.12.03": [96, true], "aps.12.04": [96, true], "aps.12.05": [97, true], "aps.12.06": [96, true], "aps.12.07": [96, true], "aps.12.08": [96, true], "aps.12.09": [96, true], "aps.12.10": [80, true], "aps.12.11": [96, true], "aps.12.12": [96, true], "aps.12.13": [96, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [83, true], "aps.12.18": [79, true], "aps.13.00": [51, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [102, true], "aps.15.01": [102, true], "aps.15.02": [101, true], "aps.15.03": [102, true], "aps.15.04": [102, true], "aps.15.05": [102, true], "aps.15.06": [102, true], "aps.15.07": [103, true], "aps.15.08": [102, true], "aps.15.09": [102, true], "aps.15.10": [102, true], "aps.15.11": [102, true], "aps.15.12": [102, true], "aps.15.13": [102, true], "aps.15.14": [102, true], "aps.15.15": [102, true], "aps.15.16": [102, true], "aps.15.17": [101, true], "aps.15.18": [101, true], "aps.15.19": [101, true], "aps.15.20": [102, true], "aps.15.21": [102, true], "aps.15.22": [102, true], "aps.15.23": [99, true], "aps.15.24": [102, true], "aps.15.25": [102, true], "aps.15.26": [102, true], "aps.15.27": [102, true], "aps.15.28": [103, true], "aps.15.29": [102, true], "aps.15.30": [101, true]}}, "CHA": {"total": 5089, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [90, true], "fun1.3": [96, true], "fun1.4": [112, true], "fun1.5": [152, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [150, true], "fun2.5": [161, true], "fun3.1": [88, true], "fun3.2": [92, true], "fun3.3": [112, true], "fun3.4": [124, true], "fun3.5": [152, true], "fun4.1": [76, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [124, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [51, false], "fun7.3": [90, false], "fun7.4": [58, false], "fun7.5": [57, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.exp_sq.start.none", "spec": ["pure", "exp_sq", "start", "none"], "APS": {"total": 28955, "solved": 12, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [200, false], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.exp_sq.derived.bracket", "spec": ["pure", "exp_sq", "derived", "bracket"], "APS": {"total": 9404, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [55, true], "aps.02.00": [61, true], "aps.02.01": [59, true], "aps.02.02": [62, true], "aps.02.03": [62, true], "aps.02.04": [67, true], "aps.02.05": [65, true], "aps.02.06": [63, true], "aps.02.07": [66, true], "aps.02.08": [61, true], "aps.02.09": [64, true], "aps.03.00": [59, true], "aps.03.01": [58, true], "aps.03.02": [67, true], "aps.04.00": [59, true], "aps.04.01": [60, true], "aps.04.02": [56, true], "aps.04.03": [63, true], "aps.04.04": [60, true], "aps.04.05": [58, true], "aps.04.06": [57, true], "aps.04.07": [60, true], "aps.04.08": [56, true], "aps.04.09": [60, true], "aps.04.10": [57, true], "aps.04.11": [56, true], "aps.04.12": [68, true], "aps.04.13": [59, true], "aps.05.00": [54, true], "aps.06.00": [57, true], "aps.06.01": [57, true], "aps.06.02": [57, true], "aps.06.03": [57, true], "aps.06.04": [47, true], "aps.06.05": [54, true], "aps.06.06": [57, true], "aps.06.07": [55, true], "aps.06.08": [55, true], "aps.06.09": [54, true], "aps.07.00": [57, true], "aps.07.01": [51, true], "aps.07.02": [49, true], "aps.08.00": [57, true], "aps.08.01": [58, true], "aps.08.02": [57, true], "aps.08.03": [56, true], "aps.08.04": [52, true], "aps.09.00": [58, true], "aps.09.01": [54, true], "aps.09.02": [51, true], "aps.09.03": [50, true], "aps.09.04": [48, true], "aps.09.05": [47, true], "aps.09.06": [49, true], "aps.10.00": [52, true], "aps.10.01": [60, true], "aps.10.02": [55, true], "aps.10.03": [57, true], "aps.10.04": [52, true], "aps.11.00": [56, true], "aps.11.01": [61, true], "aps.11.02": [59, true], "aps.11.03": [58, true], "aps.12.00": [63, true], "aps.12.01": [60, true], "aps.12.02": [68, true], "aps.12.03": [62, true], "aps.12.04": [62, true], "aps.12.05": [61, true], "aps.12.06": [67, true], "aps.12.07": [65, true], "aps.12.08": [65, true], "aps.12.09": [61, true], "aps.12.10": [68, true], "aps.12.11": [69, true], "aps.12.12": [66, true], "aps.12.13": [65, true], "aps.12.14": [64, true], "aps.12.15": [68, true], "aps.12.16": [62, true], "aps.12.17": [63, true], "aps.12.18": [66, true], "aps.13.00": [10, false], "aps.14.00": [61, true], "aps.14.01": [61, true], "aps.14.02": [61, true], "aps.14.03": [61, true], "aps.14.04": [61, true], "aps.14.05": [61, true], "aps.14.06": [61, true], "aps.14.07": [61, true], "aps.14.08": [61, true], "aps.14.09": [61, true], "aps.14.10": [61, true], "aps.14.11": [61, true], "aps.14.12": [61, true], "aps.14.13": [61, true], "aps.14.14": [61, true], "aps.14.15": [61, true], "aps.14.16": [61, true], "aps.14.17": [61, true], "aps.14.18": [61, true], "aps.14.19": [61, true], "aps.14.20": [61, true], "aps.14.21": [61, true], "aps.14.22": [61, true], "aps.14.23": [61, true], "aps.14.24": [61, true], "aps.14.25": [61, true], "aps.14.26": [61, true], "aps.14.27": [61, true], "aps.14.28": [61, true], "aps.14.29": [61, true], "aps.14.30": [61, true], "aps.14.31": [61, true], "aps.14.32": [61, true], "aps.14.33": [61, true], "aps.14.34": [61, true], "aps.14.35": [61, true], "aps.14.36": [61, true], "aps.14.37": [61, true], "aps.14.38": [61, true], "aps.14.39": [61, true], "aps.15.00": [61, true], "aps.15.01": [64, true], "aps.15.02": [63, true], "aps.15.03": [63, true], "aps.15.04": [63, true], "aps.15.05": [63, true], "aps.15.06": [65, true], "aps.15.07": [63, true], "aps.15.08": [61, true], "aps.15.09": [66, true], "aps.15.10": [62, true], "aps.15.11": [65, true], "aps.15.12": [65, true], "aps.15.13": [66, true], "aps.15.14": [64, true], "aps.15.15": [65, true], "aps.15.16": [65, true], "aps.15.17": [63, true], "aps.15.18": [57, true], "aps.15.19": [60, true], "aps.15.20": [61, true], "aps.15.21": [61, true], "aps.15.22": [56, true], "aps.15.23": [62, true], "aps.15.24": [58, true], "aps.15.25": [61, true], "aps.15.26": [62, true], "aps.15.27": [61, true], "aps.15.28": [60, true], "aps.15.29": [61, true], "aps.15.30": [66, true]}}, "CHA": {"total": 3901, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [54, true], "fun1.2": [61, true], "fun1.3": [68, true], "fun1.4": [82, true], "fun1.5": [116, true], "fun2.1": [56, true], "fun2.2": [74, true], "fun2.3": [76, true], "fun2.4": [91, true], "fun2.5": [98, true], "fun3.1": [78, true], "fun3.2": [82, true], "fun3.3": [98, true], "fun3.4": [110, true], "fun3.5": [134, true], "fun4.1": [61, true], "fun4.2": [63, true], "fun4.3": [88, true], "fun4.4": [92, true], "fun4.5": [116, true], "fun5.1": [70, true], "fun5.2": [66, true], "fun5.3": [72, true], "fun5.4": [73, true], "fun5.5": [74, true], "fun6.1": [50, true], "fun6.2": [42, true], "fun6.3": [49, true], "fun6.4": [51, true], "fun6.5": [52, true], "fun7.1": [10, false], "fun7.2": [10, false], "fun7.3": [10, false], "fun7.4": [15, false], "fun7.5": [14, false], "fun8.1": [52, true], "fun8.2": [61, true], "fun8.3": [63, true], "fun8.4": [63, true], "fun8.5": [66, true], "fun9.1": [52, true], "fun9.2": [58, true], "fun9.3": [63, true], "fun9.4": [63, true], "fun9.5": [63, true]}}}, {"label": "pure.exp_sq.derived.both", "spec": ["pure", "exp_sq", "derived", "both"], "APS": {"total": 9414, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [56, true], "aps.02.00": [59, true], "aps.02.01": [56, true], "aps.02.02": [57, true], "aps.02.03": [63, true], "aps.02.04": [60, true], "aps.02.05": [60, true], "aps.02.06": [62, true], "aps.02.07": [64, true], "aps.02.08": [63, true], "aps.02.09": [59, true], "aps.03.00": [61, true], "aps.03.01": [58, true], "aps.03.02": [61, true], "aps.04.00": [56, true], "aps.04.01": [56, true], "aps.04.02": [58, true], "aps.04.03": [60, true], "aps.04.04": [53, true], "aps.04.05": [57, true], "aps.04.06": [57, true], "aps.04.07": [60, true], "aps.04.08": [58, true], "aps.04.09": [59, true], "aps.04.10": [59, true], "aps.04.11": [59, true], "aps.04.12": [64, true], "aps.04.13": [58, true], "aps.05.00": [54, true], "aps.06.00": [53, true], "aps.06.01": [54, true], "aps.06.02": [52, true], "aps.06.03": [55, true], "aps.06.04": [52, true], "aps.06.05": [56, true], "aps.06.06": [56, true], "aps.06.07": [55, true], "aps.06.08": [51, true], "aps.06.09": [52, true], "aps.07.00": [50, true], "aps.07.01": [54, true], "aps.07.02": [51, true], "aps.08.00": [57, true], "aps.08.01": [56, true], "aps.08.02": [57, true], "aps.08.03": [54, true], "aps.08.04": [52, true], "aps.09.00": [49, true], "aps.09.01": [48, true], "aps.09.02": [48, true], "aps.09.03": [55, true], "aps.09.04": [44, true], "aps.09.05": [48, true], "aps.09.06": [44, true], "aps.10.00": [57, true], "aps.10.01": [57, true], "aps.10.02": [53, true], "aps.10.03": [57, true], "aps.10.04": [58, true], "aps.11.00": [56, true], "aps.11.01": [61, true], "aps.11.02": [55, true], "aps.11.03": [56, true], "aps.12.00": [60, true], "aps.12.01": [63, true], "aps.12.02": [59, true], "aps.12.03": [64, true], "aps.12.04": [57, true], "aps.12.05": [62, true], "aps.12.06": [61, true], "aps.12.07": [61, true], "aps.12.08": [63, true], "aps.12.09": [68, true], "aps.12.10": [70, true], "aps.12.11": [64, true], "aps.12.12": [65, true], "aps.12.13": [63, true], "aps.12.14": [61, true], "aps.12.15": [60, true], "aps.12.16": [63, true], "aps.12.17": [61, true], "aps.12.18": [61, true], "aps.13.00": [8, false], "aps.14.00": [65, true], "aps.14.01": [65, true], "aps.14.02": [65, true], "aps.14.03": [65, true], "aps.14.04": [65, true], "aps.14.05": [65, true], "aps.14.06": [65, true], "aps.14.07": [65, true], "aps.14.08": [65, true], "aps.14.09": [65, true], "aps.14.10": [65, true], "aps.14.11": [65, true], "aps.14.12": [65, true], "aps.14.13": [65, true], "aps.14.14": [65, true], "aps.14.15": [65, true], "aps.14.16": [65, true], "aps.14.17": [65, true], "aps.14.18": [65, true], "aps.14.19": [65, true], "aps.14.20": [65, true], "aps.14.21": [65, true], "aps.14.22": [65, true], "aps.14.23": [65, true], "aps.14.24": [65, true], "aps.14.25": [65, true], "aps.14.26": [65, true], "aps.14.27": [65, true], "aps.14.28": [65, true], "aps.14.29": [65, true], "aps.14.30": [65, true], "aps.14.31": [65, true], "aps.14.32": [65, true], "aps.14.33": [65, true], "aps.14.34": [65, true], "aps.14.35": [65, true], "aps.14.36": [65, true], "aps.14.37": [65, true], "aps.14.38": [65, true], "aps.14.39": [65, true], "aps.15.00": [65, true], "aps.15.01": [65, true], "aps.15.02": [62, true], "aps.15.03": [62, true], "aps.15.04": [62, true], "aps.15.05": [63, true], "aps.15.06": [64, true], "aps.15.07": [63, true], "aps.15.08": [62, true], "aps.15.09": [63, true], "aps.15.10": [62, true], "aps.15.11": [64, true], "aps.15.12": [64, true], "aps.15.13": [62, true], "aps.15.14": [64, true], "aps.15.15": [63, true], "aps.15.16": [59, true], "aps.15.17": [63, true], "aps.15.18": [63, true], "aps.15.19": [62, true], "aps.15.20": [60, true], "aps.15.21": [59, true], "aps.15.22": [57, true], "aps.15.23": [61, true], "aps.15.24": [57, true], "aps.15.25": [58, true], "aps.15.26": [59, true], "aps.15.27": [60, true], "aps.15.28": [62, true], "aps.15.29": [59, true], "aps.15.30": [59, true]}}, "CHA": {"total": 3718, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [59, true], "fun1.3": [63, true], "fun1.4": [76, true], "fun1.5": [110, true], "fun2.1": [53, true], "fun2.2": [71, true], "fun2.3": [73, true], "fun2.4": [90, true], "fun2.5": [96, true], "fun3.1": [68, true], "fun3.2": [68, true], "fun3.3": [84, true], "fun3.4": [95, true], "fun3.5": [115, true], "fun4.1": [57, true], "fun4.2": [64, true], "fun4.3": [78, true], "fun4.4": [87, true], "fun4.5": [109, true], "fun5.1": [67, true], "fun5.2": [62, true], "fun5.3": [62, true], "fun5.4": [65, true], "fun5.5": [66, true], "fun6.1": [40, true], "fun6.2": [41, true], "fun6.3": [50, true], "fun6.4": [45, true], "fun6.5": [47, true], "fun7.1": [8, false], "fun7.2": [9, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [16, false], "fun8.1": [54, true], "fun8.2": [59, true], "fun8.3": [62, true], "fun8.4": [64, true], "fun8.5": [65, true], "fun9.1": [53, true], "fun9.2": [56, true], "fun9.3": [61, true], "fun9.4": [63, true], "fun9.5": [62, true]}}}, {"label": "pure.exp_sq.derived.step", "spec": ["pure", "exp_sq", "derived", "step"], "APS": {"total": 17920, "solved": 153, "n": 154, "over": 122, "per": {"aps.01.00": [118, true], "aps.02.00": [113, true], "aps.02.01": [120, true], "aps.02.02": [128, true], "aps.02.03": [124, true], "aps.02.04": [119, true], "aps.02.05": [120, true], "aps.02.06": [125, true], "aps.02.07": [124, true], "aps.02.08": [124, true], "aps.02.09": [125, true], "aps.03.00": [119, true], "aps.03.01": [122, true], "aps.03.02": [122, true], "aps.04.00": [117, true], "aps.04.01": [115, true], "aps.04.02": [111, true], "aps.04.03": [113, true], "aps.04.04": [114, true], "aps.04.05": [116, true], "aps.04.06": [115, true], "aps.04.07": [115, true], "aps.04.08": [115, true], "aps.04.09": [115, true], "aps.04.10": [118, true], "aps.04.11": [115, true], "aps.04.12": [116, true], "aps.04.13": [117, true], "aps.05.00": [118, true], "aps.06.00": [117, true], "aps.06.01": [117, true], "aps.06.02": [104, true], "aps.06.03": [111, true], "aps.06.04": [108, true], "aps.06.05": [108, true], "aps.06.06": [107, true], "aps.06.07": [99, true], "aps.06.08": [107, true], "aps.06.09": [102, true], "aps.07.00": [110, true], "aps.07.01": [108, true], "aps.07.02": [103, true], "aps.08.00": [121, true], "aps.08.01": [119, true], "aps.08.02": [112, true], "aps.08.03": [110, true], "aps.08.04": [108, true], "aps.09.00": [113, true], "aps.09.01": [108, true], "aps.09.02": [109, true], "aps.09.03": [103, true], "aps.09.04": [98, true], "aps.09.05": [91, true], "aps.09.06": [86, true], "aps.10.00": [117, true], "aps.10.01": [119, true], "aps.10.02": [113, true], "aps.10.03": [109, true], "aps.10.04": [112, true], "aps.11.00": [108, true], "aps.11.01": [114, true], "aps.11.02": [107, true], "aps.11.03": [110, true], "aps.12.00": [120, true], "aps.12.01": [125, true], "aps.12.02": [125, true], "aps.12.03": [123, true], "aps.12.04": [124, true], "aps.12.05": [130, true], "aps.12.06": [128, true], "aps.12.07": [127, true], "aps.12.08": [131, true], "aps.12.09": [133, true], "aps.12.10": [134, true], "aps.12.11": [134, true], "aps.12.12": [131, true], "aps.12.13": [120, true], "aps.12.14": [130, true], "aps.12.15": [132, true], "aps.12.16": [131, true], "aps.12.17": [130, true], "aps.12.18": [128, true], "aps.13.00": [11, false], "aps.14.00": [128, true], "aps.14.01": [128, true], "aps.14.02": [128, true], "aps.14.03": [128, true], "aps.14.04": [128, true], "aps.14.05": [128, true], "aps.14.06": [128, true], "aps.14.07": [128, true], "aps.14.08": [128, true], "aps.14.09": [128, true], "aps.14.10": [128, true], "aps.14.11": [128, true], "aps.14.12": [128, true], "aps.14.13": [128, true], "aps.14.14": [128, true], "aps.14.15": [128, true], "aps.14.16": [128, true], "aps.14.17": [128, true], "aps.14.18": [128, true], "aps.14.19": [128, true], "aps.14.20": [128, true], "aps.14.21": [128, true], "aps.14.22": [128, true], "aps.14.23": [128, true], "aps.14.24": [128, true], "aps.14.25": [128, true], "aps.14.26": [128, true], "aps.14.27": [128, true], "aps.14.28": [128, true], "aps.14.29": [128, true], "aps.14.30": [128, true], "aps.14.31": [128, true], "aps.14.32": [128, true], "aps.14.33": [128, true], "aps.14.34": [128, true], "aps.14.35": [128, true], "aps.14.36": [128, true], "aps.14.37": [128, true], "aps.14.38": [128, true], "aps.14.39": [128, true], "aps.15.00": [104, true], "aps.15.01": [104, true], "aps.15.02": [99, true], "aps.15.03": [102, true], "aps.15.04": [103, true], "aps.15.05": [104, true], "aps.15.06": [101, true], "aps.15.07": [99, true], "aps.15.08": [99, true], "aps.15.09": [98, true], "aps.15.10": [99, true], "aps.15.11": [100, true], "aps.15.12": [100, true], "aps.15.13": [100, true], "aps.15.14": [100, true], "aps.15.15": [99, true], "aps.15.16": [99, true], "aps.15.17": [101, true], "aps.15.18": [102, true], "aps.15.19": [102, true], "aps.15.20": [102, true], "aps.15.21": [97, true], "aps.15.22": [91, true], "aps.15.23": [92, true], "aps.15.24": [86, true], "aps.15.25": [91, true], "aps.15.26": [91, true], "aps.15.27": [92, true], "aps.15.28": [95, true], "aps.15.29": [96, true], "aps.15.30": [95, true]}}, "CHA": {"total": 5403, "solved": 40, "n": 45, "over": 22, "per": {"fun1.1": [119, true], "fun1.2": [119, true], "fun1.3": [127, true], "fun1.4": [140, true], "fun1.5": [195, true], "fun2.1": [112, true], "fun2.2": [132, true], "fun2.3": [138, true], "fun2.4": [146, true], "fun2.5": [152, true], "fun3.1": [87, true], "fun3.2": [91, true], "fun3.3": [114, true], "fun3.4": [131, true], "fun3.5": [159, true], "fun4.1": [86, true], "fun4.2": [98, true], "fun4.3": [101, true], "fun4.4": [128, true], "fun4.5": [142, true], "fun5.1": [77, true], "fun5.2": [85, true], "fun5.3": [86, true], "fun5.4": [87, true], "fun5.5": [88, true], "fun6.1": [42, true], "fun6.2": [43, true], "fun6.3": [49, true], "fun6.4": [57, true], "fun6.5": [59, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [11, false], "fun7.4": [14, false], "fun7.5": [22, false], "fun8.1": [110, true], "fun8.2": [120, true], "fun8.3": [121, true], "fun8.4": [124, true], "fun8.5": [126, true], "fun9.1": [119, true], "fun9.2": [123, true], "fun9.3": [123, true], "fun9.4": [121, true], "fun9.5": [126, true]}}}, {"label": "pure.exp_sq.derived.credit", "spec": ["pure", "exp_sq", "derived", "credit"], "APS": {"total": 7679, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [49, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [47, true], "aps.12.18": [50, true], "aps.13.00": [7, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [7, false], "fun7.2": [10, false], "fun7.3": [11, false], "fun7.4": [49, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.exp_sq.bracket.none", "spec": ["pure", "exp_sq", "bracket", "none"], "APS": {"total": 30800, "solved": 0, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.exp_sq.derived.project", "spec": ["pure", "exp_sq", "derived", "project"], "APS": {"total": 14682, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [91, true], "aps.02.05": [90, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [93, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [88, true], "aps.04.07": [89, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [85, true], "aps.06.00": [82, true], "aps.06.01": [83, true], "aps.06.02": [82, true], "aps.06.03": [82, true], "aps.06.04": [82, true], "aps.06.05": [83, true], "aps.06.06": [83, true], "aps.06.07": [83, true], "aps.06.08": [82, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [82, true], "aps.07.02": [82, true], "aps.08.00": [83, true], "aps.08.01": [82, true], "aps.08.02": [82, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [83, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [83, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [83, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [96, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [97, true], "aps.12.12": [96, true], "aps.12.13": [97, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [96, true], "aps.12.18": [97, true], "aps.13.00": [51, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [102, true], "aps.15.01": [103, true], "aps.15.02": [102, true], "aps.15.03": [102, true], "aps.15.04": [103, true], "aps.15.05": [103, true], "aps.15.06": [102, true], "aps.15.07": [102, true], "aps.15.08": [102, true], "aps.15.09": [102, true], "aps.15.10": [102, true], "aps.15.11": [102, true], "aps.15.12": [102, true], "aps.15.13": [102, true], "aps.15.14": [102, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [102, true], "aps.15.20": [102, true], "aps.15.21": [103, true], "aps.15.22": [103, true], "aps.15.23": [102, true], "aps.15.24": [102, true], "aps.15.25": [103, true], "aps.15.26": [103, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [103, true], "aps.15.30": [102, true]}}, "CHA": {"total": 5112, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [90, true], "fun1.3": [96, true], "fun1.4": [112, true], "fun1.5": [152, true], "fun2.1": [83, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [150, true], "fun2.5": [162, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [88, true], "fun4.2": [93, true], "fun4.3": [113, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [52, false], "fun7.3": [52, false], "fun7.4": [57, false], "fun7.5": [59, false], "fun8.1": [85, true], "fun8.2": [87, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.exp_sq.derived.safe", "spec": ["pure", "exp_sq", "derived", "safe"], "APS": {"total": 14534, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [86, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [93, true], "aps.02.09": [93, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [89, true], "aps.05.00": [84, true], "aps.06.00": [83, true], "aps.06.01": [82, true], "aps.06.02": [82, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [83, true], "aps.06.07": [83, true], "aps.06.08": [82, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [82, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [83, true], "aps.08.02": [82, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [82, true], "aps.09.02": [82, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [83, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [83, true], "aps.11.00": [82, true], "aps.11.01": [82, true], "aps.11.02": [83, true], "aps.11.03": [83, true], "aps.12.00": [97, true], "aps.12.01": [96, true], "aps.12.02": [96, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [96, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [94, true], "aps.12.09": [96, true], "aps.12.10": [97, true], "aps.12.11": [96, true], "aps.12.12": [97, true], "aps.12.13": [97, true], "aps.12.14": [96, true], "aps.12.15": [97, true], "aps.12.16": [97, true], "aps.12.17": [96, true], "aps.12.18": [97, true], "aps.13.00": [11, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [101, true], "aps.15.01": [102, true], "aps.15.02": [99, true], "aps.15.03": [102, true], "aps.15.04": [102, true], "aps.15.05": [102, true], "aps.15.06": [101, true], "aps.15.07": [99, true], "aps.15.08": [99, true], "aps.15.09": [98, true], "aps.15.10": [99, true], "aps.15.11": [100, true], "aps.15.12": [100, true], "aps.15.13": [100, true], "aps.15.14": [100, true], "aps.15.15": [99, true], "aps.15.16": [99, true], "aps.15.17": [101, true], "aps.15.18": [102, true], "aps.15.19": [102, true], "aps.15.20": [102, true], "aps.15.21": [97, true], "aps.15.22": [91, true], "aps.15.23": [92, true], "aps.15.24": [86, true], "aps.15.25": [91, true], "aps.15.26": [91, true], "aps.15.27": [92, true], "aps.15.28": [95, true], "aps.15.29": [96, true], "aps.15.30": [95, true]}}, "CHA": {"total": 4834, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [146, true], "fun2.5": [152, true], "fun3.1": [87, true], "fun3.2": [92, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [86, true], "fun4.2": [92, true], "fun4.3": [101, true], "fun4.4": [125, true], "fun4.5": [142, true], "fun5.1": [77, true], "fun5.2": [85, true], "fun5.3": [86, true], "fun5.4": [87, true], "fun5.5": [88, true], "fun6.1": [42, true], "fun6.2": [43, true], "fun6.3": [49, true], "fun6.4": [57, true], "fun6.5": [59, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [11, false], "fun7.4": [14, false], "fun7.5": [22, false], "fun8.1": [85, true], "fun8.2": [86, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.exp_sq.derived3.both", "spec": ["pure", "exp_sq", "derived3", "both"], "APS": {"total": 9516, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [58, true], "aps.02.00": [60, true], "aps.02.01": [58, true], "aps.02.02": [56, true], "aps.02.03": [59, true], "aps.02.04": [61, true], "aps.02.05": [58, true], "aps.02.06": [62, true], "aps.02.07": [60, true], "aps.02.08": [61, true], "aps.02.09": [62, true], "aps.03.00": [61, true], "aps.03.01": [64, true], "aps.03.02": [63, true], "aps.04.00": [61, true], "aps.04.01": [62, true], "aps.04.02": [59, true], "aps.04.03": [62, true], "aps.04.04": [58, true], "aps.04.05": [60, true], "aps.04.06": [62, true], "aps.04.07": [56, true], "aps.04.08": [60, true], "aps.04.09": [60, true], "aps.04.10": [60, true], "aps.04.11": [60, true], "aps.04.12": [55, true], "aps.04.13": [58, true], "aps.05.00": [56, true], "aps.06.00": [53, true], "aps.06.01": [53, true], "aps.06.02": [51, true], "aps.06.03": [52, true], "aps.06.04": [54, true], "aps.06.05": [52, true], "aps.06.06": [53, true], "aps.06.07": [52, true], "aps.06.08": [54, true], "aps.06.09": [54, true], "aps.07.00": [51, true], "aps.07.01": [46, true], "aps.07.02": [51, true], "aps.08.00": [57, true], "aps.08.01": [52, true], "aps.08.02": [56, true], "aps.08.03": [53, true], "aps.08.04": [51, true], "aps.09.00": [46, true], "aps.09.01": [50, true], "aps.09.02": [48, true], "aps.09.03": [46, true], "aps.09.04": [47, true], "aps.09.05": [46, true], "aps.09.06": [43, true], "aps.10.00": [60, true], "aps.10.01": [58, true], "aps.10.02": [58, true], "aps.10.03": [51, true], "aps.10.04": [57, true], "aps.11.00": [56, true], "aps.11.01": [58, true], "aps.11.02": [59, true], "aps.11.03": [56, true], "aps.12.00": [60, true], "aps.12.01": [61, true], "aps.12.02": [60, true], "aps.12.03": [62, true], "aps.12.04": [59, true], "aps.12.05": [60, true], "aps.12.06": [64, true], "aps.12.07": [61, true], "aps.12.08": [66, true], "aps.12.09": [65, true], "aps.12.10": [65, true], "aps.12.11": [65, true], "aps.12.12": [64, true], "aps.12.13": [63, true], "aps.12.14": [60, true], "aps.12.15": [61, true], "aps.12.16": [63, true], "aps.12.17": [61, true], "aps.12.18": [69, true], "aps.13.00": [8, false], "aps.14.00": [68, true], "aps.14.01": [68, true], "aps.14.02": [68, true], "aps.14.03": [68, true], "aps.14.04": [68, true], "aps.14.05": [68, true], "aps.14.06": [68, true], "aps.14.07": [68, true], "aps.14.08": [68, true], "aps.14.09": [68, true], "aps.14.10": [68, true], "aps.14.11": [68, true], "aps.14.12": [68, true], "aps.14.13": [68, true], "aps.14.14": [68, true], "aps.14.15": [68, true], "aps.14.16": [68, true], "aps.14.17": [68, true], "aps.14.18": [68, true], "aps.14.19": [68, true], "aps.14.20": [68, true], "aps.14.21": [68, true], "aps.14.22": [68, true], "aps.14.23": [68, true], "aps.14.24": [68, true], "aps.14.25": [68, true], "aps.14.26": [68, true], "aps.14.27": [68, true], "aps.14.28": [68, true], "aps.14.29": [68, true], "aps.14.30": [68, true], "aps.14.31": [68, true], "aps.14.32": [68, true], "aps.14.33": [68, true], "aps.14.34": [68, true], "aps.14.35": [68, true], "aps.14.36": [68, true], "aps.14.37": [68, true], "aps.14.38": [68, true], "aps.14.39": [68, true], "aps.15.00": [63, true], "aps.15.01": [62, true], "aps.15.02": [62, true], "aps.15.03": [61, true], "aps.15.04": [63, true], "aps.15.05": [63, true], "aps.15.06": [63, true], "aps.15.07": [64, true], "aps.15.08": [61, true], "aps.15.09": [60, true], "aps.15.10": [63, true], "aps.15.11": [60, true], "aps.15.12": [61, true], "aps.15.13": [60, true], "aps.15.14": [63, true], "aps.15.15": [63, true], "aps.15.16": [60, true], "aps.15.17": [62, true], "aps.15.18": [62, true], "aps.15.19": [62, true], "aps.15.20": [64, true], "aps.15.21": [60, true], "aps.15.22": [55, true], "aps.15.23": [60, true], "aps.15.24": [60, true], "aps.15.25": [59, true], "aps.15.26": [57, true], "aps.15.27": [60, true], "aps.15.28": [60, true], "aps.15.29": [60, true], "aps.15.30": [58, true]}}, "CHA": {"total": 3778, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [54, true], "fun1.2": [57, true], "fun1.3": [66, true], "fun1.4": [74, true], "fun1.5": [104, true], "fun2.1": [52, true], "fun2.2": [72, true], "fun2.3": [79, true], "fun2.4": [90, true], "fun2.5": [98, true], "fun3.1": [64, true], "fun3.2": [67, true], "fun3.3": [85, true], "fun3.4": [96, true], "fun3.5": [111, true], "fun4.1": [66, true], "fun4.2": [70, true], "fun4.3": [83, true], "fun4.4": [94, true], "fun4.5": [123, true], "fun5.1": [67, true], "fun5.2": [68, true], "fun5.3": [68, true], "fun5.4": [71, true], "fun5.5": [73, true], "fun6.1": [39, true], "fun6.2": [40, true], "fun6.3": [40, true], "fun6.4": [49, true], "fun6.5": [45, true], "fun7.1": [8, false], "fun7.2": [10, false], "fun7.3": [7, false], "fun7.4": [13, false], "fun7.5": [16, false], "fun8.1": [56, true], "fun8.2": [59, true], "fun8.3": [58, true], "fun8.4": [67, true], "fun8.5": [66, true], "fun9.1": [58, true], "fun9.2": [60, true], "fun9.3": [64, true], "fun9.4": [63, true], "fun9.5": [62, true]}}}, {"label": "pure.exp_sq.derived3.bracket", "spec": ["pure", "exp_sq", "derived3", "bracket"], "APS": {"total": 9825, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [53, true], "aps.02.00": [61, true], "aps.02.01": [55, true], "aps.02.02": [59, true], "aps.02.03": [63, true], "aps.02.04": [63, true], "aps.02.05": [67, true], "aps.02.06": [59, true], "aps.02.07": [62, true], "aps.02.08": [63, true], "aps.02.09": [65, true], "aps.03.00": [67, true], "aps.03.01": [63, true], "aps.03.02": [61, true], "aps.04.00": [55, true], "aps.04.01": [60, true], "aps.04.02": [61, true], "aps.04.03": [62, true], "aps.04.04": [67, true], "aps.04.05": [56, true], "aps.04.06": [63, true], "aps.04.07": [58, true], "aps.04.08": [57, true], "aps.04.09": [65, true], "aps.04.10": [64, true], "aps.04.11": [64, true], "aps.04.12": [61, true], "aps.04.13": [63, true], "aps.05.00": [59, true], "aps.06.00": [59, true], "aps.06.01": [56, true], "aps.06.02": [51, true], "aps.06.03": [56, true], "aps.06.04": [58, true], "aps.06.05": [58, true], "aps.06.06": [57, true], "aps.06.07": [55, true], "aps.06.08": [54, true], "aps.06.09": [54, true], "aps.07.00": [57, true], "aps.07.01": [51, true], "aps.07.02": [50, true], "aps.08.00": [57, true], "aps.08.01": [60, true], "aps.08.02": [64, true], "aps.08.03": [58, true], "aps.08.04": [58, true], "aps.09.00": [53, true], "aps.09.01": [61, true], "aps.09.02": [53, true], "aps.09.03": [53, true], "aps.09.04": [49, true], "aps.09.05": [46, true], "aps.09.06": [46, true], "aps.10.00": [60, true], "aps.10.01": [65, true], "aps.10.02": [61, true], "aps.10.03": [61, true], "aps.10.04": [54, true], "aps.11.00": [57, true], "aps.11.01": [60, true], "aps.11.02": [60, true], "aps.11.03": [59, true], "aps.12.00": [61, true], "aps.12.01": [59, true], "aps.12.02": [60, true], "aps.12.03": [63, true], "aps.12.04": [61, true], "aps.12.05": [62, true], "aps.12.06": [63, true], "aps.12.07": [66, true], "aps.12.08": [63, true], "aps.12.09": [65, true], "aps.12.10": [62, true], "aps.12.11": [64, true], "aps.12.12": [63, true], "aps.12.13": [67, true], "aps.12.14": [64, true], "aps.12.15": [66, true], "aps.12.16": [65, true], "aps.12.17": [63, true], "aps.12.18": [64, true], "aps.13.00": [11, false], "aps.14.00": [70, true], "aps.14.01": [70, true], "aps.14.02": [70, true], "aps.14.03": [70, true], "aps.14.04": [70, true], "aps.14.05": [70, true], "aps.14.06": [70, true], "aps.14.07": [70, true], "aps.14.08": [70, true], "aps.14.09": [70, true], "aps.14.10": [70, true], "aps.14.11": [70, true], "aps.14.12": [70, true], "aps.14.13": [70, true], "aps.14.14": [70, true], "aps.14.15": [70, true], "aps.14.16": [70, true], "aps.14.17": [70, true], "aps.14.18": [70, true], "aps.14.19": [70, true], "aps.14.20": [70, true], "aps.14.21": [70, true], "aps.14.22": [70, true], "aps.14.23": [70, true], "aps.14.24": [70, true], "aps.14.25": [70, true], "aps.14.26": [70, true], "aps.14.27": [70, true], "aps.14.28": [70, true], "aps.14.29": [70, true], "aps.14.30": [70, true], "aps.14.31": [70, true], "aps.14.32": [70, true], "aps.14.33": [70, true], "aps.14.34": [70, true], "aps.14.35": [70, true], "aps.14.36": [70, true], "aps.14.37": [70, true], "aps.14.38": [70, true], "aps.14.39": [70, true], "aps.15.00": [65, true], "aps.15.01": [64, true], "aps.15.02": [61, true], "aps.15.03": [64, true], "aps.15.04": [65, true], "aps.15.05": [63, true], "aps.15.06": [64, true], "aps.15.07": [64, true], "aps.15.08": [62, true], "aps.15.09": [61, true], "aps.15.10": [60, true], "aps.15.11": [61, true], "aps.15.12": [65, true], "aps.15.13": [62, true], "aps.15.14": [63, true], "aps.15.15": [66, true], "aps.15.16": [63, true], "aps.15.17": [64, true], "aps.15.18": [66, true], "aps.15.19": [64, true], "aps.15.20": [67, true], "aps.15.21": [64, true], "aps.15.22": [60, true], "aps.15.23": [57, true], "aps.15.24": [58, true], "aps.15.25": [61, true], "aps.15.26": [60, true], "aps.15.27": [61, true], "aps.15.28": [63, true], "aps.15.29": [57, true], "aps.15.30": [62, true]}}, "CHA": {"total": 3956, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [61, true], "fun1.3": [64, true], "fun1.4": [77, true], "fun1.5": [105, true], "fun2.1": [51, true], "fun2.2": [74, true], "fun2.3": [78, true], "fun2.4": [90, true], "fun2.5": [99, true], "fun3.1": [71, true], "fun3.2": [76, true], "fun3.3": [82, true], "fun3.4": [104, true], "fun3.5": [123, true], "fun4.1": [72, true], "fun4.2": [74, true], "fun4.3": [92, true], "fun4.4": [109, true], "fun4.5": [131, true], "fun5.1": [80, true], "fun5.2": [78, true], "fun5.3": [80, true], "fun5.4": [86, true], "fun5.5": [88, true], "fun6.1": [41, true], "fun6.2": [57, true], "fun6.3": [50, true], "fun6.4": [48, true], "fun6.5": [50, true], "fun7.1": [11, false], "fun7.2": [10, false], "fun7.3": [5, false], "fun7.4": [13, false], "fun7.5": [17, false], "fun8.1": [57, true], "fun8.2": [56, true], "fun8.3": [64, true], "fun8.4": [64, true], "fun8.5": [67, true], "fun9.1": [59, true], "fun9.2": [55, true], "fun9.3": [63, true], "fun9.4": [64, true], "fun9.5": [58, true]}}}, {"label": "pure.exp_sq.derived.none", "spec": ["pure", "exp_sq", "derived", "none"], "APS": {"total": 30800, "solved": 0, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.exp_sq.derived3.step", "spec": ["pure", "exp_sq", "derived3", "step"], "APS": {"total": 18006, "solved": 153, "n": 154, "over": 126, "per": {"aps.01.00": [119, true], "aps.02.00": [116, true], "aps.02.01": [119, true], "aps.02.02": [111, true], "aps.02.03": [121, true], "aps.02.04": [117, true], "aps.02.05": [120, true], "aps.02.06": [121, true], "aps.02.07": [121, true], "aps.02.08": [122, true], "aps.02.09": [122, true], "aps.03.00": [126, true], "aps.03.01": [125, true], "aps.03.02": [124, true], "aps.04.00": [120, true], "aps.04.01": [119, true], "aps.04.02": [122, true], "aps.04.03": [123, true], "aps.04.04": [122, true], "aps.04.05": [121, true], "aps.04.06": [121, true], "aps.04.07": [121, true], "aps.04.08": [116, true], "aps.04.09": [116, true], "aps.04.10": [115, true], "aps.04.11": [115, true], "aps.04.12": [115, true], "aps.04.13": [117, true], "aps.05.00": [120, true], "aps.06.00": [119, true], "aps.06.01": [118, true], "aps.06.02": [107, true], "aps.06.03": [111, true], "aps.06.04": [116, true], "aps.06.05": [107, true], "aps.06.06": [107, true], "aps.06.07": [108, true], "aps.06.08": [107, true], "aps.06.09": [107, true], "aps.07.00": [110, true], "aps.07.01": [108, true], "aps.07.02": [103, true], "aps.08.00": [121, true], "aps.08.01": [119, true], "aps.08.02": [112, true], "aps.08.03": [112, true], "aps.08.04": [110, true], "aps.09.00": [117, true], "aps.09.01": [116, true], "aps.09.02": [108, true], "aps.09.03": [102, true], "aps.09.04": [97, true], "aps.09.05": [90, true], "aps.09.06": [85, true], "aps.10.00": [118, true], "aps.10.01": [106, true], "aps.10.02": [116, true], "aps.10.03": [108, true], "aps.10.04": [114, true], "aps.11.00": [108, true], "aps.11.01": [116, true], "aps.11.02": [112, true], "aps.11.03": [113, true], "aps.12.00": [122, true], "aps.12.01": [127, true], "aps.12.02": [126, true], "aps.12.03": [123, true], "aps.12.04": [130, true], "aps.12.05": [131, true], "aps.12.06": [132, true], "aps.12.07": [132, true], "aps.12.08": [132, true], "aps.12.09": [134, true], "aps.12.10": [132, true], "aps.12.11": [134, true], "aps.12.12": [133, true], "aps.12.13": [119, true], "aps.12.14": [133, true], "aps.12.15": [132, true], "aps.12.16": [133, true], "aps.12.17": [128, true], "aps.12.18": [128, true], "aps.13.00": [11, false], "aps.14.00": [128, true], "aps.14.01": [128, true], "aps.14.02": [128, true], "aps.14.03": [128, true], "aps.14.04": [128, true], "aps.14.05": [128, true], "aps.14.06": [128, true], "aps.14.07": [128, true], "aps.14.08": [128, true], "aps.14.09": [128, true], "aps.14.10": [128, true], "aps.14.11": [128, true], "aps.14.12": [128, true], "aps.14.13": [128, true], "aps.14.14": [128, true], "aps.14.15": [128, true], "aps.14.16": [128, true], "aps.14.17": [128, true], "aps.14.18": [128, true], "aps.14.19": [128, true], "aps.14.20": [128, true], "aps.14.21": [128, true], "aps.14.22": [128, true], "aps.14.23": [128, true], "aps.14.24": [128, true], "aps.14.25": [128, true], "aps.14.26": [128, true], "aps.14.27": [128, true], "aps.14.28": [128, true], "aps.14.29": [128, true], "aps.14.30": [128, true], "aps.14.31": [128, true], "aps.14.32": [128, true], "aps.14.33": [128, true], "aps.14.34": [128, true], "aps.14.35": [128, true], "aps.14.36": [128, true], "aps.14.37": [128, true], "aps.14.38": [128, true], "aps.14.39": [128, true], "aps.15.00": [105, true], "aps.15.01": [103, true], "aps.15.02": [104, true], "aps.15.03": [102, true], "aps.15.04": [99, true], "aps.15.05": [93, true], "aps.15.06": [99, true], "aps.15.07": [101, true], "aps.15.08": [104, true], "aps.15.09": [104, true], "aps.15.10": [105, true], "aps.15.11": [105, true], "aps.15.12": [105, true], "aps.15.13": [104, true], "aps.15.14": [90, true], "aps.15.15": [95, true], "aps.15.16": [99, true], "aps.15.17": [102, true], "aps.15.18": [100, true], "aps.15.19": [100, true], "aps.15.20": [99, true], "aps.15.21": [94, true], "aps.15.22": [90, true], "aps.15.23": [93, true], "aps.15.24": [92, true], "aps.15.25": [91, true], "aps.15.26": [92, true], "aps.15.27": [93, true], "aps.15.28": [85, true], "aps.15.29": [91, true], "aps.15.30": [91, true]}}, "CHA": {"total": 5567, "solved": 40, "n": 45, "over": 33, "per": {"fun1.1": [118, true], "fun1.2": [119, true], "fun1.3": [133, true], "fun1.4": [150, true], "fun1.5": [194, true], "fun2.1": [108, true], "fun2.2": [133, true], "fun2.3": [131, true], "fun2.4": [147, true], "fun2.5": [157, true], "fun3.1": [92, true], "fun3.2": [97, true], "fun3.3": [119, true], "fun3.4": [133, true], "fun3.5": [166, true], "fun4.1": [92, true], "fun4.2": [95, true], "fun4.3": [129, true], "fun4.4": [138, true], "fun4.5": [168, true], "fun5.1": [96, true], "fun5.2": [103, true], "fun5.3": [102, true], "fun5.4": [107, true], "fun5.5": [110, true], "fun6.1": [39, true], "fun6.2": [39, true], "fun6.3": [40, true], "fun6.4": [49, true], "fun6.5": [44, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [14, false], "fun7.5": [25, false], "fun8.1": [112, true], "fun8.2": [120, true], "fun8.3": [124, true], "fun8.4": [123, true], "fun8.5": [125, true], "fun9.1": [119, true], "fun9.2": [121, true], "fun9.3": [128, true], "fun9.4": [119, true], "fun9.5": [128, true]}}}, {"label": "pure.exp_sq.derived3.safe", "spec": ["pure", "exp_sq", "derived3", "safe"], "APS": {"total": 14553, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [91, true], "aps.02.04": [90, true], "aps.02.05": [90, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [89, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [89, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [89, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [83, true], "aps.06.02": [82, true], "aps.06.03": [83, true], "aps.06.04": [82, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [82, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [82, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [83, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [83, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [96, true], "aps.12.03": [96, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [96, true], "aps.12.11": [96, true], "aps.12.12": [97, true], "aps.12.13": [96, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [97, true], "aps.12.18": [97, true], "aps.13.00": [11, false], "aps.14.00": [103, true], "aps.14.01": [103, true], "aps.14.02": [103, true], "aps.14.03": [103, true], "aps.14.04": [103, true], "aps.14.05": [103, true], "aps.14.06": [103, true], "aps.14.07": [103, true], "aps.14.08": [103, true], "aps.14.09": [103, true], "aps.14.10": [103, true], "aps.14.11": [103, true], "aps.14.12": [103, true], "aps.14.13": [103, true], "aps.14.14": [103, true], "aps.14.15": [103, true], "aps.14.16": [103, true], "aps.14.17": [103, true], "aps.14.18": [103, true], "aps.14.19": [103, true], "aps.14.20": [103, true], "aps.14.21": [103, true], "aps.14.22": [103, true], "aps.14.23": [103, true], "aps.14.24": [103, true], "aps.14.25": [103, true], "aps.14.26": [103, true], "aps.14.27": [103, true], "aps.14.28": [103, true], "aps.14.29": [103, true], "aps.14.30": [103, true], "aps.14.31": [103, true], "aps.14.32": [103, true], "aps.14.33": [103, true], "aps.14.34": [103, true], "aps.14.35": [103, true], "aps.14.36": [103, true], "aps.14.37": [103, true], "aps.14.38": [103, true], "aps.14.39": [103, true], "aps.15.00": [102, true], "aps.15.01": [102, true], "aps.15.02": [102, true], "aps.15.03": [102, true], "aps.15.04": [99, true], "aps.15.05": [93, true], "aps.15.06": [99, true], "aps.15.07": [101, true], "aps.15.08": [102, true], "aps.15.09": [102, true], "aps.15.10": [102, true], "aps.15.11": [102, true], "aps.15.12": [103, true], "aps.15.13": [102, true], "aps.15.14": [90, true], "aps.15.15": [95, true], "aps.15.16": [99, true], "aps.15.17": [102, true], "aps.15.18": [100, true], "aps.15.19": [100, true], "aps.15.20": [99, true], "aps.15.21": [94, true], "aps.15.22": [90, true], "aps.15.23": [93, true], "aps.15.24": [92, true], "aps.15.25": [91, true], "aps.15.26": [92, true], "aps.15.27": [93, true], "aps.15.28": [85, true], "aps.15.29": [91, true], "aps.15.30": [91, true]}}, "CHA": {"total": 4857, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [112, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [147, true], "fun2.5": [157, true], "fun3.1": [88, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [39, true], "fun6.2": [39, true], "fun6.3": [40, true], "fun6.4": [49, true], "fun6.5": [44, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [14, false], "fun7.5": [25, false], "fun8.1": [85, true], "fun8.2": [86, true], "fun8.3": [91, true], "fun8.4": [93, true], "fun8.5": [96, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.exp_sq.derived3.project", "spec": ["pure", "exp_sq", "derived3", "project"], "APS": {"total": 14669, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [91, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [93, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [89, true], "aps.04.05": [88, true], "aps.04.06": [89, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [89, true], "aps.04.13": [78, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [82, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [83, true], "aps.06.07": [82, true], "aps.06.08": [82, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [82, true], "aps.07.02": [82, true], "aps.08.00": [83, true], "aps.08.01": [82, true], "aps.08.02": [82, true], "aps.08.03": [82, true], "aps.08.04": [82, true], "aps.09.00": [83, true], "aps.09.01": [82, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [83, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [82, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [96, true], "aps.12.02": [96, true], "aps.12.03": [97, true], "aps.12.04": [96, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [97, true], "aps.12.12": [96, true], "aps.12.13": [96, true], "aps.12.14": [96, true], "aps.12.15": [97, true], "aps.12.16": [95, true], "aps.12.17": [96, true], "aps.12.18": [96, true], "aps.13.00": [51, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [103, true], "aps.15.01": [103, true], "aps.15.02": [102, true], "aps.15.03": [103, true], "aps.15.04": [102, true], "aps.15.05": [102, true], "aps.15.06": [102, true], "aps.15.07": [103, true], "aps.15.08": [102, true], "aps.15.09": [103, true], "aps.15.10": [102, true], "aps.15.11": [102, true], "aps.15.12": [103, true], "aps.15.13": [103, true], "aps.15.14": [103, true], "aps.15.15": [103, true], "aps.15.16": [102, true], "aps.15.17": [103, true], "aps.15.18": [102, true], "aps.15.19": [103, true], "aps.15.20": [102, true], "aps.15.21": [102, true], "aps.15.22": [103, true], "aps.15.23": [103, true], "aps.15.24": [103, true], "aps.15.25": [102, true], "aps.15.26": [103, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 5117, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [83, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [150, true], "fun2.5": [163, true], "fun3.1": [88, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [124, true], "fun3.5": [153, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [52, false], "fun7.3": [52, false], "fun7.4": [57, false], "fun7.5": [60, false], "fun8.1": [85, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [93, true], "fun8.5": [97, true], "fun9.1": [83, true], "fun9.2": [87, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [97, true]}}}, {"label": "pure.exp_sq.derived3.credit", "spec": ["pure", "exp_sq", "derived3", "credit"], "APS": {"total": 7682, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [49, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [11, false], "fun7.4": [49, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.rat_sq.start.bracket", "spec": ["pure", "rat_sq", "start", "bracket"], "APS": {"total": 9962, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [59, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [74, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [59, true], "aps.04.01": [61, true], "aps.04.02": [63, true], "aps.04.03": [63, true], "aps.04.04": [63, true], "aps.04.05": [64, true], "aps.04.06": [60, true], "aps.04.07": [62, true], "aps.04.08": [61, true], "aps.04.09": [62, true], "aps.04.10": [63, true], "aps.04.11": [63, true], "aps.04.12": [61, true], "aps.04.13": [59, true], "aps.05.00": [60, true], "aps.06.00": [59, true], "aps.06.01": [60, true], "aps.06.02": [60, true], "aps.06.03": [60, true], "aps.06.04": [59, true], "aps.06.05": [58, true], "aps.06.06": [58, true], "aps.06.07": [60, true], "aps.06.08": [58, true], "aps.06.09": [60, true], "aps.07.00": [59, true], "aps.07.01": [62, true], "aps.07.02": [65, true], "aps.08.00": [3, true], "aps.08.01": [59, true], "aps.08.02": [59, true], "aps.08.03": [59, true], "aps.08.04": [59, true], "aps.09.00": [60, true], "aps.09.01": [60, true], "aps.09.02": [62, true], "aps.09.03": [64, true], "aps.09.04": [66, true], "aps.09.05": [71, true], "aps.09.06": [74, true], "aps.10.00": [60, true], "aps.10.01": [58, true], "aps.10.02": [56, true], "aps.10.03": [54, true], "aps.10.04": [51, true], "aps.11.00": [57, true], "aps.11.01": [61, true], "aps.11.02": [60, true], "aps.11.03": [58, true], "aps.12.00": [65, true], "aps.12.01": [64, true], "aps.12.02": [63, true], "aps.12.03": [64, true], "aps.12.04": [65, true], "aps.12.05": [65, true], "aps.12.06": [66, true], "aps.12.07": [66, true], "aps.12.08": [66, true], "aps.12.09": [66, true], "aps.12.10": [65, true], "aps.12.11": [66, true], "aps.12.12": [62, true], "aps.12.13": [66, true], "aps.12.14": [65, true], "aps.12.15": [67, true], "aps.12.16": [67, true], "aps.12.17": [66, true], "aps.12.18": [65, true], "aps.13.00": [9, false], "aps.14.00": [70, true], "aps.14.01": [70, true], "aps.14.02": [70, true], "aps.14.03": [70, true], "aps.14.04": [70, true], "aps.14.05": [70, true], "aps.14.06": [70, true], "aps.14.07": [70, true], "aps.14.08": [70, true], "aps.14.09": [70, true], "aps.14.10": [70, true], "aps.14.11": [70, true], "aps.14.12": [70, true], "aps.14.13": [70, true], "aps.14.14": [70, true], "aps.14.15": [70, true], "aps.14.16": [70, true], "aps.14.17": [70, true], "aps.14.18": [70, true], "aps.14.19": [70, true], "aps.14.20": [70, true], "aps.14.21": [70, true], "aps.14.22": [70, true], "aps.14.23": [70, true], "aps.14.24": [70, true], "aps.14.25": [70, true], "aps.14.26": [70, true], "aps.14.27": [70, true], "aps.14.28": [70, true], "aps.14.29": [70, true], "aps.14.30": [70, true], "aps.14.31": [70, true], "aps.14.32": [70, true], "aps.14.33": [70, true], "aps.14.34": [70, true], "aps.14.35": [70, true], "aps.14.36": [70, true], "aps.14.37": [70, true], "aps.14.38": [70, true], "aps.14.39": [70, true], "aps.15.00": [69, true], "aps.15.01": [69, true], "aps.15.02": [69, true], "aps.15.03": [69, true], "aps.15.04": [69, true], "aps.15.05": [70, true], "aps.15.06": [68, true], "aps.15.07": [68, true], "aps.15.08": [69, true], "aps.15.09": [69, true], "aps.15.10": [68, true], "aps.15.11": [69, true], "aps.15.12": [69, true], "aps.15.13": [70, true], "aps.15.14": [70, true], "aps.15.15": [68, true], "aps.15.16": [68, true], "aps.15.17": [68, true], "aps.15.18": [68, true], "aps.15.19": [67, true], "aps.15.20": [67, true], "aps.15.21": [67, true], "aps.15.22": [69, true], "aps.15.23": [69, true], "aps.15.24": [69, true], "aps.15.25": [66, true], "aps.15.26": [68, true], "aps.15.27": [69, true], "aps.15.28": [68, true], "aps.15.29": [68, true], "aps.15.30": [69, true]}}, "CHA": {"total": 3501, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [64, true], "fun1.3": [70, true], "fun1.4": [65, true], "fun1.5": [85, true], "fun2.1": [57, true], "fun2.2": [72, true], "fun2.3": [79, true], "fun2.4": [92, true], "fun2.5": [98, true], "fun3.1": [52, true], "fun3.2": [54, true], "fun3.3": [65, true], "fun3.4": [71, true], "fun3.5": [85, true], "fun4.1": [49, true], "fun4.2": [51, true], "fun4.3": [62, true], "fun4.4": [68, true], "fun4.5": [82, true], "fun5.1": [48, true], "fun5.2": [47, true], "fun5.3": [51, true], "fun5.4": [53, true], "fun5.5": [54, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [16, false], "fun8.1": [60, true], "fun8.2": [59, true], "fun8.3": [61, true], "fun8.4": [63, true], "fun8.5": [65, true], "fun9.1": [60, true], "fun9.2": [62, true], "fun9.3": [64, true], "fun9.4": [68, true], "fun9.5": [69, true]}}}, {"label": "pure.rat_sq.start.step", "spec": ["pure", "rat_sq", "start", "step"], "APS": {"total": 11304, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [68, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [75, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [79, true], "aps.04.01": [72, true], "aps.04.02": [75, true], "aps.04.03": [71, true], "aps.04.04": [71, true], "aps.04.05": [71, true], "aps.04.06": [74, true], "aps.04.07": [75, true], "aps.04.08": [72, true], "aps.04.09": [67, true], "aps.04.10": [76, true], "aps.04.11": [75, true], "aps.04.12": [67, true], "aps.04.13": [66, true], "aps.05.00": [69, true], "aps.06.00": [72, true], "aps.06.01": [71, true], "aps.06.02": [67, true], "aps.06.03": [69, true], "aps.06.04": [67, true], "aps.06.05": [69, true], "aps.06.06": [69, true], "aps.06.07": [67, true], "aps.06.08": [69, true], "aps.06.09": [73, true], "aps.07.00": [72, true], "aps.07.01": [72, true], "aps.07.02": [79, true], "aps.08.00": [3, true], "aps.08.01": [68, true], "aps.08.02": [68, true], "aps.08.03": [67, true], "aps.08.04": [65, true], "aps.09.00": [69, true], "aps.09.01": [69, true], "aps.09.02": [68, true], "aps.09.03": [70, true], "aps.09.04": [79, true], "aps.09.05": [82, true], "aps.09.06": [78, true], "aps.10.00": [71, true], "aps.10.01": [68, true], "aps.10.02": [64, true], "aps.10.03": [58, true], "aps.10.04": [55, true], "aps.11.00": [67, true], "aps.11.01": [70, true], "aps.11.02": [72, true], "aps.11.03": [70, true], "aps.12.00": [73, true], "aps.12.01": [63, true], "aps.12.02": [73, true], "aps.12.03": [73, true], "aps.12.04": [73, true], "aps.12.05": [76, true], "aps.12.06": [79, true], "aps.12.07": [74, true], "aps.12.08": [79, true], "aps.12.09": [81, true], "aps.12.10": [77, true], "aps.12.11": [78, true], "aps.12.12": [76, true], "aps.12.13": [77, true], "aps.12.14": [75, true], "aps.12.15": [75, true], "aps.12.16": [75, true], "aps.12.17": [77, true], "aps.12.18": [78, true], "aps.13.00": [14, false], "aps.14.00": [78, true], "aps.14.01": [78, true], "aps.14.02": [78, true], "aps.14.03": [78, true], "aps.14.04": [78, true], "aps.14.05": [78, true], "aps.14.06": [78, true], "aps.14.07": [78, true], "aps.14.08": [78, true], "aps.14.09": [78, true], "aps.14.10": [78, true], "aps.14.11": [78, true], "aps.14.12": [78, true], "aps.14.13": [78, true], "aps.14.14": [78, true], "aps.14.15": [78, true], "aps.14.16": [78, true], "aps.14.17": [78, true], "aps.14.18": [78, true], "aps.14.19": [78, true], "aps.14.20": [78, true], "aps.14.21": [78, true], "aps.14.22": [78, true], "aps.14.23": [78, true], "aps.14.24": [78, true], "aps.14.25": [78, true], "aps.14.26": [78, true], "aps.14.27": [78, true], "aps.14.28": [78, true], "aps.14.29": [78, true], "aps.14.30": [78, true], "aps.14.31": [78, true], "aps.14.32": [78, true], "aps.14.33": [78, true], "aps.14.34": [78, true], "aps.14.35": [78, true], "aps.14.36": [78, true], "aps.14.37": [78, true], "aps.14.38": [78, true], "aps.14.39": [78, true], "aps.15.00": [81, true], "aps.15.01": [79, true], "aps.15.02": [81, true], "aps.15.03": [83, true], "aps.15.04": [81, true], "aps.15.05": [81, true], "aps.15.06": [79, true], "aps.15.07": [78, true], "aps.15.08": [80, true], "aps.15.09": [79, true], "aps.15.10": [81, true], "aps.15.11": [81, true], "aps.15.12": [80, true], "aps.15.13": [83, true], "aps.15.14": [80, true], "aps.15.15": [82, true], "aps.15.16": [79, true], "aps.15.17": [80, true], "aps.15.18": [79, true], "aps.15.19": [76, true], "aps.15.20": [75, true], "aps.15.21": [84, true], "aps.15.22": [77, true], "aps.15.23": [81, true], "aps.15.24": [79, true], "aps.15.25": [76, true], "aps.15.26": [78, true], "aps.15.27": [78, true], "aps.15.28": [82, true], "aps.15.29": [82, true], "aps.15.30": [83, true]}}, "CHA": {"total": 3798, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [71, true], "fun1.2": [74, true], "fun1.3": [78, true], "fun1.4": [72, true], "fun1.5": [92, true], "fun2.1": [72, true], "fun2.2": [86, true], "fun2.3": [95, true], "fun2.4": [110, true], "fun2.5": [115, true], "fun3.1": [53, true], "fun3.2": [61, true], "fun3.3": [72, true], "fun3.4": [78, true], "fun3.5": [92, true], "fun4.1": [49, true], "fun4.2": [51, true], "fun4.3": [66, true], "fun4.4": [72, true], "fun4.5": [86, true], "fun5.1": [48, true], "fun5.2": [49, true], "fun5.3": [53, true], "fun5.4": [55, true], "fun5.5": [56, true], "fun6.1": [46, true], "fun6.2": [47, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [14, false], "fun7.2": [11, false], "fun7.3": [16, false], "fun7.4": [15, false], "fun7.5": [18, false], "fun8.1": [72, true], "fun8.2": [74, true], "fun8.3": [74, true], "fun8.4": [77, true], "fun8.5": [80, true], "fun9.1": [71, true], "fun9.2": [73, true], "fun9.3": [76, true], "fun9.4": [76, true], "fun9.5": [80, true]}}}, {"label": "pure.exp_sq.derived3.none", "spec": ["pure", "exp_sq", "derived3", "none"], "APS": {"total": 30800, "solved": 0, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.rat_sq.start.none", "spec": ["pure", "rat_sq", "start", "none"], "APS": {"total": 28757, "solved": 13, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [200, false], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [3, true], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 8392, "solved": 4, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [46, true], "fun6.2": [200, false], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.rat_sq.start.both", "spec": ["pure", "rat_sq", "start", "both"], "APS": {"total": 9370, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [56, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [74, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [58, true], "aps.04.01": [55, true], "aps.04.02": [58, true], "aps.04.03": [60, true], "aps.04.04": [58, true], "aps.04.05": [57, true], "aps.04.06": [56, true], "aps.04.07": [58, true], "aps.04.08": [57, true], "aps.04.09": [58, true], "aps.04.10": [58, true], "aps.04.11": [59, true], "aps.04.12": [57, true], "aps.04.13": [55, true], "aps.05.00": [57, true], "aps.06.00": [55, true], "aps.06.01": [53, true], "aps.06.02": [53, true], "aps.06.03": [54, true], "aps.06.04": [55, true], "aps.06.05": [56, true], "aps.06.06": [55, true], "aps.06.07": [55, true], "aps.06.08": [55, true], "aps.06.09": [52, true], "aps.07.00": [55, true], "aps.07.01": [58, true], "aps.07.02": [61, true], "aps.08.00": [3, true], "aps.08.01": [53, true], "aps.08.02": [55, true], "aps.08.03": [57, true], "aps.08.04": [51, true], "aps.09.00": [56, true], "aps.09.01": [56, true], "aps.09.02": [59, true], "aps.09.03": [57, true], "aps.09.04": [59, true], "aps.09.05": [64, true], "aps.09.06": [67, true], "aps.10.00": [57, true], "aps.10.01": [54, true], "aps.10.02": [53, true], "aps.10.03": [50, true], "aps.10.04": [47, true], "aps.11.00": [53, true], "aps.11.01": [55, true], "aps.11.02": [54, true], "aps.11.03": [54, true], "aps.12.00": [60, true], "aps.12.01": [60, true], "aps.12.02": [60, true], "aps.12.03": [59, true], "aps.12.04": [59, true], "aps.12.05": [61, true], "aps.12.06": [63, true], "aps.12.07": [64, true], "aps.12.08": [62, true], "aps.12.09": [61, true], "aps.12.10": [60, true], "aps.12.11": [62, true], "aps.12.12": [60, true], "aps.12.13": [61, true], "aps.12.14": [61, true], "aps.12.15": [64, true], "aps.12.16": [59, true], "aps.12.17": [61, true], "aps.12.18": [62, true], "aps.13.00": [9, false], "aps.14.00": [66, true], "aps.14.01": [66, true], "aps.14.02": [66, true], "aps.14.03": [66, true], "aps.14.04": [66, true], "aps.14.05": [66, true], "aps.14.06": [66, true], "aps.14.07": [66, true], "aps.14.08": [66, true], "aps.14.09": [66, true], "aps.14.10": [66, true], "aps.14.11": [66, true], "aps.14.12": [66, true], "aps.14.13": [66, true], "aps.14.14": [66, true], "aps.14.15": [66, true], "aps.14.16": [66, true], "aps.14.17": [66, true], "aps.14.18": [66, true], "aps.14.19": [66, true], "aps.14.20": [66, true], "aps.14.21": [66, true], "aps.14.22": [66, true], "aps.14.23": [66, true], "aps.14.24": [66, true], "aps.14.25": [66, true], "aps.14.26": [66, true], "aps.14.27": [66, true], "aps.14.28": [66, true], "aps.14.29": [66, true], "aps.14.30": [66, true], "aps.14.31": [66, true], "aps.14.32": [66, true], "aps.14.33": [66, true], "aps.14.34": [66, true], "aps.14.35": [66, true], "aps.14.36": [66, true], "aps.14.37": [66, true], "aps.14.38": [66, true], "aps.14.39": [66, true], "aps.15.00": [64, true], "aps.15.01": [65, true], "aps.15.02": [64, true], "aps.15.03": [65, true], "aps.15.04": [64, true], "aps.15.05": [65, true], "aps.15.06": [68, true], "aps.15.07": [65, true], "aps.15.08": [65, true], "aps.15.09": [65, true], "aps.15.10": [64, true], "aps.15.11": [64, true], "aps.15.12": [64, true], "aps.15.13": [66, true], "aps.15.14": [64, true], "aps.15.15": [65, true], "aps.15.16": [67, true], "aps.15.17": [65, true], "aps.15.18": [65, true], "aps.15.19": [63, true], "aps.15.20": [60, true], "aps.15.21": [64, true], "aps.15.22": [66, true], "aps.15.23": [60, true], "aps.15.24": [67, true], "aps.15.25": [63, true], "aps.15.26": [65, true], "aps.15.27": [63, true], "aps.15.28": [63, true], "aps.15.29": [63, true], "aps.15.30": [64, true]}}, "CHA": {"total": 3423, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [55, true], "fun1.2": [61, true], "fun1.3": [65, true], "fun1.4": [65, true], "fun1.5": [85, true], "fun2.1": [54, true], "fun2.2": [68, true], "fun2.3": [75, true], "fun2.4": [86, true], "fun2.5": [95, true], "fun3.1": [49, true], "fun3.2": [52, true], "fun3.3": [65, true], "fun3.4": [71, true], "fun3.5": [85, true], "fun4.1": [47, true], "fun4.2": [49, true], "fun4.3": [62, true], "fun4.4": [68, true], "fun4.5": [82, true], "fun5.1": [47, true], "fun5.2": [47, true], "fun5.3": [51, true], "fun5.4": [53, true], "fun5.5": [54, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [16, false], "fun8.1": [56, true], "fun8.2": [58, true], "fun8.3": [59, true], "fun8.4": [60, true], "fun8.5": [62, true], "fun9.1": [55, true], "fun9.2": [56, true], "fun9.3": [61, true], "fun9.4": [63, true], "fun9.5": [64, true]}}}, {"label": "pure.rat_sq.start.project", "spec": ["pure", "rat_sq", "start", "project"], "APS": {"total": 14061, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [94, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [89, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [89, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [82, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [82, true], "aps.06.09": [82, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [3, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [83, true], "aps.09.01": [83, true], "aps.09.02": [82, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [83, true], "aps.10.02": [83, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [83, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [96, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [93, true], "aps.12.10": [96, true], "aps.12.11": [97, true], "aps.12.12": [96, true], "aps.12.13": [96, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [94, true], "aps.12.17": [96, true], "aps.12.18": [97, true], "aps.13.00": [52, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [103, true], "aps.15.01": [102, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [102, true], "aps.15.05": [102, true], "aps.15.06": [103, true], "aps.15.07": [102, true], "aps.15.08": [103, true], "aps.15.09": [103, true], "aps.15.10": [102, true], "aps.15.11": [103, true], "aps.15.12": [102, true], "aps.15.13": [102, true], "aps.15.14": [103, true], "aps.15.15": [103, true], "aps.15.16": [102, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [102, true], "aps.15.21": [102, true], "aps.15.22": [103, true], "aps.15.23": [102, true], "aps.15.24": [102, true], "aps.15.25": [102, true], "aps.15.26": [102, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 4930, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [90, true], "fun1.3": [96, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [111, true], "fun2.3": [122, true], "fun2.4": [150, true], "fun2.5": [163, true], "fun3.1": [89, true], "fun3.2": [80, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [46, true], "fun6.2": [89, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [52, false], "fun7.2": [52, false], "fun7.3": [54, false], "fun7.4": [57, false], "fun7.5": [60, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [91, true], "fun8.4": [93, true], "fun8.5": [97, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [91, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.rat_sq.bracket.bracket", "spec": ["pure", "rat_sq", "bracket", "bracket"], "APS": {"total": 8952, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [52, true], "aps.02.00": [56, true], "aps.02.01": [54, true], "aps.02.02": [55, true], "aps.02.03": [57, true], "aps.02.04": [56, true], "aps.02.05": [56, true], "aps.02.06": [55, true], "aps.02.07": [56, true], "aps.02.08": [57, true], "aps.02.09": [56, true], "aps.03.00": [59, true], "aps.03.01": [57, true], "aps.03.02": [58, true], "aps.04.00": [50, true], "aps.04.01": [56, true], "aps.04.02": [54, true], "aps.04.03": [56, true], "aps.04.04": [55, true], "aps.04.05": [55, true], "aps.04.06": [54, true], "aps.04.07": [57, true], "aps.04.08": [55, true], "aps.04.09": [56, true], "aps.04.10": [54, true], "aps.04.11": [56, true], "aps.04.12": [52, true], "aps.04.13": [56, true], "aps.05.00": [50, true], "aps.06.00": [52, true], "aps.06.01": [50, true], "aps.06.02": [50, true], "aps.06.03": [53, true], "aps.06.04": [52, true], "aps.06.05": [51, true], "aps.06.06": [51, true], "aps.06.07": [50, true], "aps.06.08": [51, true], "aps.06.09": [48, true], "aps.07.00": [52, true], "aps.07.01": [49, true], "aps.07.02": [50, true], "aps.08.00": [3, true], "aps.08.01": [51, true], "aps.08.02": [51, true], "aps.08.03": [51, true], "aps.08.04": [53, true], "aps.09.00": [51, true], "aps.09.01": [50, true], "aps.09.02": [51, true], "aps.09.03": [51, true], "aps.09.04": [46, true], "aps.09.05": [47, true], "aps.09.06": [46, true], "aps.10.00": [51, true], "aps.10.01": [49, true], "aps.10.02": [53, true], "aps.10.03": [51, true], "aps.10.04": [49, true], "aps.11.00": [50, true], "aps.11.01": [54, true], "aps.11.02": [53, true], "aps.11.03": [54, true], "aps.12.00": [61, true], "aps.12.01": [60, true], "aps.12.02": [57, true], "aps.12.03": [55, true], "aps.12.04": [57, true], "aps.12.05": [59, true], "aps.12.06": [61, true], "aps.12.07": [61, true], "aps.12.08": [60, true], "aps.12.09": [62, true], "aps.12.10": [62, true], "aps.12.11": [61, true], "aps.12.12": [64, true], "aps.12.13": [61, true], "aps.12.14": [60, true], "aps.12.15": [63, true], "aps.12.16": [59, true], "aps.12.17": [59, true], "aps.12.18": [61, true], "aps.13.00": [8, false], "aps.14.00": [64, true], "aps.14.01": [64, true], "aps.14.02": [64, true], "aps.14.03": [64, true], "aps.14.04": [64, true], "aps.14.05": [64, true], "aps.14.06": [64, true], "aps.14.07": [64, true], "aps.14.08": [64, true], "aps.14.09": [64, true], "aps.14.10": [64, true], "aps.14.11": [64, true], "aps.14.12": [64, true], "aps.14.13": [64, true], "aps.14.14": [64, true], "aps.14.15": [64, true], "aps.14.16": [64, true], "aps.14.17": [64, true], "aps.14.18": [64, true], "aps.14.19": [64, true], "aps.14.20": [64, true], "aps.14.21": [64, true], "aps.14.22": [64, true], "aps.14.23": [64, true], "aps.14.24": [64, true], "aps.14.25": [64, true], "aps.14.26": [64, true], "aps.14.27": [64, true], "aps.14.28": [64, true], "aps.14.29": [64, true], "aps.14.30": [64, true], "aps.14.31": [64, true], "aps.14.32": [64, true], "aps.14.33": [64, true], "aps.14.34": [64, true], "aps.14.35": [64, true], "aps.14.36": [64, true], "aps.14.37": [64, true], "aps.14.38": [64, true], "aps.14.39": [64, true], "aps.15.00": [59, true], "aps.15.01": [57, true], "aps.15.02": [57, true], "aps.15.03": [58, true], "aps.15.04": [59, true], "aps.15.05": [58, true], "aps.15.06": [60, true], "aps.15.07": [59, true], "aps.15.08": [59, true], "aps.15.09": [59, true], "aps.15.10": [58, true], "aps.15.11": [59, true], "aps.15.12": [58, true], "aps.15.13": [60, true], "aps.15.14": [60, true], "aps.15.15": [57, true], "aps.15.16": [59, true], "aps.15.17": [57, true], "aps.15.18": [56, true], "aps.15.19": [53, true], "aps.15.20": [56, true], "aps.15.21": [55, true], "aps.15.22": [56, true], "aps.15.23": [56, true], "aps.15.24": [58, true], "aps.15.25": [58, true], "aps.15.26": [53, true], "aps.15.27": [54, true], "aps.15.28": [55, true], "aps.15.29": [57, true], "aps.15.30": [55, true]}}, "CHA": {"total": 3672, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [53, true], "fun1.2": [55, true], "fun1.3": [60, true], "fun1.4": [64, true], "fun1.5": [84, true], "fun2.1": [54, true], "fun2.2": [63, true], "fun2.3": [70, true], "fun2.4": [83, true], "fun2.5": [88, true], "fun3.1": [82, true], "fun3.2": [86, true], "fun3.3": [93, true], "fun3.4": [94, true], "fun3.5": [89, true], "fun4.1": [60, true], "fun4.2": [68, true], "fun4.3": [76, true], "fun4.4": [83, true], "fun4.5": [89, true], "fun5.1": [65, true], "fun5.2": [64, true], "fun5.3": [64, true], "fun5.4": [61, true], "fun5.5": [63, true], "fun6.1": [49, true], "fun6.2": [58, true], "fun6.3": [57, true], "fun6.4": [62, true], "fun6.5": [63, true], "fun7.1": [8, false], "fun7.2": [10, false], "fun7.3": [13, false], "fun7.4": [14, false], "fun7.5": [56, false], "fun8.1": [53, true], "fun8.2": [55, true], "fun8.3": [57, true], "fun8.4": [61, true], "fun8.5": [66, true], "fun9.1": [52, true], "fun9.2": [56, true], "fun9.3": [57, true], "fun9.4": [58, true], "fun9.5": [57, true]}}}, {"label": "pure.rat_sq.start.credit", "spec": ["pure", "rat_sq", "start", "credit"], "APS": {"total": 7680, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [8, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [8, false], "fun7.2": [8, false], "fun7.3": [8, false], "fun7.4": [10, false], "fun7.5": [14, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.rat_sq.bracket.both", "spec": ["pure", "rat_sq", "bracket", "both"], "APS": {"total": 8940, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [52, true], "aps.02.00": [56, true], "aps.02.01": [54, true], "aps.02.02": [55, true], "aps.02.03": [56, true], "aps.02.04": [57, true], "aps.02.05": [54, true], "aps.02.06": [55, true], "aps.02.07": [56, true], "aps.02.08": [57, true], "aps.02.09": [56, true], "aps.03.00": [52, true], "aps.03.01": [60, true], "aps.03.02": [58, true], "aps.04.00": [50, true], "aps.04.01": [56, true], "aps.04.02": [54, true], "aps.04.03": [56, true], "aps.04.04": [55, true], "aps.04.05": [55, true], "aps.04.06": [54, true], "aps.04.07": [57, true], "aps.04.08": [55, true], "aps.04.09": [56, true], "aps.04.10": [54, true], "aps.04.11": [56, true], "aps.04.12": [52, true], "aps.04.13": [56, true], "aps.05.00": [50, true], "aps.06.00": [52, true], "aps.06.01": [51, true], "aps.06.02": [50, true], "aps.06.03": [53, true], "aps.06.04": [52, true], "aps.06.05": [51, true], "aps.06.06": [49, true], "aps.06.07": [50, true], "aps.06.08": [48, true], "aps.06.09": [48, true], "aps.07.00": [52, true], "aps.07.01": [49, true], "aps.07.02": [50, true], "aps.08.00": [3, true], "aps.08.01": [51, true], "aps.08.02": [51, true], "aps.08.03": [51, true], "aps.08.04": [53, true], "aps.09.00": [52, true], "aps.09.01": [52, true], "aps.09.02": [51, true], "aps.09.03": [51, true], "aps.09.04": [46, true], "aps.09.05": [47, true], "aps.09.06": [46, true], "aps.10.00": [51, true], "aps.10.01": [49, true], "aps.10.02": [53, true], "aps.10.03": [51, true], "aps.10.04": [49, true], "aps.11.00": [50, true], "aps.11.01": [54, true], "aps.11.02": [53, true], "aps.11.03": [54, true], "aps.12.00": [61, true], "aps.12.01": [60, true], "aps.12.02": [55, true], "aps.12.03": [55, true], "aps.12.04": [57, true], "aps.12.05": [59, true], "aps.12.06": [61, true], "aps.12.07": [60, true], "aps.12.08": [60, true], "aps.12.09": [62, true], "aps.12.10": [62, true], "aps.12.11": [61, true], "aps.12.12": [64, true], "aps.12.13": [60, true], "aps.12.14": [61, true], "aps.12.15": [59, true], "aps.12.16": [58, true], "aps.12.17": [62, true], "aps.12.18": [61, true], "aps.13.00": [8, false], "aps.14.00": [64, true], "aps.14.01": [64, true], "aps.14.02": [64, true], "aps.14.03": [64, true], "aps.14.04": [64, true], "aps.14.05": [64, true], "aps.14.06": [64, true], "aps.14.07": [64, true], "aps.14.08": [64, true], "aps.14.09": [64, true], "aps.14.10": [64, true], "aps.14.11": [64, true], "aps.14.12": [64, true], "aps.14.13": [64, true], "aps.14.14": [64, true], "aps.14.15": [64, true], "aps.14.16": [64, true], "aps.14.17": [64, true], "aps.14.18": [64, true], "aps.14.19": [64, true], "aps.14.20": [64, true], "aps.14.21": [64, true], "aps.14.22": [64, true], "aps.14.23": [64, true], "aps.14.24": [64, true], "aps.14.25": [64, true], "aps.14.26": [64, true], "aps.14.27": [64, true], "aps.14.28": [64, true], "aps.14.29": [64, true], "aps.14.30": [64, true], "aps.14.31": [64, true], "aps.14.32": [64, true], "aps.14.33": [64, true], "aps.14.34": [64, true], "aps.14.35": [64, true], "aps.14.36": [64, true], "aps.14.37": [64, true], "aps.14.38": [64, true], "aps.14.39": [64, true], "aps.15.00": [59, true], "aps.15.01": [57, true], "aps.15.02": [57, true], "aps.15.03": [58, true], "aps.15.04": [59, true], "aps.15.05": [58, true], "aps.15.06": [60, true], "aps.15.07": [59, true], "aps.15.08": [59, true], "aps.15.09": [59, true], "aps.15.10": [58, true], "aps.15.11": [59, true], "aps.15.12": [58, true], "aps.15.13": [60, true], "aps.15.14": [60, true], "aps.15.15": [57, true], "aps.15.16": [59, true], "aps.15.17": [57, true], "aps.15.18": [56, true], "aps.15.19": [53, true], "aps.15.20": [56, true], "aps.15.21": [55, true], "aps.15.22": [56, true], "aps.15.23": [56, true], "aps.15.24": [58, true], "aps.15.25": [58, true], "aps.15.26": [53, true], "aps.15.27": [54, true], "aps.15.28": [55, true], "aps.15.29": [57, true], "aps.15.30": [55, true]}}, "CHA": {"total": 3525, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [53, true], "fun1.2": [55, true], "fun1.3": [58, true], "fun1.4": [64, true], "fun1.5": [84, true], "fun2.1": [54, true], "fun2.2": [63, true], "fun2.3": [72, true], "fun2.4": [83, true], "fun2.5": [89, true], "fun3.1": [62, true], "fun3.2": [67, true], "fun3.3": [69, true], "fun3.4": [77, true], "fun3.5": [89, true], "fun4.1": [57, true], "fun4.2": [61, true], "fun4.3": [70, true], "fun4.4": [77, true], "fun4.5": [88, true], "fun5.1": [65, true], "fun5.2": [67, true], "fun5.3": [54, true], "fun5.4": [56, true], "fun5.5": [58, true], "fun6.1": [47, true], "fun6.2": [49, true], "fun6.3": [53, true], "fun6.4": [55, true], "fun6.5": [56, true], "fun7.1": [8, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [14, false], "fun7.5": [53, false], "fun8.1": [55, true], "fun8.2": [55, true], "fun8.3": [57, true], "fun8.4": [60, true], "fun8.5": [66, true], "fun9.1": [52, true], "fun9.2": [56, true], "fun9.3": [57, true], "fun9.4": [58, true], "fun9.5": [57, true]}}}, {"label": "pure.rat_sq.start.safe", "spec": ["pure", "rat_sq", "start", "safe"], "APS": {"total": 11306, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [68, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [75, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [79, true], "aps.04.01": [72, true], "aps.04.02": [75, true], "aps.04.03": [71, true], "aps.04.04": [71, true], "aps.04.05": [71, true], "aps.04.06": [74, true], "aps.04.07": [75, true], "aps.04.08": [72, true], "aps.04.09": [67, true], "aps.04.10": [76, true], "aps.04.11": [77, true], "aps.04.12": [67, true], "aps.04.13": [66, true], "aps.05.00": [69, true], "aps.06.00": [72, true], "aps.06.01": [71, true], "aps.06.02": [67, true], "aps.06.03": [69, true], "aps.06.04": [67, true], "aps.06.05": [69, true], "aps.06.06": [69, true], "aps.06.07": [67, true], "aps.06.08": [69, true], "aps.06.09": [73, true], "aps.07.00": [72, true], "aps.07.01": [72, true], "aps.07.02": [79, true], "aps.08.00": [3, true], "aps.08.01": [68, true], "aps.08.02": [68, true], "aps.08.03": [67, true], "aps.08.04": [65, true], "aps.09.00": [69, true], "aps.09.01": [69, true], "aps.09.02": [68, true], "aps.09.03": [70, true], "aps.09.04": [79, true], "aps.09.05": [82, true], "aps.09.06": [78, true], "aps.10.00": [71, true], "aps.10.01": [68, true], "aps.10.02": [64, true], "aps.10.03": [58, true], "aps.10.04": [55, true], "aps.11.00": [67, true], "aps.11.01": [70, true], "aps.11.02": [72, true], "aps.11.03": [70, true], "aps.12.00": [73, true], "aps.12.01": [63, true], "aps.12.02": [73, true], "aps.12.03": [73, true], "aps.12.04": [73, true], "aps.12.05": [76, true], "aps.12.06": [79, true], "aps.12.07": [74, true], "aps.12.08": [79, true], "aps.12.09": [81, true], "aps.12.10": [77, true], "aps.12.11": [78, true], "aps.12.12": [76, true], "aps.12.13": [77, true], "aps.12.14": [75, true], "aps.12.15": [75, true], "aps.12.16": [75, true], "aps.12.17": [77, true], "aps.12.18": [78, true], "aps.13.00": [14, false], "aps.14.00": [78, true], "aps.14.01": [78, true], "aps.14.02": [78, true], "aps.14.03": [78, true], "aps.14.04": [78, true], "aps.14.05": [78, true], "aps.14.06": [78, true], "aps.14.07": [78, true], "aps.14.08": [78, true], "aps.14.09": [78, true], "aps.14.10": [78, true], "aps.14.11": [78, true], "aps.14.12": [78, true], "aps.14.13": [78, true], "aps.14.14": [78, true], "aps.14.15": [78, true], "aps.14.16": [78, true], "aps.14.17": [78, true], "aps.14.18": [78, true], "aps.14.19": [78, true], "aps.14.20": [78, true], "aps.14.21": [78, true], "aps.14.22": [78, true], "aps.14.23": [78, true], "aps.14.24": [78, true], "aps.14.25": [78, true], "aps.14.26": [78, true], "aps.14.27": [78, true], "aps.14.28": [78, true], "aps.14.29": [78, true], "aps.14.30": [78, true], "aps.14.31": [78, true], "aps.14.32": [78, true], "aps.14.33": [78, true], "aps.14.34": [78, true], "aps.14.35": [78, true], "aps.14.36": [78, true], "aps.14.37": [78, true], "aps.14.38": [78, true], "aps.14.39": [78, true], "aps.15.00": [81, true], "aps.15.01": [79, true], "aps.15.02": [81, true], "aps.15.03": [83, true], "aps.15.04": [81, true], "aps.15.05": [81, true], "aps.15.06": [79, true], "aps.15.07": [78, true], "aps.15.08": [80, true], "aps.15.09": [79, true], "aps.15.10": [81, true], "aps.15.11": [81, true], "aps.15.12": [80, true], "aps.15.13": [83, true], "aps.15.14": [80, true], "aps.15.15": [82, true], "aps.15.16": [79, true], "aps.15.17": [80, true], "aps.15.18": [79, true], "aps.15.19": [76, true], "aps.15.20": [75, true], "aps.15.21": [84, true], "aps.15.22": [77, true], "aps.15.23": [81, true], "aps.15.24": [79, true], "aps.15.25": [76, true], "aps.15.26": [78, true], "aps.15.27": [78, true], "aps.15.28": [82, true], "aps.15.29": [82, true], "aps.15.30": [83, true]}}, "CHA": {"total": 3798, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [71, true], "fun1.2": [74, true], "fun1.3": [78, true], "fun1.4": [72, true], "fun1.5": [92, true], "fun2.1": [72, true], "fun2.2": [86, true], "fun2.3": [95, true], "fun2.4": [110, true], "fun2.5": [115, true], "fun3.1": [53, true], "fun3.2": [61, true], "fun3.3": [72, true], "fun3.4": [78, true], "fun3.5": [92, true], "fun4.1": [49, true], "fun4.2": [51, true], "fun4.3": [66, true], "fun4.4": [72, true], "fun4.5": [86, true], "fun5.1": [48, true], "fun5.2": [49, true], "fun5.3": [53, true], "fun5.4": [55, true], "fun5.5": [56, true], "fun6.1": [46, true], "fun6.2": [47, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [14, false], "fun7.2": [11, false], "fun7.3": [16, false], "fun7.4": [15, false], "fun7.5": [18, false], "fun8.1": [72, true], "fun8.2": [74, true], "fun8.3": [74, true], "fun8.4": [77, true], "fun8.5": [80, true], "fun9.1": [71, true], "fun9.2": [73, true], "fun9.3": [76, true], "fun9.4": [76, true], "fun9.5": [80, true]}}}, {"label": "pure.rat_sq.bracket.credit", "spec": ["pure", "rat_sq", "bracket", "credit"], "APS": {"total": 7678, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [42, true], "aps.10.00": [43, true], "aps.10.01": [42, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [7, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [51, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3125, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [46, true], "fun1.3": [50, true], "fun1.4": [55, true], "fun1.5": [77, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [7, false], "fun7.2": [9, false], "fun7.3": [11, false], "fun7.4": [11, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.rat_sq.bracket.project", "spec": ["pure", "rat_sq", "bracket", "project"], "APS": {"total": 14487, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [88, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [89, true], "aps.04.03": [88, true], "aps.04.04": [89, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [78, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [78, true], "aps.05.00": [84, true], "aps.06.00": [83, true], "aps.06.01": [83, true], "aps.06.02": [83, true], "aps.06.03": [82, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [83, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [82, true], "aps.07.02": [82, true], "aps.08.00": [3, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [82, true], "aps.09.00": [81, true], "aps.09.01": [82, true], "aps.09.02": [82, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [83, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [72, true], "aps.11.02": [82, true], "aps.11.03": [70, true], "aps.12.00": [97, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [96, true], "aps.12.06": [96, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [80, true], "aps.12.11": [92, true], "aps.12.12": [96, true], "aps.12.13": [96, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [97, true], "aps.12.17": [83, true], "aps.12.18": [79, true], "aps.13.00": [51, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [102, true], "aps.15.01": [102, true], "aps.15.02": [103, true], "aps.15.03": [102, true], "aps.15.04": [102, true], "aps.15.05": [101, true], "aps.15.06": [103, true], "aps.15.07": [103, true], "aps.15.08": [100, true], "aps.15.09": [103, true], "aps.15.10": [103, true], "aps.15.11": [102, true], "aps.15.12": [103, true], "aps.15.13": [102, true], "aps.15.14": [102, true], "aps.15.15": [102, true], "aps.15.16": [101, true], "aps.15.17": [101, true], "aps.15.18": [102, true], "aps.15.19": [101, true], "aps.15.20": [102, true], "aps.15.21": [102, true], "aps.15.22": [102, true], "aps.15.23": [103, true], "aps.15.24": [102, true], "aps.15.25": [102, true], "aps.15.26": [100, true], "aps.15.27": [102, true], "aps.15.28": [102, true], "aps.15.29": [101, true], "aps.15.30": [103, true]}}, "CHA": {"total": 5091, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [112, true], "fun1.5": [153, true], "fun2.1": [71, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [151, true], "fun2.5": [162, true], "fun3.1": [88, true], "fun3.2": [92, true], "fun3.3": [113, true], "fun3.4": [124, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [78, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [51, false], "fun7.2": [51, false], "fun7.3": [50, false], "fun7.4": [58, false], "fun7.5": [54, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [83, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [93, true], "fun9.5": [96, true]}}}, {"label": "pure.rat_sq.bracket.safe", "spec": ["pure", "rat_sq", "bracket", "safe"], "APS": {"total": 13896, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [85, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [90, true], "aps.02.06": [90, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [93, true], "aps.03.00": [92, true], "aps.03.01": [93, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [87, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [87, true], "aps.04.06": [85, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [89, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [83, true], "aps.06.01": [83, true], "aps.06.02": [82, true], "aps.06.03": [81, true], "aps.06.04": [83, true], "aps.06.05": [83, true], "aps.06.06": [83, true], "aps.06.07": [81, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [83, true], "aps.07.01": [83, true], "aps.07.02": [80, true], "aps.08.00": [3, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [81, true], "aps.08.04": [83, true], "aps.09.00": [80, true], "aps.09.01": [80, true], "aps.09.02": [81, true], "aps.09.03": [78, true], "aps.09.04": [82, true], "aps.09.05": [78, true], "aps.09.06": [63, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [81, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [80, true], "aps.11.01": [82, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [96, true], "aps.12.02": [96, true], "aps.12.03": [96, true], "aps.12.04": [97, true], "aps.12.05": [96, true], "aps.12.06": [96, true], "aps.12.07": [97, true], "aps.12.08": [96, true], "aps.12.09": [96, true], "aps.12.10": [96, true], "aps.12.11": [97, true], "aps.12.12": [97, true], "aps.12.13": [97, true], "aps.12.14": [95, true], "aps.12.15": [96, true], "aps.12.16": [93, true], "aps.12.17": [97, true], "aps.12.18": [93, true], "aps.13.00": [10, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [88, true], "aps.15.01": [89, true], "aps.15.02": [87, true], "aps.15.03": [82, true], "aps.15.04": [87, true], "aps.15.05": [87, true], "aps.15.06": [89, true], "aps.15.07": [87, true], "aps.15.08": [72, true], "aps.15.09": [86, true], "aps.15.10": [77, true], "aps.15.11": [77, true], "aps.15.12": [86, true], "aps.15.13": [87, true], "aps.15.14": [90, true], "aps.15.15": [90, true], "aps.15.16": [89, true], "aps.15.17": [88, true], "aps.15.18": [80, true], "aps.15.19": [79, true], "aps.15.20": [85, true], "aps.15.21": [82, true], "aps.15.22": [74, true], "aps.15.23": [72, true], "aps.15.24": [79, true], "aps.15.25": [72, true], "aps.15.26": [74, true], "aps.15.27": [70, true], "aps.15.28": [77, true], "aps.15.29": [84, true], "aps.15.30": [72, true]}}, "CHA": {"total": 4442, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [90, true], "fun1.3": [95, true], "fun1.4": [99, true], "fun1.5": [123, true], "fun2.1": [81, true], "fun2.2": [101, true], "fun2.3": [111, true], "fun2.4": [127, true], "fun2.5": [127, true], "fun3.1": [78, true], "fun3.2": [79, true], "fun3.3": [85, true], "fun3.4": [93, true], "fun3.5": [108, true], "fun4.1": [74, true], "fun4.2": [76, true], "fun4.3": [85, true], "fun4.4": [84, true], "fun4.5": [97, true], "fun5.1": [85, true], "fun5.2": [71, true], "fun5.3": [70, true], "fun5.4": [72, true], "fun5.5": [73, true], "fun6.1": [49, true], "fun6.2": [52, true], "fun6.3": [57, true], "fun6.4": [62, true], "fun6.5": [64, true], "fun7.1": [10, false], "fun7.2": [57, false], "fun7.3": [15, false], "fun7.4": [20, false], "fun7.5": [18, false], "fun8.1": [83, true], "fun8.2": [86, true], "fun8.3": [91, true], "fun8.4": [93, true], "fun8.5": [95, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [91, true], "fun9.5": [95, true]}}}, {"label": "pure.rat_sq.derived.bracket", "spec": ["pure", "rat_sq", "derived", "bracket"], "APS": {"total": 10328, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [66, true], "aps.02.00": [63, true], "aps.02.01": [66, true], "aps.02.02": [70, true], "aps.02.03": [70, true], "aps.02.04": [66, true], "aps.02.05": [68, true], "aps.02.06": [66, true], "aps.02.07": [69, true], "aps.02.08": [68, true], "aps.02.09": [71, true], "aps.03.00": [67, true], "aps.03.01": [70, true], "aps.03.02": [70, true], "aps.04.00": [68, true], "aps.04.01": [66, true], "aps.04.02": [65, true], "aps.04.03": [64, true], "aps.04.04": [63, true], "aps.04.05": [66, true], "aps.04.06": [67, true], "aps.04.07": [67, true], "aps.04.08": [66, true], "aps.04.09": [65, true], "aps.04.10": [63, true], "aps.04.11": [65, true], "aps.04.12": [67, true], "aps.04.13": [68, true], "aps.05.00": [66, true], "aps.06.00": [61, true], "aps.06.01": [62, true], "aps.06.02": [61, true], "aps.06.03": [57, true], "aps.06.04": [59, true], "aps.06.05": [59, true], "aps.06.06": [61, true], "aps.06.07": [59, true], "aps.06.08": [60, true], "aps.06.09": [61, true], "aps.07.00": [59, true], "aps.07.01": [61, true], "aps.07.02": [56, true], "aps.08.00": [64, true], "aps.08.01": [60, true], "aps.08.02": [64, true], "aps.08.03": [54, true], "aps.08.04": [59, true], "aps.09.00": [63, true], "aps.09.01": [62, true], "aps.09.02": [61, true], "aps.09.03": [59, true], "aps.09.04": [57, true], "aps.09.05": [51, true], "aps.09.06": [52, true], "aps.10.00": [60, true], "aps.10.01": [64, true], "aps.10.02": [62, true], "aps.10.03": [63, true], "aps.10.04": [59, true], "aps.11.00": [63, true], "aps.11.01": [62, true], "aps.11.02": [63, true], "aps.11.03": [67, true], "aps.12.00": [70, true], "aps.12.01": [68, true], "aps.12.02": [66, true], "aps.12.03": [68, true], "aps.12.04": [69, true], "aps.12.05": [69, true], "aps.12.06": [67, true], "aps.12.07": [69, true], "aps.12.08": [71, true], "aps.12.09": [71, true], "aps.12.10": [69, true], "aps.12.11": [68, true], "aps.12.12": [72, true], "aps.12.13": [68, true], "aps.12.14": [72, true], "aps.12.15": [74, true], "aps.12.16": [69, true], "aps.12.17": [75, true], "aps.12.18": [74, true], "aps.13.00": [8, false], "aps.14.00": [70, true], "aps.14.01": [70, true], "aps.14.02": [70, true], "aps.14.03": [70, true], "aps.14.04": [70, true], "aps.14.05": [70, true], "aps.14.06": [70, true], "aps.14.07": [70, true], "aps.14.08": [70, true], "aps.14.09": [70, true], "aps.14.10": [70, true], "aps.14.11": [70, true], "aps.14.12": [70, true], "aps.14.13": [70, true], "aps.14.14": [70, true], "aps.14.15": [70, true], "aps.14.16": [70, true], "aps.14.17": [70, true], "aps.14.18": [70, true], "aps.14.19": [70, true], "aps.14.20": [70, true], "aps.14.21": [70, true], "aps.14.22": [70, true], "aps.14.23": [70, true], "aps.14.24": [70, true], "aps.14.25": [70, true], "aps.14.26": [70, true], "aps.14.27": [70, true], "aps.14.28": [70, true], "aps.14.29": [70, true], "aps.14.30": [70, true], "aps.14.31": [70, true], "aps.14.32": [70, true], "aps.14.33": [70, true], "aps.14.34": [70, true], "aps.14.35": [70, true], "aps.14.36": [70, true], "aps.14.37": [70, true], "aps.14.38": [70, true], "aps.14.39": [70, true], "aps.15.00": [68, true], "aps.15.01": [66, true], "aps.15.02": [67, true], "aps.15.03": [65, true], "aps.15.04": [65, true], "aps.15.05": [68, true], "aps.15.06": [68, true], "aps.15.07": [66, true], "aps.15.08": [66, true], "aps.15.09": [63, true], "aps.15.10": [67, true], "aps.15.11": [66, true], "aps.15.12": [66, true], "aps.15.13": [65, true], "aps.15.14": [68, true], "aps.15.15": [68, true], "aps.15.16": [66, true], "aps.15.17": [68, true], "aps.15.18": [65, true], "aps.15.19": [67, true], "aps.15.20": [67, true], "aps.15.21": [64, true], "aps.15.22": [64, true], "aps.15.23": [59, true], "aps.15.24": [61, true], "aps.15.25": [63, true], "aps.15.26": [63, true], "aps.15.27": [62, true], "aps.15.28": [64, true], "aps.15.29": [62, true], "aps.15.30": [61, true]}}, "CHA": {"total": 4044, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [62, true], "fun1.2": [68, true], "fun1.3": [74, true], "fun1.4": [88, true], "fun1.5": [121, true], "fun2.1": [59, true], "fun2.2": [84, true], "fun2.3": [91, true], "fun2.4": [106, true], "fun2.5": [112, true], "fun3.1": [76, true], "fun3.2": [80, true], "fun3.3": [96, true], "fun3.4": [107, true], "fun3.5": [130, true], "fun4.1": [70, true], "fun4.2": [72, true], "fun4.3": [93, true], "fun4.4": [101, true], "fun4.5": [124, true], "fun5.1": [47, true], "fun5.2": [64, true], "fun5.3": [61, true], "fun5.4": [73, true], "fun5.5": [75, true], "fun6.1": [43, true], "fun6.2": [43, true], "fun6.3": [46, true], "fun6.4": [47, true], "fun6.5": [47, true], "fun7.1": [8, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [14, false], "fun7.5": [28, false], "fun8.1": [65, true], "fun8.2": [64, true], "fun8.3": [69, true], "fun8.4": [72, true], "fun8.5": [76, true], "fun9.1": [64, true], "fun9.2": [64, true], "fun9.3": [68, true], "fun9.4": [70, true], "fun9.5": [72, true]}}}, {"label": "pure.rat_sq.derived.both", "spec": ["pure", "rat_sq", "derived", "both"], "APS": {"total": 9630, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [59, true], "aps.02.00": [62, true], "aps.02.01": [61, true], "aps.02.02": [61, true], "aps.02.03": [62, true], "aps.02.04": [56, true], "aps.02.05": [61, true], "aps.02.06": [61, true], "aps.02.07": [64, true], "aps.02.08": [61, true], "aps.02.09": [61, true], "aps.03.00": [64, true], "aps.03.01": [65, true], "aps.03.02": [63, true], "aps.04.00": [60, true], "aps.04.01": [60, true], "aps.04.02": [62, true], "aps.04.03": [60, true], "aps.04.04": [58, true], "aps.04.05": [62, true], "aps.04.06": [61, true], "aps.04.07": [61, true], "aps.04.08": [61, true], "aps.04.09": [64, true], "aps.04.10": [59, true], "aps.04.11": [61, true], "aps.04.12": [58, true], "aps.04.13": [58, true], "aps.05.00": [59, true], "aps.06.00": [59, true], "aps.06.01": [58, true], "aps.06.02": [54, true], "aps.06.03": [57, true], "aps.06.04": [54, true], "aps.06.05": [54, true], "aps.06.06": [56, true], "aps.06.07": [57, true], "aps.06.08": [55, true], "aps.06.09": [57, true], "aps.07.00": [57, true], "aps.07.01": [51, true], "aps.07.02": [54, true], "aps.08.00": [57, true], "aps.08.01": [54, true], "aps.08.02": [59, true], "aps.08.03": [57, true], "aps.08.04": [55, true], "aps.09.00": [59, true], "aps.09.01": [55, true], "aps.09.02": [53, true], "aps.09.03": [56, true], "aps.09.04": [53, true], "aps.09.05": [50, true], "aps.09.06": [47, true], "aps.10.00": [58, true], "aps.10.01": [58, true], "aps.10.02": [57, true], "aps.10.03": [58, true], "aps.10.04": [56, true], "aps.11.00": [57, true], "aps.11.01": [57, true], "aps.11.02": [59, true], "aps.11.03": [61, true], "aps.12.00": [67, true], "aps.12.01": [59, true], "aps.12.02": [59, true], "aps.12.03": [66, true], "aps.12.04": [64, true], "aps.12.05": [64, true], "aps.12.06": [63, true], "aps.12.07": [65, true], "aps.12.08": [65, true], "aps.12.09": [65, true], "aps.12.10": [68, true], "aps.12.11": [68, true], "aps.12.12": [66, true], "aps.12.13": [67, true], "aps.12.14": [67, true], "aps.12.15": [67, true], "aps.12.16": [65, true], "aps.12.17": [65, true], "aps.12.18": [66, true], "aps.13.00": [8, false], "aps.14.00": [65, true], "aps.14.01": [65, true], "aps.14.02": [65, true], "aps.14.03": [65, true], "aps.14.04": [65, true], "aps.14.05": [65, true], "aps.14.06": [65, true], "aps.14.07": [65, true], "aps.14.08": [65, true], "aps.14.09": [65, true], "aps.14.10": [65, true], "aps.14.11": [65, true], "aps.14.12": [65, true], "aps.14.13": [65, true], "aps.14.14": [65, true], "aps.14.15": [65, true], "aps.14.16": [65, true], "aps.14.17": [65, true], "aps.14.18": [65, true], "aps.14.19": [65, true], "aps.14.20": [65, true], "aps.14.21": [65, true], "aps.14.22": [65, true], "aps.14.23": [65, true], "aps.14.24": [65, true], "aps.14.25": [65, true], "aps.14.26": [65, true], "aps.14.27": [65, true], "aps.14.28": [65, true], "aps.14.29": [65, true], "aps.14.30": [65, true], "aps.14.31": [65, true], "aps.14.32": [65, true], "aps.14.33": [65, true], "aps.14.34": [65, true], "aps.14.35": [65, true], "aps.14.36": [65, true], "aps.14.37": [65, true], "aps.14.38": [65, true], "aps.14.39": [65, true], "aps.15.00": [64, true], "aps.15.01": [65, true], "aps.15.02": [64, true], "aps.15.03": [63, true], "aps.15.04": [62, true], "aps.15.05": [64, true], "aps.15.06": [63, true], "aps.15.07": [64, true], "aps.15.08": [61, true], "aps.15.09": [59, true], "aps.15.10": [64, true], "aps.15.11": [62, true], "aps.15.12": [64, true], "aps.15.13": [64, true], "aps.15.14": [62, true], "aps.15.15": [63, true], "aps.15.16": [65, true], "aps.15.17": [66, true], "aps.15.18": [65, true], "aps.15.19": [64, true], "aps.15.20": [63, true], "aps.15.21": [62, true], "aps.15.22": [59, true], "aps.15.23": [57, true], "aps.15.24": [60, true], "aps.15.25": [61, true], "aps.15.26": [59, true], "aps.15.27": [61, true], "aps.15.28": [60, true], "aps.15.29": [61, true], "aps.15.30": [59, true]}}, "CHA": {"total": 3827, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [59, true], "fun1.2": [63, true], "fun1.3": [71, true], "fun1.4": [76, true], "fun1.5": [115, true], "fun2.1": [56, true], "fun2.2": [74, true], "fun2.3": [82, true], "fun2.4": [95, true], "fun2.5": [102, true], "fun3.1": [68, true], "fun3.2": [70, true], "fun3.3": [88, true], "fun3.4": [99, true], "fun3.5": [118, true], "fun4.1": [64, true], "fun4.2": [67, true], "fun4.3": [82, true], "fun4.4": [97, true], "fun4.5": [115, true], "fun5.1": [67, true], "fun5.2": [69, true], "fun5.3": [62, true], "fun5.4": [68, true], "fun5.5": [69, true], "fun6.1": [42, true], "fun6.2": [39, true], "fun6.3": [44, true], "fun6.4": [44, true], "fun6.5": [44, true], "fun7.1": [8, false], "fun7.2": [10, false], "fun7.3": [10, false], "fun7.4": [12, false], "fun7.5": [16, false], "fun8.1": [59, true], "fun8.2": [61, true], "fun8.3": [61, true], "fun8.4": [63, true], "fun8.5": [66, true], "fun9.1": [56, true], "fun9.2": [57, true], "fun9.3": [65, true], "fun9.4": [64, true], "fun9.5": [66, true]}}}, {"label": "pure.rat_sq.bracket.none", "spec": ["pure", "rat_sq", "bracket", "none"], "APS": {"total": 30603, "solved": 1, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [3, true], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.rat_sq.derived.step", "spec": ["pure", "rat_sq", "derived", "step"], "APS": {"total": 18204, "solved": 153, "n": 154, "over": 125, "per": {"aps.01.00": [117, true], "aps.02.00": [119, true], "aps.02.01": [126, true], "aps.02.02": [127, true], "aps.02.03": [125, true], "aps.02.04": [106, true], "aps.02.05": [121, true], "aps.02.06": [126, true], "aps.02.07": [126, true], "aps.02.08": [126, true], "aps.02.09": [126, true], "aps.03.00": [125, true], "aps.03.01": [123, true], "aps.03.02": [121, true], "aps.04.00": [118, true], "aps.04.01": [117, true], "aps.04.02": [118, true], "aps.04.03": [117, true], "aps.04.04": [115, true], "aps.04.05": [119, true], "aps.04.06": [121, true], "aps.04.07": [119, true], "aps.04.08": [115, true], "aps.04.09": [115, true], "aps.04.10": [119, true], "aps.04.11": [117, true], "aps.04.12": [117, true], "aps.04.13": [116, true], "aps.05.00": [121, true], "aps.06.00": [117, true], "aps.06.01": [119, true], "aps.06.02": [113, true], "aps.06.03": [113, true], "aps.06.04": [113, true], "aps.06.05": [110, true], "aps.06.06": [109, true], "aps.06.07": [108, true], "aps.06.08": [103, true], "aps.06.09": [106, true], "aps.07.00": [116, true], "aps.07.01": [111, true], "aps.07.02": [105, true], "aps.08.00": [122, true], "aps.08.01": [118, true], "aps.08.02": [121, true], "aps.08.03": [111, true], "aps.08.04": [113, true], "aps.09.00": [119, true], "aps.09.01": [114, true], "aps.09.02": [111, true], "aps.09.03": [107, true], "aps.09.04": [100, true], "aps.09.05": [95, true], "aps.09.06": [90, true], "aps.10.00": [118, true], "aps.10.01": [119, true], "aps.10.02": [116, true], "aps.10.03": [120, true], "aps.10.04": [116, true], "aps.11.00": [115, true], "aps.11.01": [111, true], "aps.11.02": [115, true], "aps.11.03": [111, true], "aps.12.00": [128, true], "aps.12.01": [128, true], "aps.12.02": [127, true], "aps.12.03": [124, true], "aps.12.04": [127, true], "aps.12.05": [128, true], "aps.12.06": [128, true], "aps.12.07": [126, true], "aps.12.08": [135, true], "aps.12.09": [137, true], "aps.12.10": [140, true], "aps.12.11": [134, true], "aps.12.12": [137, true], "aps.12.13": [130, true], "aps.12.14": [130, true], "aps.12.15": [133, true], "aps.12.16": [135, true], "aps.12.17": [134, true], "aps.12.18": [129, true], "aps.13.00": [11, false], "aps.14.00": [129, true], "aps.14.01": [129, true], "aps.14.02": [129, true], "aps.14.03": [129, true], "aps.14.04": [129, true], "aps.14.05": [129, true], "aps.14.06": [129, true], "aps.14.07": [129, true], "aps.14.08": [129, true], "aps.14.09": [129, true], "aps.14.10": [129, true], "aps.14.11": [129, true], "aps.14.12": [129, true], "aps.14.13": [129, true], "aps.14.14": [129, true], "aps.14.15": [129, true], "aps.14.16": [129, true], "aps.14.17": [129, true], "aps.14.18": [129, true], "aps.14.19": [129, true], "aps.14.20": [129, true], "aps.14.21": [129, true], "aps.14.22": [129, true], "aps.14.23": [129, true], "aps.14.24": [129, true], "aps.14.25": [129, true], "aps.14.26": [129, true], "aps.14.27": [129, true], "aps.14.28": [129, true], "aps.14.29": [129, true], "aps.14.30": [129, true], "aps.14.31": [129, true], "aps.14.32": [129, true], "aps.14.33": [129, true], "aps.14.34": [129, true], "aps.14.35": [129, true], "aps.14.36": [129, true], "aps.14.37": [129, true], "aps.14.38": [129, true], "aps.14.39": [129, true], "aps.15.00": [104, true], "aps.15.01": [105, true], "aps.15.02": [100, true], "aps.15.03": [103, true], "aps.15.04": [104, true], "aps.15.05": [105, true], "aps.15.06": [105, true], "aps.15.07": [101, true], "aps.15.08": [101, true], "aps.15.09": [100, true], "aps.15.10": [100, true], "aps.15.11": [102, true], "aps.15.12": [104, true], "aps.15.13": [104, true], "aps.15.14": [102, true], "aps.15.15": [100, true], "aps.15.16": [95, true], "aps.15.17": [98, true], "aps.15.18": [101, true], "aps.15.19": [102, true], "aps.15.20": [102, true], "aps.15.21": [103, true], "aps.15.22": [93, true], "aps.15.23": [92, true], "aps.15.24": [93, true], "aps.15.25": [94, true], "aps.15.26": [90, true], "aps.15.27": [88, true], "aps.15.28": [93, true], "aps.15.29": [92, true], "aps.15.30": [95, true]}}, "CHA": {"total": 5481, "solved": 40, "n": 45, "over": 23, "per": {"fun1.1": [120, true], "fun1.2": [125, true], "fun1.3": [134, true], "fun1.4": [150, true], "fun1.5": [193, true], "fun2.1": [116, true], "fun2.2": [137, true], "fun2.3": [144, true], "fun2.4": [155, true], "fun2.5": [164, true], "fun3.1": [87, true], "fun3.2": [95, true], "fun3.3": [121, true], "fun3.4": [136, true], "fun3.5": [169, true], "fun4.1": [88, true], "fun4.2": [91, true], "fun4.3": [111, true], "fun4.4": [118, true], "fun4.5": [151, true], "fun5.1": [77, true], "fun5.2": [83, true], "fun5.3": [80, true], "fun5.4": [92, true], "fun5.5": [93, true], "fun6.1": [41, true], "fun6.2": [47, true], "fun6.3": [44, true], "fun6.4": [44, true], "fun6.5": [44, true], "fun7.1": [11, false], "fun7.2": [10, false], "fun7.3": [11, false], "fun7.4": [15, false], "fun7.5": [23, false], "fun8.1": [118, true], "fun8.2": [121, true], "fun8.3": [122, true], "fun8.4": [126, true], "fun8.5": [122, true], "fun9.1": [119, true], "fun9.2": [125, true], "fun9.3": [124, true], "fun9.4": [125, true], "fun9.5": [129, true]}}}, {"label": "pure.rat_sq.derived.project", "spec": ["pure", "rat_sq", "derived", "project"], "APS": {"total": 14725, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [91, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [89, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [89, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [88, true], "aps.04.07": [89, true], "aps.04.08": [88, true], "aps.04.09": [89, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [89, true], "aps.04.13": [88, true], "aps.05.00": [85, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [82, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [83, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [82, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [82, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [97, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [97, true], "aps.12.12": [97, true], "aps.12.13": [97, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [96, true], "aps.12.18": [92, true], "aps.13.00": [51, false], "aps.14.00": [103, true], "aps.14.01": [103, true], "aps.14.02": [103, true], "aps.14.03": [103, true], "aps.14.04": [103, true], "aps.14.05": [103, true], "aps.14.06": [103, true], "aps.14.07": [103, true], "aps.14.08": [103, true], "aps.14.09": [103, true], "aps.14.10": [103, true], "aps.14.11": [103, true], "aps.14.12": [103, true], "aps.14.13": [103, true], "aps.14.14": [103, true], "aps.14.15": [103, true], "aps.14.16": [103, true], "aps.14.17": [103, true], "aps.14.18": [103, true], "aps.14.19": [103, true], "aps.14.20": [103, true], "aps.14.21": [103, true], "aps.14.22": [103, true], "aps.14.23": [103, true], "aps.14.24": [103, true], "aps.14.25": [103, true], "aps.14.26": [103, true], "aps.14.27": [103, true], "aps.14.28": [103, true], "aps.14.29": [103, true], "aps.14.30": [103, true], "aps.14.31": [103, true], "aps.14.32": [103, true], "aps.14.33": [103, true], "aps.14.34": [103, true], "aps.14.35": [103, true], "aps.14.36": [103, true], "aps.14.37": [103, true], "aps.14.38": [103, true], "aps.14.39": [103, true], "aps.15.00": [102, true], "aps.15.01": [103, true], "aps.15.02": [103, true], "aps.15.03": [102, true], "aps.15.04": [102, true], "aps.15.05": [102, true], "aps.15.06": [102, true], "aps.15.07": [103, true], "aps.15.08": [103, true], "aps.15.09": [103, true], "aps.15.10": [102, true], "aps.15.11": [102, true], "aps.15.12": [102, true], "aps.15.13": [103, true], "aps.15.14": [103, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [102, true], "aps.15.20": [103, true], "aps.15.21": [103, true], "aps.15.22": [103, true], "aps.15.23": [102, true], "aps.15.24": [102, true], "aps.15.25": [102, true], "aps.15.26": [102, true], "aps.15.27": [102, true], "aps.15.28": [103, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 5115, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [111, true], "fun2.3": [122, true], "fun2.4": [150, true], "fun2.5": [163, true], "fun3.1": [88, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [88, true], "fun4.2": [93, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [52, false], "fun7.3": [54, false], "fun7.4": [57, false], "fun7.5": [60, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.rat_sq.derived.none", "spec": ["pure", "rat_sq", "derived", "none"], "APS": {"total": 30800, "solved": 0, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.rat_sq.derived.credit", "spec": ["pure", "rat_sq", "derived", "credit"], "APS": {"total": 7682, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [49, true], "aps.13.00": [7, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [7, false], "fun7.2": [9, false], "fun7.3": [11, false], "fun7.4": [49, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.rat_sq.derived3.bracket", "spec": ["pure", "rat_sq", "derived3", "bracket"], "APS": {"total": 10243, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [65, true], "aps.02.00": [61, true], "aps.02.01": [67, true], "aps.02.02": [63, true], "aps.02.03": [67, true], "aps.02.04": [68, true], "aps.02.05": [67, true], "aps.02.06": [65, true], "aps.02.07": [63, true], "aps.02.08": [65, true], "aps.02.09": [70, true], "aps.03.00": [69, true], "aps.03.01": [67, true], "aps.03.02": [69, true], "aps.04.00": [66, true], "aps.04.01": [66, true], "aps.04.02": [68, true], "aps.04.03": [68, true], "aps.04.04": [66, true], "aps.04.05": [64, true], "aps.04.06": [64, true], "aps.04.07": [59, true], "aps.04.08": [56, true], "aps.04.09": [65, true], "aps.04.10": [68, true], "aps.04.11": [65, true], "aps.04.12": [68, true], "aps.04.13": [65, true], "aps.05.00": [64, true], "aps.06.00": [65, true], "aps.06.01": [62, true], "aps.06.02": [62, true], "aps.06.03": [61, true], "aps.06.04": [61, true], "aps.06.05": [56, true], "aps.06.06": [60, true], "aps.06.07": [56, true], "aps.06.08": [59, true], "aps.06.09": [59, true], "aps.07.00": [60, true], "aps.07.01": [58, true], "aps.07.02": [57, true], "aps.08.00": [65, true], "aps.08.01": [66, true], "aps.08.02": [61, true], "aps.08.03": [62, true], "aps.08.04": [59, true], "aps.09.00": [62, true], "aps.09.01": [63, true], "aps.09.02": [55, true], "aps.09.03": [58, true], "aps.09.04": [54, true], "aps.09.05": [54, true], "aps.09.06": [54, true], "aps.10.00": [64, true], "aps.10.01": [64, true], "aps.10.02": [61, true], "aps.10.03": [64, true], "aps.10.04": [61, true], "aps.11.00": [61, true], "aps.11.01": [57, true], "aps.11.02": [60, true], "aps.11.03": [62, true], "aps.12.00": [72, true], "aps.12.01": [68, true], "aps.12.02": [67, true], "aps.12.03": [67, true], "aps.12.04": [67, true], "aps.12.05": [71, true], "aps.12.06": [68, true], "aps.12.07": [69, true], "aps.12.08": [68, true], "aps.12.09": [74, true], "aps.12.10": [68, true], "aps.12.11": [69, true], "aps.12.12": [72, true], "aps.12.13": [72, true], "aps.12.14": [69, true], "aps.12.15": [74, true], "aps.12.16": [71, true], "aps.12.17": [70, true], "aps.12.18": [72, true], "aps.13.00": [11, false], "aps.14.00": [69, true], "aps.14.01": [69, true], "aps.14.02": [69, true], "aps.14.03": [69, true], "aps.14.04": [69, true], "aps.14.05": [69, true], "aps.14.06": [69, true], "aps.14.07": [69, true], "aps.14.08": [69, true], "aps.14.09": [69, true], "aps.14.10": [69, true], "aps.14.11": [69, true], "aps.14.12": [69, true], "aps.14.13": [69, true], "aps.14.14": [69, true], "aps.14.15": [69, true], "aps.14.16": [69, true], "aps.14.17": [69, true], "aps.14.18": [69, true], "aps.14.19": [69, true], "aps.14.20": [69, true], "aps.14.21": [69, true], "aps.14.22": [69, true], "aps.14.23": [69, true], "aps.14.24": [69, true], "aps.14.25": [69, true], "aps.14.26": [69, true], "aps.14.27": [69, true], "aps.14.28": [69, true], "aps.14.29": [69, true], "aps.14.30": [69, true], "aps.14.31": [69, true], "aps.14.32": [69, true], "aps.14.33": [69, true], "aps.14.34": [69, true], "aps.14.35": [69, true], "aps.14.36": [69, true], "aps.14.37": [69, true], "aps.14.38": [69, true], "aps.14.39": [69, true], "aps.15.00": [68, true], "aps.15.01": [68, true], "aps.15.02": [66, true], "aps.15.03": [64, true], "aps.15.04": [65, true], "aps.15.05": [68, true], "aps.15.06": [68, true], "aps.15.07": [63, true], "aps.15.08": [64, true], "aps.15.09": [64, true], "aps.15.10": [66, true], "aps.15.11": [68, true], "aps.15.12": [65, true], "aps.15.13": [65, true], "aps.15.14": [66, true], "aps.15.15": [65, true], "aps.15.16": [67, true], "aps.15.17": [67, true], "aps.15.18": [67, true], "aps.15.19": [66, true], "aps.15.20": [66, true], "aps.15.21": [67, true], "aps.15.22": [63, true], "aps.15.23": [59, true], "aps.15.24": [60, true], "aps.15.25": [63, true], "aps.15.26": [63, true], "aps.15.27": [65, true], "aps.15.28": [64, true], "aps.15.29": [62, true], "aps.15.30": [62, true]}}, "CHA": {"total": 4123, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [64, true], "fun1.2": [68, true], "fun1.3": [71, true], "fun1.4": [85, true], "fun1.5": [118, true], "fun2.1": [59, true], "fun2.2": [90, true], "fun2.3": [84, true], "fun2.4": [102, true], "fun2.5": [108, true], "fun3.1": [68, true], "fun3.2": [77, true], "fun3.3": [93, true], "fun3.4": [101, true], "fun3.5": [127, true], "fun4.1": [73, true], "fun4.2": [77, true], "fun4.3": [93, true], "fun4.4": [106, true], "fun4.5": [136, true], "fun5.1": [77, true], "fun5.2": [77, true], "fun5.3": [79, true], "fun5.4": [83, true], "fun5.5": [85, true], "fun6.1": [42, true], "fun6.2": [57, true], "fun6.3": [48, true], "fun6.4": [51, true], "fun6.5": [53, true], "fun7.1": [11, false], "fun7.2": [8, false], "fun7.3": [12, false], "fun7.4": [12, false], "fun7.5": [14, false], "fun8.1": [64, true], "fun8.2": [68, true], "fun8.3": [64, true], "fun8.4": [71, true], "fun8.5": [71, true], "fun9.1": [62, true], "fun9.2": [64, true], "fun9.3": [68, true], "fun9.4": [71, true], "fun9.5": [68, true]}}}, {"label": "pure.rat_sq.derived.safe", "spec": ["pure", "rat_sq", "derived", "safe"], "APS": {"total": 14599, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [91, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [90, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [93, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [89, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [89, true], "aps.04.07": [88, true], "aps.04.08": [89, true], "aps.04.09": [88, true], "aps.04.10": [89, true], "aps.04.11": [88, true], "aps.04.12": [89, true], "aps.04.13": [89, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [83, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [83, true], "aps.06.07": [83, true], "aps.06.08": [82, true], "aps.06.09": [83, true], "aps.07.00": [83, true], "aps.07.01": [83, true], "aps.07.02": [80, true], "aps.08.00": [82, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [80, true], "aps.10.00": [82, true], "aps.10.01": [83, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [82, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [97, true], "aps.12.01": [96, true], "aps.12.02": [97, true], "aps.12.03": [96, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [96, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [97, true], "aps.12.12": [97, true], "aps.12.13": [96, true], "aps.12.14": [97, true], "aps.12.15": [97, true], "aps.12.16": [96, true], "aps.12.17": [96, true], "aps.12.18": [96, true], "aps.13.00": [11, false], "aps.14.00": [103, true], "aps.14.01": [103, true], "aps.14.02": [103, true], "aps.14.03": [103, true], "aps.14.04": [103, true], "aps.14.05": [103, true], "aps.14.06": [103, true], "aps.14.07": [103, true], "aps.14.08": [103, true], "aps.14.09": [103, true], "aps.14.10": [103, true], "aps.14.11": [103, true], "aps.14.12": [103, true], "aps.14.13": [103, true], "aps.14.14": [103, true], "aps.14.15": [103, true], "aps.14.16": [103, true], "aps.14.17": [103, true], "aps.14.18": [103, true], "aps.14.19": [103, true], "aps.14.20": [103, true], "aps.14.21": [103, true], "aps.14.22": [103, true], "aps.14.23": [103, true], "aps.14.24": [103, true], "aps.14.25": [103, true], "aps.14.26": [103, true], "aps.14.27": [103, true], "aps.14.28": [103, true], "aps.14.29": [103, true], "aps.14.30": [103, true], "aps.14.31": [103, true], "aps.14.32": [103, true], "aps.14.33": [103, true], "aps.14.34": [103, true], "aps.14.35": [103, true], "aps.14.36": [103, true], "aps.14.37": [103, true], "aps.14.38": [103, true], "aps.14.39": [103, true], "aps.15.00": [102, true], "aps.15.01": [102, true], "aps.15.02": [100, true], "aps.15.03": [101, true], "aps.15.04": [102, true], "aps.15.05": [102, true], "aps.15.06": [102, true], "aps.15.07": [101, true], "aps.15.08": [101, true], "aps.15.09": [100, true], "aps.15.10": [100, true], "aps.15.11": [102, true], "aps.15.12": [103, true], "aps.15.13": [103, true], "aps.15.14": [102, true], "aps.15.15": [100, true], "aps.15.16": [95, true], "aps.15.17": [98, true], "aps.15.18": [101, true], "aps.15.19": [102, true], "aps.15.20": [102, true], "aps.15.21": [101, true], "aps.15.22": [93, true], "aps.15.23": [92, true], "aps.15.24": [93, true], "aps.15.25": [94, true], "aps.15.26": [90, true], "aps.15.27": [88, true], "aps.15.28": [93, true], "aps.15.29": [92, true], "aps.15.30": [95, true]}}, "CHA": {"total": 4835, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [152, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [123, true], "fun2.4": [150, true], "fun2.5": [161, true], "fun3.1": [87, true], "fun3.2": [93, true], "fun3.3": [112, true], "fun3.4": [124, true], "fun3.5": [152, true], "fun4.1": [88, true], "fun4.2": [91, true], "fun4.3": [111, true], "fun4.4": [122, true], "fun4.5": [153, true], "fun5.1": [77, true], "fun5.2": [83, true], "fun5.3": [80, true], "fun5.4": [92, true], "fun5.5": [93, true], "fun6.1": [41, true], "fun6.2": [47, true], "fun6.3": [44, true], "fun6.4": [44, true], "fun6.5": [44, true], "fun7.1": [11, false], "fun7.2": [10, false], "fun7.3": [11, false], "fun7.4": [15, false], "fun7.5": [23, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.rat_sq.derived3.none", "spec": ["pure", "rat_sq", "derived3", "none"], "APS": {"total": 30800, "solved": 0, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [200, false], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [200, false], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.rat_sq.derived3.project", "spec": ["pure", "rat_sq", "derived3", "project"], "APS": {"total": 14679, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [90, true], "aps.02.06": [90, true], "aps.02.07": [91, true], "aps.02.08": [93, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [89, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [89, true], "aps.04.11": [88, true], "aps.04.12": [89, true], "aps.04.13": [88, true], "aps.05.00": [85, true], "aps.06.00": [83, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [82, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [83, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [82, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [82, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [82, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [96, true], "aps.12.03": [96, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [97, true], "aps.12.11": [96, true], "aps.12.12": [97, true], "aps.12.13": [96, true], "aps.12.14": [97, true], "aps.12.15": [96, true], "aps.12.16": [97, true], "aps.12.17": [96, true], "aps.12.18": [94, true], "aps.13.00": [51, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [103, true], "aps.15.01": [103, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [102, true], "aps.15.05": [103, true], "aps.15.06": [103, true], "aps.15.07": [103, true], "aps.15.08": [103, true], "aps.15.09": [102, true], "aps.15.10": [103, true], "aps.15.11": [102, true], "aps.15.12": [103, true], "aps.15.13": [103, true], "aps.15.14": [103, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [102, true], "aps.15.18": [102, true], "aps.15.19": [102, true], "aps.15.20": [102, true], "aps.15.21": [102, true], "aps.15.22": [103, true], "aps.15.23": [102, true], "aps.15.24": [102, true], "aps.15.25": [102, true], "aps.15.26": [102, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [102, true], "aps.15.30": [102, true]}}, "CHA": {"total": 5114, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [96, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [83, true], "fun2.2": [110, true], "fun2.3": [123, true], "fun2.4": [150, true], "fun2.5": [162, true], "fun3.1": [88, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [52, false], "fun7.3": [52, false], "fun7.4": [57, false], "fun7.5": [60, false], "fun8.1": [85, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [93, true], "fun8.5": [96, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.rat_sq.derived3.safe", "spec": ["pure", "rat_sq", "derived3", "safe"], "APS": {"total": 14540, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [86, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [92, true], "aps.02.09": [93, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [89, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [89, true], "aps.04.07": [89, true], "aps.04.08": [89, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [89, true], "aps.04.12": [89, true], "aps.04.13": [89, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [82, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [82, true], "aps.06.09": [83, true], "aps.07.00": [83, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [82, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [82, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [78, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [83, true], "aps.09.06": [83, true], "aps.10.00": [83, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [83, true], "aps.11.00": [83, true], "aps.11.01": [83, true], "aps.11.02": [82, true], "aps.11.03": [82, true], "aps.12.00": [97, true], "aps.12.01": [97, true], "aps.12.02": [96, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [96, true], "aps.12.11": [96, true], "aps.12.12": [97, true], "aps.12.13": [96, true], "aps.12.14": [97, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [96, true], "aps.12.18": [94, true], "aps.13.00": [11, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [103, true], "aps.15.01": [101, true], "aps.15.02": [102, true], "aps.15.03": [102, true], "aps.15.04": [103, true], "aps.15.05": [101, true], "aps.15.06": [100, true], "aps.15.07": [101, true], "aps.15.08": [102, true], "aps.15.09": [102, true], "aps.15.10": [102, true], "aps.15.11": [102, true], "aps.15.12": [102, true], "aps.15.13": [102, true], "aps.15.14": [102, true], "aps.15.15": [102, true], "aps.15.16": [97, true], "aps.15.17": [97, true], "aps.15.18": [99, true], "aps.15.19": [101, true], "aps.15.20": [102, true], "aps.15.21": [95, true], "aps.15.22": [94, true], "aps.15.23": [91, true], "aps.15.24": [91, true], "aps.15.25": [91, true], "aps.15.26": [91, true], "aps.15.27": [91, true], "aps.15.28": [89, true], "aps.15.29": [87, true], "aps.15.30": [92, true]}}, "CHA": {"total": 4846, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [90, true], "fun1.3": [96, true], "fun1.4": [112, true], "fun1.5": [153, true], "fun2.1": [83, true], "fun2.2": [110, true], "fun2.3": [123, true], "fun2.4": [150, true], "fun2.5": [158, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [100, true], "fun3.4": [123, true], "fun3.5": [141, true], "fun4.1": [89, true], "fun4.2": [93, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [41, true], "fun6.2": [46, true], "fun6.3": [42, true], "fun6.4": [45, true], "fun6.5": [47, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [15, false], "fun7.5": [26, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [87, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [97, true]}}}, {"label": "pure.rat_sq.derived3.credit", "spec": ["pure", "rat_sq", "derived3", "credit"], "APS": {"total": 7683, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [11, false], "fun7.4": [49, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.rat_sq.derived3.step", "spec": ["pure", "rat_sq", "derived3", "step"], "APS": {"total": 18202, "solved": 153, "n": 154, "over": 131, "per": {"aps.01.00": [123, true], "aps.02.00": [116, true], "aps.02.01": [122, true], "aps.02.02": [113, true], "aps.02.03": [123, true], "aps.02.04": [112, true], "aps.02.05": [117, true], "aps.02.06": [121, true], "aps.02.07": [124, true], "aps.02.08": [123, true], "aps.02.09": [123, true], "aps.03.00": [127, true], "aps.03.01": [127, true], "aps.03.02": [125, true], "aps.04.00": [120, true], "aps.04.01": [118, true], "aps.04.02": [123, true], "aps.04.03": [124, true], "aps.04.04": [124, true], "aps.04.05": [124, true], "aps.04.06": [123, true], "aps.04.07": [122, true], "aps.04.08": [117, true], "aps.04.09": [117, true], "aps.04.10": [117, true], "aps.04.11": [122, true], "aps.04.12": [122, true], "aps.04.13": [121, true], "aps.05.00": [116, true], "aps.06.00": [119, true], "aps.06.01": [119, true], "aps.06.02": [115, true], "aps.06.03": [113, true], "aps.06.04": [114, true], "aps.06.05": [108, true], "aps.06.06": [108, true], "aps.06.07": [110, true], "aps.06.08": [109, true], "aps.06.09": [109, true], "aps.07.00": [116, true], "aps.07.01": [111, true], "aps.07.02": [105, true], "aps.08.00": [122, true], "aps.08.01": [119, true], "aps.08.02": [120, true], "aps.08.03": [111, true], "aps.08.04": [111, true], "aps.09.00": [120, true], "aps.09.01": [114, true], "aps.09.02": [111, true], "aps.09.03": [106, true], "aps.09.04": [100, true], "aps.09.05": [95, true], "aps.09.06": [90, true], "aps.10.00": [118, true], "aps.10.01": [117, true], "aps.10.02": [110, true], "aps.10.03": [120, true], "aps.10.04": [117, true], "aps.11.00": [115, true], "aps.11.01": [113, true], "aps.11.02": [110, true], "aps.11.03": [108, true], "aps.12.00": [130, true], "aps.12.01": [130, true], "aps.12.02": [127, true], "aps.12.03": [125, true], "aps.12.04": [124, true], "aps.12.05": [133, true], "aps.12.06": [133, true], "aps.12.07": [132, true], "aps.12.08": [135, true], "aps.12.09": [134, true], "aps.12.10": [135, true], "aps.12.11": [131, true], "aps.12.12": [129, true], "aps.12.13": [131, true], "aps.12.14": [135, true], "aps.12.15": [136, true], "aps.12.16": [136, true], "aps.12.17": [133, true], "aps.12.18": [133, true], "aps.13.00": [11, false], "aps.14.00": [128, true], "aps.14.01": [128, true], "aps.14.02": [128, true], "aps.14.03": [128, true], "aps.14.04": [128, true], "aps.14.05": [128, true], "aps.14.06": [128, true], "aps.14.07": [128, true], "aps.14.08": [128, true], "aps.14.09": [128, true], "aps.14.10": [128, true], "aps.14.11": [128, true], "aps.14.12": [128, true], "aps.14.13": [128, true], "aps.14.14": [128, true], "aps.14.15": [128, true], "aps.14.16": [128, true], "aps.14.17": [128, true], "aps.14.18": [128, true], "aps.14.19": [128, true], "aps.14.20": [128, true], "aps.14.21": [128, true], "aps.14.22": [128, true], "aps.14.23": [128, true], "aps.14.24": [128, true], "aps.14.25": [128, true], "aps.14.26": [128, true], "aps.14.27": [128, true], "aps.14.28": [128, true], "aps.14.29": [128, true], "aps.14.30": [128, true], "aps.14.31": [128, true], "aps.14.32": [128, true], "aps.14.33": [128, true], "aps.14.34": [128, true], "aps.14.35": [128, true], "aps.14.36": [128, true], "aps.14.37": [128, true], "aps.14.38": [128, true], "aps.14.39": [128, true], "aps.15.00": [104, true], "aps.15.01": [103, true], "aps.15.02": [105, true], "aps.15.03": [105, true], "aps.15.04": [105, true], "aps.15.05": [101, true], "aps.15.06": [100, true], "aps.15.07": [101, true], "aps.15.08": [105, true], "aps.15.09": [105, true], "aps.15.10": [106, true], "aps.15.11": [105, true], "aps.15.12": [105, true], "aps.15.13": [105, true], "aps.15.14": [103, true], "aps.15.15": [104, true], "aps.15.16": [97, true], "aps.15.17": [97, true], "aps.15.18": [99, true], "aps.15.19": [101, true], "aps.15.20": [103, true], "aps.15.21": [95, true], "aps.15.22": [94, true], "aps.15.23": [91, true], "aps.15.24": [91, true], "aps.15.25": [91, true], "aps.15.26": [91, true], "aps.15.27": [91, true], "aps.15.28": [89, true], "aps.15.29": [87, true], "aps.15.30": [92, true]}}, "CHA": {"total": 5585, "solved": 40, "n": 45, "over": 30, "per": {"fun1.1": [120, true], "fun1.2": [127, true], "fun1.3": [128, true], "fun1.4": [150, true], "fun1.5": [175, true], "fun2.1": [118, true], "fun2.2": [129, true], "fun2.3": [141, true], "fun2.4": [157, true], "fun2.5": [158, true], "fun3.1": [90, true], "fun3.2": [109, true], "fun3.3": [100, true], "fun3.4": [123, true], "fun3.5": [141, true], "fun4.1": [102, true], "fun4.2": [104, true], "fun4.3": [123, true], "fun4.4": [135, true], "fun4.5": [168, true], "fun5.1": [96, true], "fun5.2": [102, true], "fun5.3": [108, true], "fun5.4": [111, true], "fun5.5": [114, true], "fun6.1": [41, true], "fun6.2": [46, true], "fun6.3": [42, true], "fun6.4": [45, true], "fun6.5": [47, true], "fun7.1": [11, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [15, false], "fun7.5": [26, false], "fun8.1": [119, true], "fun8.2": [120, true], "fun8.3": [124, true], "fun8.4": [122, true], "fun8.5": [126, true], "fun9.1": [119, true], "fun9.2": [128, true], "fun9.3": [129, true], "fun9.4": [120, true], "fun9.5": [128, true]}}}, {"label": "pure.ratio.start.step", "spec": ["pure", "ratio", "start", "step"], "APS": {"total": 12777, "solved": 153, "n": 154, "over": 27, "per": {"aps.01.00": [80, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [50, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [122, true], "aps.04.01": [111, true], "aps.04.02": [130, true], "aps.04.03": [76, true], "aps.04.04": [88, true], "aps.04.05": [44, true], "aps.04.06": [136, true], "aps.04.07": [55, true], "aps.04.08": [39, true], "aps.04.09": [80, true], "aps.04.10": [76, true], "aps.04.11": [73, true], "aps.04.12": [76, true], "aps.04.13": [74, true], "aps.05.00": [153, true], "aps.06.00": [18, true], "aps.06.01": [55, true], "aps.06.02": [20, true], "aps.06.03": [75, true], "aps.06.04": [174, true], "aps.06.05": [85, true], "aps.06.06": [87, true], "aps.06.07": [71, true], "aps.06.08": [88, true], "aps.06.09": [81, true], "aps.07.00": [44, true], "aps.07.01": [49, true], "aps.07.02": [129, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [180, true], "aps.08.03": [87, true], "aps.08.04": [74, true], "aps.09.00": [32, true], "aps.09.01": [33, true], "aps.09.02": [56, true], "aps.09.03": [74, true], "aps.09.04": [81, true], "aps.09.05": [71, true], "aps.09.06": [32, true], "aps.10.00": [108, true], "aps.10.01": [175, true], "aps.10.02": [76, true], "aps.10.03": [71, true], "aps.10.04": [76, true], "aps.11.00": [71, true], "aps.11.01": [68, true], "aps.11.02": [161, true], "aps.11.03": [176, true], "aps.12.00": [147, true], "aps.12.01": [153, true], "aps.12.02": [35, true], "aps.12.03": [82, true], "aps.12.04": [49, true], "aps.12.05": [86, true], "aps.12.06": [165, true], "aps.12.07": [155, true], "aps.12.08": [65, true], "aps.12.09": [57, true], "aps.12.10": [50, true], "aps.12.11": [45, true], "aps.12.12": [40, true], "aps.12.13": [35, true], "aps.12.14": [32, true], "aps.12.15": [27, true], "aps.12.16": [38, true], "aps.12.17": [45, true], "aps.12.18": [51, true], "aps.13.00": [10, false], "aps.14.00": [86, true], "aps.14.01": [86, true], "aps.14.02": [86, true], "aps.14.03": [86, true], "aps.14.04": [86, true], "aps.14.05": [86, true], "aps.14.06": [86, true], "aps.14.07": [86, true], "aps.14.08": [86, true], "aps.14.09": [86, true], "aps.14.10": [86, true], "aps.14.11": [86, true], "aps.14.12": [86, true], "aps.14.13": [86, true], "aps.14.14": [86, true], "aps.14.15": [86, true], "aps.14.16": [86, true], "aps.14.17": [86, true], "aps.14.18": [86, true], "aps.14.19": [86, true], "aps.14.20": [86, true], "aps.14.21": [86, true], "aps.14.22": [86, true], "aps.14.23": [86, true], "aps.14.24": [86, true], "aps.14.25": [86, true], "aps.14.26": [86, true], "aps.14.27": [86, true], "aps.14.28": [86, true], "aps.14.29": [86, true], "aps.14.30": [86, true], "aps.14.31": [86, true], "aps.14.32": [86, true], "aps.14.33": [86, true], "aps.14.34": [86, true], "aps.14.35": [86, true], "aps.14.36": [86, true], "aps.14.37": [86, true], "aps.14.38": [86, true], "aps.14.39": [86, true], "aps.15.00": [88, true], "aps.15.01": [98, true], "aps.15.02": [173, true], "aps.15.03": [113, true], "aps.15.04": [92, true], "aps.15.05": [88, true], "aps.15.06": [88, true], "aps.15.07": [87, true], "aps.15.08": [82, true], "aps.15.09": [81, true], "aps.15.10": [82, true], "aps.15.11": [84, true], "aps.15.12": [89, true], "aps.15.13": [83, true], "aps.15.14": [86, true], "aps.15.15": [90, true], "aps.15.16": [95, true], "aps.15.17": [179, true], "aps.15.18": [165, true], "aps.15.19": [153, true], "aps.15.20": [45, true], "aps.15.21": [86, true], "aps.15.22": [62, true], "aps.15.23": [170, true], "aps.15.24": [79, true], "aps.15.25": [89, true], "aps.15.26": [67, true], "aps.15.27": [106, true], "aps.15.28": [81, true], "aps.15.29": [79, true], "aps.15.30": [74, true]}}, "CHA": {"total": 4318, "solved": 39, "n": 45, "over": 5, "per": {"fun1.1": [154, true], "fun1.2": [76, true], "fun1.3": [127, true], "fun1.4": [91, true], "fun1.5": [109, true], "fun2.1": [72, true], "fun2.2": [67, true], "fun2.3": [200, false], "fun2.4": [108, true], "fun2.5": [146, true], "fun3.1": [63, true], "fun3.2": [69, true], "fun3.3": [84, true], "fun3.4": [94, true], "fun3.5": [109, true], "fun4.1": [55, true], "fun4.2": [58, true], "fun4.3": [76, true], "fun4.4": [82, true], "fun4.5": [96, true], "fun5.1": [50, true], "fun5.2": [55, true], "fun5.3": [54, true], "fun5.4": [56, true], "fun5.5": [57, true], "fun6.1": [47, true], "fun6.2": [48, true], "fun6.3": [51, true], "fun6.4": [53, true], "fun6.5": [54, true], "fun7.1": [10, false], "fun7.2": [12, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [20, false], "fun8.1": [79, true], "fun8.2": [37, true], "fun8.3": [87, true], "fun8.4": [84, true], "fun8.5": [84, true], "fun9.1": [124, true], "fun9.2": [75, true], "fun9.3": [97, true], "fun9.4": [104, true], "fun9.5": [86, true]}}}, {"label": "pure.ratio.start.bracket", "spec": ["pure", "ratio", "start", "bracket"], "APS": {"total": 10612, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [66, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [67, true], "aps.04.01": [69, true], "aps.04.02": [68, true], "aps.04.03": [69, true], "aps.04.04": [69, true], "aps.04.05": [69, true], "aps.04.06": [68, true], "aps.04.07": [68, true], "aps.04.08": [69, true], "aps.04.09": [67, true], "aps.04.10": [63, true], "aps.04.11": [63, true], "aps.04.12": [64, true], "aps.04.13": [64, true], "aps.05.00": [66, true], "aps.06.00": [67, true], "aps.06.01": [66, true], "aps.06.02": [67, true], "aps.06.03": [67, true], "aps.06.04": [67, true], "aps.06.05": [68, true], "aps.06.06": [70, true], "aps.06.07": [71, true], "aps.06.08": [70, true], "aps.06.09": [71, true], "aps.07.00": [67, true], "aps.07.01": [67, true], "aps.07.02": [67, true], "aps.08.00": [3, true], "aps.08.01": [67, true], "aps.08.02": [68, true], "aps.08.03": [68, true], "aps.08.04": [67, true], "aps.09.00": [66, true], "aps.09.01": [66, true], "aps.09.02": [66, true], "aps.09.03": [63, true], "aps.09.04": [65, true], "aps.09.05": [64, true], "aps.09.06": [64, true], "aps.10.00": [67, true], "aps.10.01": [67, true], "aps.10.02": [66, true], "aps.10.03": [64, true], "aps.10.04": [62, true], "aps.11.00": [60, true], "aps.11.01": [68, true], "aps.11.02": [67, true], "aps.11.03": [67, true], "aps.12.00": [72, true], "aps.12.01": [73, true], "aps.12.02": [72, true], "aps.12.03": [75, true], "aps.12.04": [74, true], "aps.12.05": [75, true], "aps.12.06": [74, true], "aps.12.07": [72, true], "aps.12.08": [74, true], "aps.12.09": [73, true], "aps.12.10": [73, true], "aps.12.11": [72, true], "aps.12.12": [73, true], "aps.12.13": [74, true], "aps.12.14": [74, true], "aps.12.15": [73, true], "aps.12.16": [73, true], "aps.12.17": [72, true], "aps.12.18": [71, true], "aps.13.00": [10, false], "aps.14.00": [72, true], "aps.14.01": [72, true], "aps.14.02": [72, true], "aps.14.03": [72, true], "aps.14.04": [72, true], "aps.14.05": [72, true], "aps.14.06": [72, true], "aps.14.07": [72, true], "aps.14.08": [72, true], "aps.14.09": [72, true], "aps.14.10": [72, true], "aps.14.11": [72, true], "aps.14.12": [72, true], "aps.14.13": [72, true], "aps.14.14": [72, true], "aps.14.15": [72, true], "aps.14.16": [72, true], "aps.14.17": [72, true], "aps.14.18": [72, true], "aps.14.19": [72, true], "aps.14.20": [72, true], "aps.14.21": [72, true], "aps.14.22": [72, true], "aps.14.23": [72, true], "aps.14.24": [72, true], "aps.14.25": [72, true], "aps.14.26": [72, true], "aps.14.27": [72, true], "aps.14.28": [72, true], "aps.14.29": [72, true], "aps.14.30": [72, true], "aps.14.31": [72, true], "aps.14.32": [72, true], "aps.14.33": [72, true], "aps.14.34": [72, true], "aps.14.35": [72, true], "aps.14.36": [72, true], "aps.14.37": [72, true], "aps.14.38": [72, true], "aps.14.39": [72, true], "aps.15.00": [76, true], "aps.15.01": [76, true], "aps.15.02": [76, true], "aps.15.03": [75, true], "aps.15.04": [76, true], "aps.15.05": [76, true], "aps.15.06": [74, true], "aps.15.07": [74, true], "aps.15.08": [71, true], "aps.15.09": [70, true], "aps.15.10": [68, true], "aps.15.11": [72, true], "aps.15.12": [74, true], "aps.15.13": [74, true], "aps.15.14": [74, true], "aps.15.15": [76, true], "aps.15.16": [76, true], "aps.15.17": [76, true], "aps.15.18": [75, true], "aps.15.19": [75, true], "aps.15.20": [77, true], "aps.15.21": [73, true], "aps.15.22": [74, true], "aps.15.23": [71, true], "aps.15.24": [67, true], "aps.15.25": [73, true], "aps.15.26": [74, true], "aps.15.27": [71, true], "aps.15.28": [71, true], "aps.15.29": [69, true], "aps.15.30": [67, true]}}, "CHA": {"total": 3769, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [63, true], "fun1.2": [64, true], "fun1.3": [72, true], "fun1.4": [76, true], "fun1.5": [93, true], "fun2.1": [58, true], "fun2.2": [90, true], "fun2.3": [106, true], "fun2.4": [125, true], "fun2.5": [132, true], "fun3.1": [58, true], "fun3.2": [61, true], "fun3.3": [72, true], "fun3.4": [79, true], "fun3.5": [93, true], "fun4.1": [53, true], "fun4.2": [56, true], "fun4.3": [67, true], "fun4.4": [73, true], "fun4.5": [87, true], "fun5.1": [51, true], "fun5.2": [50, true], "fun5.3": [51, true], "fun5.4": [53, true], "fun5.5": [54, true], "fun6.1": [47, true], "fun6.2": [47, true], "fun6.3": [48, true], "fun6.4": [51, true], "fun6.5": [52, true], "fun7.1": [10, false], "fun7.2": [9, false], "fun7.3": [9, false], "fun7.4": [12, false], "fun7.5": [16, false], "fun8.1": [64, true], "fun8.2": [68, true], "fun8.3": [70, true], "fun8.4": [70, true], "fun8.5": [72, true], "fun9.1": [66, true], "fun9.2": [65, true], "fun9.3": [69, true], "fun9.4": [71, true], "fun9.5": [72, true]}}}, {"label": "pure.ratio.start.credit", "spec": ["pure", "ratio", "start", "credit"], "APS": {"total": 7680, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [8, false], "fun7.4": [12, false], "fun7.5": [10, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.rat_sq.bracket.step", "spec": ["pure", "rat_sq", "bracket", "step"], "APS": {"total": 14712, "solved": 153, "n": 154, "over": 71, "per": {"aps.01.00": [93, true], "aps.02.00": [99, true], "aps.02.01": [96, true], "aps.02.02": [95, true], "aps.02.03": [91, true], "aps.02.04": [98, true], "aps.02.05": [99, true], "aps.02.06": [101, true], "aps.02.07": [102, true], "aps.02.08": [100, true], "aps.02.09": [105, true], "aps.03.00": [100, true], "aps.03.01": [97, true], "aps.03.02": [99, true], "aps.04.00": [90, true], "aps.04.01": [99, true], "aps.04.02": [91, true], "aps.04.03": [95, true], "aps.04.04": [101, true], "aps.04.05": [97, true], "aps.04.06": [97, true], "aps.04.07": [98, true], "aps.04.08": [96, true], "aps.04.09": [96, true], "aps.04.10": [99, true], "aps.04.11": [97, true], "aps.04.12": [92, true], "aps.04.13": [92, true], "aps.05.00": [96, true], "aps.06.00": [92, true], "aps.06.01": [96, true], "aps.06.02": [97, true], "aps.06.03": [97, true], "aps.06.04": [97, true], "aps.06.05": [92, true], "aps.06.06": [92, true], "aps.06.07": [93, true], "aps.06.08": [92, true], "aps.06.09": [93, true], "aps.07.00": [91, true], "aps.07.01": [90, true], "aps.07.02": [80, true], "aps.08.00": [3, true], "aps.08.01": [87, true], "aps.08.02": [95, true], "aps.08.03": [85, true], "aps.08.04": [95, true], "aps.09.00": [97, true], "aps.09.01": [97, true], "aps.09.02": [89, true], "aps.09.03": [78, true], "aps.09.04": [82, true], "aps.09.05": [78, true], "aps.09.06": [63, true], "aps.10.00": [86, true], "aps.10.01": [84, true], "aps.10.02": [91, true], "aps.10.03": [94, true], "aps.10.04": [95, true], "aps.11.00": [92, true], "aps.11.01": [94, true], "aps.11.02": [94, true], "aps.11.03": [96, true], "aps.12.00": [108, true], "aps.12.01": [108, true], "aps.12.02": [105, true], "aps.12.03": [96, true], "aps.12.04": [97, true], "aps.12.05": [105, true], "aps.12.06": [111, true], "aps.12.07": [111, true], "aps.12.08": [107, true], "aps.12.09": [111, true], "aps.12.10": [109, true], "aps.12.11": [106, true], "aps.12.12": [115, true], "aps.12.13": [110, true], "aps.12.14": [105, true], "aps.12.15": [110, true], "aps.12.16": [103, true], "aps.12.17": [104, true], "aps.12.18": [105, true], "aps.13.00": [10, false], "aps.14.00": [104, true], "aps.14.01": [104, true], "aps.14.02": [104, true], "aps.14.03": [104, true], "aps.14.04": [104, true], "aps.14.05": [104, true], "aps.14.06": [104, true], "aps.14.07": [104, true], "aps.14.08": [104, true], "aps.14.09": [104, true], "aps.14.10": [104, true], "aps.14.11": [104, true], "aps.14.12": [104, true], "aps.14.13": [104, true], "aps.14.14": [104, true], "aps.14.15": [104, true], "aps.14.16": [104, true], "aps.14.17": [104, true], "aps.14.18": [104, true], "aps.14.19": [104, true], "aps.14.20": [104, true], "aps.14.21": [104, true], "aps.14.22": [104, true], "aps.14.23": [104, true], "aps.14.24": [104, true], "aps.14.25": [104, true], "aps.14.26": [104, true], "aps.14.27": [104, true], "aps.14.28": [104, true], "aps.14.29": [104, true], "aps.14.30": [104, true], "aps.14.31": [104, true], "aps.14.32": [104, true], "aps.14.33": [104, true], "aps.14.34": [104, true], "aps.14.35": [104, true], "aps.14.36": [104, true], "aps.14.37": [104, true], "aps.14.38": [104, true], "aps.14.39": [104, true], "aps.15.00": [88, true], "aps.15.01": [89, true], "aps.15.02": [87, true], "aps.15.03": [82, true], "aps.15.04": [87, true], "aps.15.05": [87, true], "aps.15.06": [89, true], "aps.15.07": [87, true], "aps.15.08": [72, true], "aps.15.09": [86, true], "aps.15.10": [77, true], "aps.15.11": [77, true], "aps.15.12": [86, true], "aps.15.13": [87, true], "aps.15.14": [90, true], "aps.15.15": [90, true], "aps.15.16": [89, true], "aps.15.17": [88, true], "aps.15.18": [80, true], "aps.15.19": [79, true], "aps.15.20": [85, true], "aps.15.21": [82, true], "aps.15.22": [74, true], "aps.15.23": [72, true], "aps.15.24": [79, true], "aps.15.25": [72, true], "aps.15.26": [74, true], "aps.15.27": [70, true], "aps.15.28": [77, true], "aps.15.29": [84, true], "aps.15.30": [72, true]}}, "CHA": {"total": 4606, "solved": 40, "n": 45, "over": 14, "per": {"fun1.1": [90, true], "fun1.2": [101, true], "fun1.3": [102, true], "fun1.4": [99, true], "fun1.5": [123, true], "fun2.1": [96, true], "fun2.2": [101, true], "fun2.3": [111, true], "fun2.4": [127, true], "fun2.5": [127, true], "fun3.1": [78, true], "fun3.2": [79, true], "fun3.3": [85, true], "fun3.4": [93, true], "fun3.5": [108, true], "fun4.1": [74, true], "fun4.2": [76, true], "fun4.3": [85, true], "fun4.4": [84, true], "fun4.5": [97, true], "fun5.1": [85, true], "fun5.2": [71, true], "fun5.3": [70, true], "fun5.4": [72, true], "fun5.5": [73, true], "fun6.1": [49, true], "fun6.2": [52, true], "fun6.3": [57, true], "fun6.4": [62, true], "fun6.5": [64, true], "fun7.1": [10, false], "fun7.2": [57, false], "fun7.3": [15, false], "fun7.4": [20, false], "fun7.5": [18, false], "fun8.1": [94, true], "fun8.2": [100, true], "fun8.3": [102, true], "fun8.4": [110, true], "fun8.5": [112, true], "fun9.1": [95, true], "fun9.2": [97, true], "fun9.3": [100, true], "fun9.4": [103, true], "fun9.5": [102, true]}}}, {"label": "pure.ratio.start.safe", "spec": ["pure", "ratio", "start", "safe"], "APS": {"total": 11677, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [80, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [50, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [76, true], "aps.04.04": [88, true], "aps.04.05": [44, true], "aps.04.06": [88, true], "aps.04.07": [89, true], "aps.04.08": [39, true], "aps.04.09": [80, true], "aps.04.10": [76, true], "aps.04.11": [73, true], "aps.04.12": [76, true], "aps.04.13": [74, true], "aps.05.00": [84, true], "aps.06.00": [18, true], "aps.06.01": [82, true], "aps.06.02": [20, true], "aps.06.03": [75, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [71, true], "aps.06.08": [82, true], "aps.06.09": [82, true], "aps.07.00": [44, true], "aps.07.01": [49, true], "aps.07.02": [82, true], "aps.08.00": [3, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [74, true], "aps.09.00": [32, true], "aps.09.01": [33, true], "aps.09.02": [83, true], "aps.09.03": [74, true], "aps.09.04": [81, true], "aps.09.05": [71, true], "aps.09.06": [32, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [76, true], "aps.10.03": [71, true], "aps.10.04": [76, true], "aps.11.00": [71, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [35, true], "aps.12.03": [82, true], "aps.12.04": [49, true], "aps.12.05": [86, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [50, true], "aps.12.11": [45, true], "aps.12.12": [40, true], "aps.12.13": [35, true], "aps.12.14": [32, true], "aps.12.15": [27, true], "aps.12.16": [38, true], "aps.12.17": [45, true], "aps.12.18": [51, true], "aps.13.00": [10, false], "aps.14.00": [86, true], "aps.14.01": [86, true], "aps.14.02": [86, true], "aps.14.03": [86, true], "aps.14.04": [86, true], "aps.14.05": [86, true], "aps.14.06": [86, true], "aps.14.07": [86, true], "aps.14.08": [86, true], "aps.14.09": [86, true], "aps.14.10": [86, true], "aps.14.11": [86, true], "aps.14.12": [86, true], "aps.14.13": [86, true], "aps.14.14": [86, true], "aps.14.15": [86, true], "aps.14.16": [86, true], "aps.14.17": [86, true], "aps.14.18": [86, true], "aps.14.19": [86, true], "aps.14.20": [86, true], "aps.14.21": [86, true], "aps.14.22": [86, true], "aps.14.23": [86, true], "aps.14.24": [86, true], "aps.14.25": [86, true], "aps.14.26": [86, true], "aps.14.27": [86, true], "aps.14.28": [86, true], "aps.14.29": [86, true], "aps.14.30": [86, true], "aps.14.31": [86, true], "aps.14.32": [86, true], "aps.14.33": [86, true], "aps.14.34": [86, true], "aps.14.35": [86, true], "aps.14.36": [86, true], "aps.14.37": [86, true], "aps.14.38": [86, true], "aps.14.39": [86, true], "aps.15.00": [103, true], "aps.15.01": [103, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [92, true], "aps.15.05": [88, true], "aps.15.06": [88, true], "aps.15.07": [87, true], "aps.15.08": [82, true], "aps.15.09": [81, true], "aps.15.10": [82, true], "aps.15.11": [84, true], "aps.15.12": [89, true], "aps.15.13": [83, true], "aps.15.14": [86, true], "aps.15.15": [90, true], "aps.15.16": [95, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [45, true], "aps.15.21": [86, true], "aps.15.22": [62, true], "aps.15.23": [103, true], "aps.15.24": [79, true], "aps.15.25": [89, true], "aps.15.26": [67, true], "aps.15.27": [103, true], "aps.15.28": [81, true], "aps.15.29": [79, true], "aps.15.30": [74, true]}}, "CHA": {"total": 4078, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [76, true], "fun1.3": [97, true], "fun1.4": [91, true], "fun1.5": [109, true], "fun2.1": [72, true], "fun2.2": [67, true], "fun2.3": [122, true], "fun2.4": [108, true], "fun2.5": [146, true], "fun3.1": [63, true], "fun3.2": [69, true], "fun3.3": [84, true], "fun3.4": [94, true], "fun3.5": [109, true], "fun4.1": [55, true], "fun4.2": [58, true], "fun4.3": [76, true], "fun4.4": [82, true], "fun4.5": [96, true], "fun5.1": [50, true], "fun5.2": [55, true], "fun5.3": [54, true], "fun5.4": [56, true], "fun5.5": [57, true], "fun6.1": [47, true], "fun6.2": [48, true], "fun6.3": [51, true], "fun6.4": [53, true], "fun6.5": [54, true], "fun7.1": [10, false], "fun7.2": [12, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [20, false], "fun8.1": [79, true], "fun8.2": [37, true], "fun8.3": [87, true], "fun8.4": [84, true], "fun8.5": [84, true], "fun9.1": [82, true], "fun9.2": [75, true], "fun9.3": [91, true], "fun9.4": [92, true], "fun9.5": [86, true]}}}, {"label": "pure.ratio.start.project", "spec": ["pure", "ratio", "start", "project"], "APS": {"total": 12971, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [50, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [89, true], "aps.04.08": [39, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [89, true], "aps.04.12": [89, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [18, true], "aps.06.01": [82, true], "aps.06.02": [20, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [83, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [82, true], "aps.07.00": [44, true], "aps.07.01": [49, true], "aps.07.02": [82, true], "aps.08.00": [3, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [32, true], "aps.09.01": [33, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [83, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [83, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [35, true], "aps.12.03": [97, true], "aps.12.04": [49, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [50, true], "aps.12.11": [45, true], "aps.12.12": [40, true], "aps.12.13": [35, true], "aps.12.14": [32, true], "aps.12.15": [27, true], "aps.12.16": [38, true], "aps.12.17": [45, true], "aps.12.18": [51, true], "aps.13.00": [52, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [103, true], "aps.15.01": [103, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [102, true], "aps.15.05": [102, true], "aps.15.06": [103, true], "aps.15.07": [102, true], "aps.15.08": [103, true], "aps.15.09": [103, true], "aps.15.10": [102, true], "aps.15.11": [103, true], "aps.15.12": [103, true], "aps.15.13": [103, true], "aps.15.14": [102, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [45, true], "aps.15.21": [102, true], "aps.15.22": [62, true], "aps.15.23": [103, true], "aps.15.24": [102, true], "aps.15.25": [102, true], "aps.15.26": [102, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [102, true], "aps.15.30": [103, true]}}, "CHA": {"total": 5029, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [82, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [83, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [106, true], "fun2.5": [163, true], "fun3.1": [88, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [52, false], "fun7.2": [51, false], "fun7.3": [54, false], "fun7.4": [57, false], "fun7.5": [59, false], "fun8.1": [85, true], "fun8.2": [37, true], "fun8.3": [91, true], "fun8.4": [92, true], "fun8.5": [97, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.ratio.bracket.bracket", "spec": ["pure", "ratio", "bracket", "bracket"], "APS": {"total": 4816, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [26, true], "aps.02.00": [25, true], "aps.02.01": [22, true], "aps.02.02": [27, true], "aps.02.03": [29, true], "aps.02.04": [36, true], "aps.02.05": [47, true], "aps.02.06": [26, true], "aps.02.07": [33, true], "aps.02.08": [36, true], "aps.02.09": [29, true], "aps.03.00": [27, true], "aps.03.01": [22, true], "aps.03.02": [21, true], "aps.04.00": [38, true], "aps.04.01": [25, true], "aps.04.02": [44, true], "aps.04.03": [32, true], "aps.04.04": [31, true], "aps.04.05": [26, true], "aps.04.06": [25, true], "aps.04.07": [33, true], "aps.04.08": [39, true], "aps.04.09": [34, true], "aps.04.10": [23, true], "aps.04.11": [36, true], "aps.04.12": [38, true], "aps.04.13": [31, true], "aps.05.00": [28, true], "aps.06.00": [26, true], "aps.06.01": [20, true], "aps.06.02": [36, true], "aps.06.03": [21, true], "aps.06.04": [22, true], "aps.06.05": [19, true], "aps.06.06": [21, true], "aps.06.07": [29, true], "aps.06.08": [22, true], "aps.06.09": [33, true], "aps.07.00": [36, true], "aps.07.01": [35, true], "aps.07.02": [35, true], "aps.08.00": [3, true], "aps.08.01": [20, true], "aps.08.02": [36, true], "aps.08.03": [30, true], "aps.08.04": [32, true], "aps.09.00": [36, true], "aps.09.01": [36, true], "aps.09.02": [41, true], "aps.09.03": [19, true], "aps.09.04": [25, true], "aps.09.05": [27, true], "aps.09.06": [24, true], "aps.10.00": [34, true], "aps.10.01": [22, true], "aps.10.02": [21, true], "aps.10.03": [33, true], "aps.10.04": [31, true], "aps.11.00": [11, true], "aps.11.01": [33, true], "aps.11.02": [30, true], "aps.11.03": [35, true], "aps.12.00": [33, true], "aps.12.01": [26, true], "aps.12.02": [25, true], "aps.12.03": [25, true], "aps.12.04": [19, true], "aps.12.05": [48, true], "aps.12.06": [23, true], "aps.12.07": [21, true], "aps.12.08": [26, true], "aps.12.09": [21, true], "aps.12.10": [18, true], "aps.12.11": [34, true], "aps.12.12": [22, true], "aps.12.13": [36, true], "aps.12.14": [24, true], "aps.12.15": [29, true], "aps.12.16": [49, true], "aps.12.17": [20, true], "aps.12.18": [22, true], "aps.13.00": [10, false], "aps.14.00": [41, true], "aps.14.01": [41, true], "aps.14.02": [41, true], "aps.14.03": [41, true], "aps.14.04": [41, true], "aps.14.05": [41, true], "aps.14.06": [41, true], "aps.14.07": [41, true], "aps.14.08": [41, true], "aps.14.09": [41, true], "aps.14.10": [41, true], "aps.14.11": [41, true], "aps.14.12": [41, true], "aps.14.13": [41, true], "aps.14.14": [41, true], "aps.14.15": [41, true], "aps.14.16": [41, true], "aps.14.17": [41, true], "aps.14.18": [41, true], "aps.14.19": [41, true], "aps.14.20": [41, true], "aps.14.21": [41, true], "aps.14.22": [41, true], "aps.14.23": [41, true], "aps.14.24": [41, true], "aps.14.25": [41, true], "aps.14.26": [41, true], "aps.14.27": [41, true], "aps.14.28": [41, true], "aps.14.29": [41, true], "aps.14.30": [41, true], "aps.14.31": [41, true], "aps.14.32": [41, true], "aps.14.33": [41, true], "aps.14.34": [41, true], "aps.14.35": [41, true], "aps.14.36": [41, true], "aps.14.37": [41, true], "aps.14.38": [41, true], "aps.14.39": [41, true], "aps.15.00": [18, true], "aps.15.01": [20, true], "aps.15.02": [22, true], "aps.15.03": [25, true], "aps.15.04": [27, true], "aps.15.05": [27, true], "aps.15.06": [22, true], "aps.15.07": [21, true], "aps.15.08": [20, true], "aps.15.09": [19, true], "aps.15.10": [18, true], "aps.15.11": [17, true], "aps.15.12": [16, true], "aps.15.13": [15, true], "aps.15.14": [13, true], "aps.15.15": [14, true], "aps.15.16": [15, true], "aps.15.17": [16, true], "aps.15.18": [17, true], "aps.15.19": [18, true], "aps.15.20": [19, true], "aps.15.21": [18, true], "aps.15.22": [27, true], "aps.15.23": [18, true], "aps.15.24": [30, true], "aps.15.25": [19, true], "aps.15.26": [23, true], "aps.15.27": [24, true], "aps.15.28": [30, true], "aps.15.29": [24, true], "aps.15.30": [20, true]}}, "CHA": {"total": 3286, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [19, true], "fun1.2": [26, true], "fun1.3": [36, true], "fun1.4": [55, true], "fun1.5": [59, true], "fun2.1": [20, true], "fun2.2": [63, true], "fun2.3": [66, true], "fun2.4": [58, true], "fun2.5": [66, true], "fun3.1": [53, true], "fun3.2": [60, true], "fun3.3": [73, true], "fun3.4": [80, true], "fun3.5": [92, true], "fun4.1": [80, true], "fun4.2": [84, true], "fun4.3": [98, true], "fun4.4": [101, true], "fun4.5": [99, true], "fun5.1": [75, true], "fun5.2": [69, true], "fun5.3": [74, true], "fun5.4": [78, true], "fun5.5": [80, true], "fun6.1": [61, true], "fun6.2": [66, true], "fun6.3": [64, true], "fun6.4": [69, true], "fun6.5": [69, true], "fun7.1": [10, false], "fun7.2": [8, false], "fun7.3": [11, false], "fun7.4": [28, false], "fun7.5": [12, false], "fun8.1": [22, true], "fun8.2": [24, true], "fun8.3": [25, true], "fun8.4": [32, true], "fun8.5": [43, true], "fun9.1": [13, true], "fun9.2": [26, true], "fun9.3": [24, true], "fun9.4": [35, true], "fun9.5": [49, true]}}}, {"label": "pure.ratio.bracket.both", "spec": ["pure", "ratio", "bracket", "both"], "APS": {"total": 4870, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [26, true], "aps.02.00": [19, true], "aps.02.01": [22, true], "aps.02.02": [27, true], "aps.02.03": [29, true], "aps.02.04": [35, true], "aps.02.05": [35, true], "aps.02.06": [23, true], "aps.02.07": [16, true], "aps.02.08": [25, true], "aps.02.09": [36, true], "aps.03.00": [25, true], "aps.03.01": [21, true], "aps.03.02": [20, true], "aps.04.00": [37, true], "aps.04.01": [26, true], "aps.04.02": [44, true], "aps.04.03": [32, true], "aps.04.04": [31, true], "aps.04.05": [25, true], "aps.04.06": [25, true], "aps.04.07": [32, true], "aps.04.08": [38, true], "aps.04.09": [34, true], "aps.04.10": [23, true], "aps.04.11": [35, true], "aps.04.12": [37, true], "aps.04.13": [31, true], "aps.05.00": [26, true], "aps.06.00": [26, true], "aps.06.01": [20, true], "aps.06.02": [36, true], "aps.06.03": [21, true], "aps.06.04": [22, true], "aps.06.05": [19, true], "aps.06.06": [21, true], "aps.06.07": [29, true], "aps.06.08": [22, true], "aps.06.09": [33, true], "aps.07.00": [36, true], "aps.07.01": [35, true], "aps.07.02": [35, true], "aps.08.00": [3, true], "aps.08.01": [20, true], "aps.08.02": [30, true], "aps.08.03": [30, true], "aps.08.04": [32, true], "aps.09.00": [36, true], "aps.09.01": [36, true], "aps.09.02": [41, true], "aps.09.03": [19, true], "aps.09.04": [25, true], "aps.09.05": [27, true], "aps.09.06": [24, true], "aps.10.00": [34, true], "aps.10.01": [22, true], "aps.10.02": [21, true], "aps.10.03": [33, true], "aps.10.04": [31, true], "aps.11.00": [11, true], "aps.11.01": [33, true], "aps.11.02": [30, true], "aps.11.03": [35, true], "aps.12.00": [33, true], "aps.12.01": [26, true], "aps.12.02": [25, true], "aps.12.03": [25, true], "aps.12.04": [19, true], "aps.12.05": [19, true], "aps.12.06": [30, true], "aps.12.07": [38, true], "aps.12.08": [28, true], "aps.12.09": [18, true], "aps.12.10": [41, true], "aps.12.11": [46, true], "aps.12.12": [45, true], "aps.12.13": [19, true], "aps.12.14": [24, true], "aps.12.15": [29, true], "aps.12.16": [49, true], "aps.12.17": [20, true], "aps.12.18": [22, true], "aps.13.00": [10, false], "aps.14.00": [37, true], "aps.14.01": [37, true], "aps.14.02": [37, true], "aps.14.03": [37, true], "aps.14.04": [37, true], "aps.14.05": [37, true], "aps.14.06": [37, true], "aps.14.07": [37, true], "aps.14.08": [37, true], "aps.14.09": [37, true], "aps.14.10": [37, true], "aps.14.11": [37, true], "aps.14.12": [37, true], "aps.14.13": [37, true], "aps.14.14": [37, true], "aps.14.15": [37, true], "aps.14.16": [37, true], "aps.14.17": [37, true], "aps.14.18": [37, true], "aps.14.19": [37, true], "aps.14.20": [37, true], "aps.14.21": [37, true], "aps.14.22": [37, true], "aps.14.23": [37, true], "aps.14.24": [37, true], "aps.14.25": [37, true], "aps.14.26": [37, true], "aps.14.27": [37, true], "aps.14.28": [37, true], "aps.14.29": [37, true], "aps.14.30": [37, true], "aps.14.31": [37, true], "aps.14.32": [37, true], "aps.14.33": [37, true], "aps.14.34": [37, true], "aps.14.35": [37, true], "aps.14.36": [37, true], "aps.14.37": [37, true], "aps.14.38": [37, true], "aps.14.39": [37, true], "aps.15.00": [17, true], "aps.15.01": [19, true], "aps.15.02": [21, true], "aps.15.03": [24, true], "aps.15.04": [26, true], "aps.15.05": [26, true], "aps.15.06": [30, true], "aps.15.07": [33, true], "aps.15.08": [34, true], "aps.15.09": [26, true], "aps.15.10": [41, true], "aps.15.11": [32, true], "aps.15.12": [26, true], "aps.15.13": [28, true], "aps.15.14": [35, true], "aps.15.15": [35, true], "aps.15.16": [37, true], "aps.15.17": [32, true], "aps.15.18": [29, true], "aps.15.19": [27, true], "aps.15.20": [24, true], "aps.15.21": [30, true], "aps.15.22": [28, true], "aps.15.23": [34, true], "aps.15.24": [32, true], "aps.15.25": [21, true], "aps.15.26": [26, true], "aps.15.27": [26, true], "aps.15.28": [24, true], "aps.15.29": [26, true], "aps.15.30": [22, true]}}, "CHA": {"total": 3139, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [19, true], "fun1.2": [26, true], "fun1.3": [36, true], "fun1.4": [47, true], "fun1.5": [59, true], "fun2.1": [18, true], "fun2.2": [63, true], "fun2.3": [62, true], "fun2.4": [58, true], "fun2.5": [56, true], "fun3.1": [53, true], "fun3.2": [60, true], "fun3.3": [71, true], "fun3.4": [75, true], "fun3.5": [87, true], "fun4.1": [80, true], "fun4.2": [84, true], "fun4.3": [65, true], "fun4.4": [79, true], "fun4.5": [93, true], "fun5.1": [67, true], "fun5.2": [66, true], "fun5.3": [68, true], "fun5.4": [71, true], "fun5.5": [73, true], "fun6.1": [57, true], "fun6.2": [54, true], "fun6.3": [52, true], "fun6.4": [58, true], "fun6.5": [58, true], "fun7.1": [10, false], "fun7.2": [8, false], "fun7.3": [11, false], "fun7.4": [25, false], "fun7.5": [12, false], "fun8.1": [36, true], "fun8.2": [24, true], "fun8.3": [25, true], "fun8.4": [23, true], "fun8.5": [43, true], "fun9.1": [19, true], "fun9.2": [25, true], "fun9.3": [45, true], "fun9.4": [35, true], "fun9.5": [49, true]}}}, {"label": "pure.ratio.bracket.step", "spec": ["pure", "ratio", "bracket", "step"], "APS": {"total": 7019, "solved": 153, "n": 154, "over": 12, "per": {"aps.01.00": [37, true], "aps.02.00": [22, true], "aps.02.01": [22, true], "aps.02.02": [19, true], "aps.02.03": [43, true], "aps.02.04": [15, true], "aps.02.05": [35, true], "aps.02.06": [23, true], "aps.02.07": [16, true], "aps.02.08": [25, true], "aps.02.09": [36, true], "aps.03.00": [84, true], "aps.03.01": [48, true], "aps.03.02": [72, true], "aps.04.00": [33, true], "aps.04.01": [72, true], "aps.04.02": [90, true], "aps.04.03": [58, true], "aps.04.04": [89, true], "aps.04.05": [38, true], "aps.04.06": [56, true], "aps.04.07": [27, true], "aps.04.08": [34, true], "aps.04.09": [40, true], "aps.04.10": [43, true], "aps.04.11": [33, true], "aps.04.12": [75, true], "aps.04.13": [79, true], "aps.05.00": [26, true], "aps.06.00": [18, true], "aps.06.01": [20, true], "aps.06.02": [51, true], "aps.06.03": [13, true], "aps.06.04": [25, true], "aps.06.05": [30, true], "aps.06.06": [31, true], "aps.06.07": [49, true], "aps.06.08": [33, true], "aps.06.09": [60, true], "aps.07.00": [50, true], "aps.07.01": [49, true], "aps.07.02": [49, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [134, true], "aps.08.03": [73, true], "aps.08.04": [58, true], "aps.09.00": [32, true], "aps.09.01": [33, true], "aps.09.02": [43, true], "aps.09.03": [19, true], "aps.09.04": [25, true], "aps.09.05": [27, true], "aps.09.06": [25, true], "aps.10.00": [60, true], "aps.10.01": [127, true], "aps.10.02": [20, true], "aps.10.03": [34, true], "aps.10.04": [24, true], "aps.11.00": [44, true], "aps.11.01": [37, true], "aps.11.02": [26, true], "aps.11.03": [27, true], "aps.12.00": [21, true], "aps.12.01": [26, true], "aps.12.02": [25, true], "aps.12.03": [44, true], "aps.12.04": [36, true], "aps.12.05": [17, true], "aps.12.06": [28, true], "aps.12.07": [108, true], "aps.12.08": [114, true], "aps.12.09": [75, true], "aps.12.10": [122, true], "aps.12.11": [124, true], "aps.12.12": [129, true], "aps.12.13": [130, true], "aps.12.14": [130, true], "aps.12.15": [134, true], "aps.12.16": [132, true], "aps.12.17": [132, true], "aps.12.18": [89, true], "aps.13.00": [11, false], "aps.14.00": [37, true], "aps.14.01": [37, true], "aps.14.02": [37, true], "aps.14.03": [37, true], "aps.14.04": [37, true], "aps.14.05": [37, true], "aps.14.06": [37, true], "aps.14.07": [37, true], "aps.14.08": [37, true], "aps.14.09": [37, true], "aps.14.10": [37, true], "aps.14.11": [37, true], "aps.14.12": [37, true], "aps.14.13": [37, true], "aps.14.14": [37, true], "aps.14.15": [37, true], "aps.14.16": [37, true], "aps.14.17": [37, true], "aps.14.18": [37, true], "aps.14.19": [37, true], "aps.14.20": [37, true], "aps.14.21": [37, true], "aps.14.22": [37, true], "aps.14.23": [37, true], "aps.14.24": [37, true], "aps.14.25": [37, true], "aps.14.26": [37, true], "aps.14.27": [37, true], "aps.14.28": [37, true], "aps.14.29": [37, true], "aps.14.30": [37, true], "aps.14.31": [37, true], "aps.14.32": [37, true], "aps.14.33": [37, true], "aps.14.34": [37, true], "aps.14.35": [37, true], "aps.14.36": [37, true], "aps.14.37": [37, true], "aps.14.38": [37, true], "aps.14.39": [37, true], "aps.15.00": [17, true], "aps.15.01": [19, true], "aps.15.02": [21, true], "aps.15.03": [24, true], "aps.15.04": [26, true], "aps.15.05": [28, true], "aps.15.06": [26, true], "aps.15.07": [28, true], "aps.15.08": [30, true], "aps.15.09": [32, true], "aps.15.10": [33, true], "aps.15.11": [36, true], "aps.15.12": [38, true], "aps.15.13": [41, true], "aps.15.14": [44, true], "aps.15.15": [47, true], "aps.15.16": [52, true], "aps.15.17": [57, true], "aps.15.18": [64, true], "aps.15.19": [34, true], "aps.15.20": [28, true], "aps.15.21": [28, true], "aps.15.22": [28, true], "aps.15.23": [56, true], "aps.15.24": [32, true], "aps.15.25": [21, true], "aps.15.26": [21, true], "aps.15.27": [26, true], "aps.15.28": [32, true], "aps.15.29": [45, true], "aps.15.30": [22, true]}}, "CHA": {"total": 3919, "solved": 40, "n": 45, "over": 3, "per": {"fun1.1": [76, true], "fun1.2": [19, true], "fun1.3": [75, true], "fun1.4": [96, true], "fun1.5": [61, true], "fun2.1": [124, true], "fun2.2": [62, true], "fun2.3": [82, true], "fun2.4": [58, true], "fun2.5": [56, true], "fun3.1": [99, true], "fun3.2": [98, true], "fun3.3": [113, true], "fun3.4": [113, true], "fun3.5": [147, true], "fun4.1": [82, true], "fun4.2": [83, true], "fun4.3": [82, true], "fun4.4": [94, true], "fun4.5": [122, true], "fun5.1": [89, true], "fun5.2": [85, true], "fun5.3": [91, true], "fun5.4": [90, true], "fun5.5": [93, true], "fun6.1": [75, true], "fun6.2": [79, true], "fun6.3": [59, true], "fun6.4": [60, true], "fun6.5": [60, true], "fun7.1": [11, false], "fun7.2": [12, false], "fun7.3": [12, false], "fun7.4": [27, false], "fun7.5": [18, false], "fun8.1": [56, true], "fun8.2": [40, true], "fun8.3": [34, true], "fun8.4": [83, true], "fun8.5": [44, true], "fun9.1": [39, true], "fun9.2": [24, true], "fun9.3": [24, true], "fun9.4": [27, true], "fun9.5": [25, true]}}}, {"label": "pure.ratio.start.none", "spec": ["pure", "ratio", "start", "none"], "APS": {"total": 23489, "solved": 50, "n": 154, "over": 3, "per": {"aps.01.00": [200, false], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [50, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [55, true], "aps.04.08": [39, true], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [18, true], "aps.06.01": [55, true], "aps.06.02": [20, true], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [44, true], "aps.07.01": [49, true], "aps.07.02": [200, false], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [32, true], "aps.09.01": [33, true], "aps.09.02": [56, true], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [69, true], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [63, true], "aps.12.01": [68, true], "aps.12.02": [35, true], "aps.12.03": [151, true], "aps.12.04": [49, true], "aps.12.05": [176, true], "aps.12.06": [73, true], "aps.12.07": [65, true], "aps.12.08": [65, true], "aps.12.09": [57, true], "aps.12.10": [50, true], "aps.12.11": [45, true], "aps.12.12": [40, true], "aps.12.13": [35, true], "aps.12.14": [32, true], "aps.12.15": [27, true], "aps.12.16": [38, true], "aps.12.17": [45, true], "aps.12.18": [51, true], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [88, true], "aps.15.01": [98, true], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [45, true], "aps.15.21": [200, false], "aps.15.22": [62, true], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [106, true], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 8743, "solved": 2, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [106, true], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [37, true], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.ratio.bracket.none", "spec": ["pure", "ratio", "bracket", "none"], "APS": {"total": 12086, "solved": 123, "n": 154, "over": 10, "per": {"aps.01.00": [37, true], "aps.02.00": [200, false], "aps.02.01": [93, true], "aps.02.02": [200, false], "aps.02.03": [43, true], "aps.02.04": [139, true], "aps.02.05": [21, true], "aps.02.06": [15, true], "aps.02.07": [93, true], "aps.02.08": [116, true], "aps.02.09": [140, true], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [28, true], "aps.06.00": [18, true], "aps.06.01": [20, true], "aps.06.02": [51, true], "aps.06.03": [13, true], "aps.06.04": [25, true], "aps.06.05": [30, true], "aps.06.06": [32, true], "aps.06.07": [187, true], "aps.06.08": [33, true], "aps.06.09": [56, true], "aps.07.00": [50, true], "aps.07.01": [49, true], "aps.07.02": [49, true], "aps.08.00": [3, true], "aps.08.01": [48, true], "aps.08.02": [134, true], "aps.08.03": [186, true], "aps.08.04": [200, false], "aps.09.00": [32, true], "aps.09.01": [33, true], "aps.09.02": [43, true], "aps.09.03": [19, true], "aps.09.04": [25, true], "aps.09.05": [27, true], "aps.09.06": [200, false], "aps.10.00": [60, true], "aps.10.01": [133, true], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [21, true], "aps.12.01": [26, true], "aps.12.02": [25, true], "aps.12.03": [44, true], "aps.12.04": [36, true], "aps.12.05": [20, true], "aps.12.06": [55, true], "aps.12.07": [66, true], "aps.12.08": [72, true], "aps.12.09": [72, true], "aps.12.10": [78, true], "aps.12.11": [81, true], "aps.12.12": [85, true], "aps.12.13": [87, true], "aps.12.14": [90, true], "aps.12.15": [92, true], "aps.12.16": [95, true], "aps.12.17": [96, true], "aps.12.18": [98, true], "aps.13.00": [200, false], "aps.14.00": [39, true], "aps.14.01": [39, true], "aps.14.02": [39, true], "aps.14.03": [39, true], "aps.14.04": [39, true], "aps.14.05": [39, true], "aps.14.06": [39, true], "aps.14.07": [39, true], "aps.14.08": [39, true], "aps.14.09": [39, true], "aps.14.10": [39, true], "aps.14.11": [39, true], "aps.14.12": [39, true], "aps.14.13": [39, true], "aps.14.14": [39, true], "aps.14.15": [39, true], "aps.14.16": [39, true], "aps.14.17": [39, true], "aps.14.18": [39, true], "aps.14.19": [39, true], "aps.14.20": [39, true], "aps.14.21": [39, true], "aps.14.22": [39, true], "aps.14.23": [39, true], "aps.14.24": [39, true], "aps.14.25": [39, true], "aps.14.26": [39, true], "aps.14.27": [39, true], "aps.14.28": [39, true], "aps.14.29": [39, true], "aps.14.30": [39, true], "aps.14.31": [39, true], "aps.14.32": [39, true], "aps.14.33": [39, true], "aps.14.34": [39, true], "aps.14.35": [39, true], "aps.14.36": [39, true], "aps.14.37": [39, true], "aps.14.38": [39, true], "aps.14.39": [39, true], "aps.15.00": [18, true], "aps.15.01": [20, true], "aps.15.02": [22, true], "aps.15.03": [25, true], "aps.15.04": [27, true], "aps.15.05": [29, true], "aps.15.06": [31, true], "aps.15.07": [40, true], "aps.15.08": [49, true], "aps.15.09": [62, true], "aps.15.10": [82, true], "aps.15.11": [118, true], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [13, true], "aps.15.15": [14, true], "aps.15.16": [15, true], "aps.15.17": [16, true], "aps.15.18": [17, true], "aps.15.19": [18, true], "aps.15.20": [19, true], "aps.15.21": [31, true], "aps.15.22": [27, true], "aps.15.23": [18, true], "aps.15.24": [30, true], "aps.15.25": [68, true], "aps.15.26": [19, true], "aps.15.27": [24, true], "aps.15.28": [31, true], "aps.15.29": [43, true], "aps.15.30": [80, true]}}, "CHA": {"total": 8159, "solved": 7, "n": 45, "over": 2, "per": {"fun1.1": [76, true], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [61, true], "fun2.1": [127, true], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [58, true], "fun2.5": [66, true], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [13, true], "fun9.2": [158, true], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.ratio.derived.step", "spec": ["pure", "ratio", "derived", "step"], "APS": {"total": 3104, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [14, true], "aps.02.01": [13, true], "aps.02.02": [12, true], "aps.02.03": [18, true], "aps.02.04": [28, true], "aps.02.05": [26, true], "aps.02.06": [11, true], "aps.02.07": [20, true], "aps.02.08": [19, true], "aps.02.09": [29, true], "aps.03.00": [25, true], "aps.03.01": [15, true], "aps.03.02": [21, true], "aps.04.00": [17, true], "aps.04.01": [18, true], "aps.04.02": [24, true], "aps.04.03": [19, true], "aps.04.04": [20, true], "aps.04.05": [17, true], "aps.04.06": [17, true], "aps.04.07": [17, true], "aps.04.08": [15, true], "aps.04.09": [18, true], "aps.04.10": [16, true], "aps.04.11": [17, true], "aps.04.12": [18, true], "aps.04.13": [18, true], "aps.05.00": [10, true], "aps.06.00": [8, true], "aps.06.01": [10, true], "aps.06.02": [12, true], "aps.06.03": [11, true], "aps.06.04": [10, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [15, true], "aps.06.08": [15, true], "aps.06.09": [15, true], "aps.07.00": [12, true], "aps.07.01": [10, true], "aps.07.02": [10, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [16, true], "aps.08.04": [15, true], "aps.09.00": [11, true], "aps.09.01": [23, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [9, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [9, true], "aps.10.01": [16, true], "aps.10.02": [15, true], "aps.10.03": [17, true], "aps.10.04": [45, true], "aps.11.00": [4, true], "aps.11.01": [13, true], "aps.11.02": [17, true], "aps.11.03": [18, true], "aps.12.00": [10, true], "aps.12.01": [12, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [12, true], "aps.12.05": [13, true], "aps.12.06": [12, true], "aps.12.07": [12, true], "aps.12.08": [11, true], "aps.12.09": [10, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [33, true], "aps.15.01": [34, true], "aps.15.02": [33, true], "aps.15.03": [33, true], "aps.15.04": [37, true], "aps.15.05": [37, true], "aps.15.06": [33, true], "aps.15.07": [32, true], "aps.15.08": [31, true], "aps.15.09": [31, true], "aps.15.10": [32, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [33, true], "aps.15.15": [33, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [33, true], "aps.15.21": [34, true], "aps.15.22": [37, true], "aps.15.23": [37, true], "aps.15.24": [34, true], "aps.15.25": [35, true], "aps.15.26": [37, true], "aps.15.27": [38, true], "aps.15.28": [40, true], "aps.15.29": [36, true], "aps.15.30": [35, true]}}, "CHA": {"total": 3524, "solved": 40, "n": 45, "over": 10, "per": {"fun1.1": [9, true], "fun1.2": [14, true], "fun1.3": [19, true], "fun1.4": [21, true], "fun1.5": [69, true], "fun2.1": [11, true], "fun2.2": [29, true], "fun2.3": [32, true], "fun2.4": [45, true], "fun2.5": [50, true], "fun3.1": [85, true], "fun3.2": [88, true], "fun3.3": [108, true], "fun3.4": [117, true], "fun3.5": [141, true], "fun4.1": [94, true], "fun4.2": [99, true], "fun4.3": [116, true], "fun4.4": [131, true], "fun4.5": [156, true], "fun5.1": [102, true], "fun5.2": [100, true], "fun5.3": [96, true], "fun5.4": [102, true], "fun5.5": [105, true], "fun6.1": [74, true], "fun6.2": [89, true], "fun6.3": [86, true], "fun6.4": [93, true], "fun6.5": [87, true], "fun7.1": [10, false], "fun7.2": [13, false], "fun7.3": [11, false], "fun7.4": [10, false], "fun7.5": [8, false], "fun8.1": [12, true], "fun8.2": [13, true], "fun8.3": [13, true], "fun8.4": [18, true], "fun8.5": [21, true], "fun9.1": [10, true], "fun9.2": [12, true], "fun9.3": [15, true], "fun9.4": [20, true], "fun9.5": [22, true]}}}, {"label": "pure.ratio.bracket.project", "spec": ["pure", "ratio", "bracket", "project"], "APS": {"total": 8361, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [37, true], "aps.02.00": [86, true], "aps.02.01": [88, true], "aps.02.02": [89, true], "aps.02.03": [43, true], "aps.02.04": [91, true], "aps.02.05": [21, true], "aps.02.06": [15, true], "aps.02.07": [88, true], "aps.02.08": [92, true], "aps.02.09": [92, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [28, true], "aps.06.00": [18, true], "aps.06.01": [20, true], "aps.06.02": [51, true], "aps.06.03": [13, true], "aps.06.04": [25, true], "aps.06.05": [30, true], "aps.06.06": [32, true], "aps.06.07": [83, true], "aps.06.08": [33, true], "aps.06.09": [56, true], "aps.07.00": [50, true], "aps.07.01": [49, true], "aps.07.02": [49, true], "aps.08.00": [3, true], "aps.08.01": [81, true], "aps.08.02": [73, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [32, true], "aps.09.01": [33, true], "aps.09.02": [43, true], "aps.09.03": [19, true], "aps.09.04": [25, true], "aps.09.05": [27, true], "aps.09.06": [83, true], "aps.10.00": [60, true], "aps.10.01": [82, true], "aps.10.02": [67, true], "aps.10.03": [82, true], "aps.10.04": [83, true], "aps.11.00": [82, true], "aps.11.01": [72, true], "aps.11.02": [82, true], "aps.11.03": [82, true], "aps.12.00": [21, true], "aps.12.01": [26, true], "aps.12.02": [25, true], "aps.12.03": [44, true], "aps.12.04": [36, true], "aps.12.05": [20, true], "aps.12.06": [95, true], "aps.12.07": [91, true], "aps.12.08": [72, true], "aps.12.09": [91, true], "aps.12.10": [86, true], "aps.12.11": [96, true], "aps.12.12": [82, true], "aps.12.13": [96, true], "aps.12.14": [85, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [81, true], "aps.12.18": [96, true], "aps.13.00": [51, false], "aps.14.00": [39, true], "aps.14.01": [39, true], "aps.14.02": [39, true], "aps.14.03": [39, true], "aps.14.04": [39, true], "aps.14.05": [39, true], "aps.14.06": [39, true], "aps.14.07": [39, true], "aps.14.08": [39, true], "aps.14.09": [39, true], "aps.14.10": [39, true], "aps.14.11": [39, true], "aps.14.12": [39, true], "aps.14.13": [39, true], "aps.14.14": [39, true], "aps.14.15": [39, true], "aps.14.16": [39, true], "aps.14.17": [39, true], "aps.14.18": [39, true], "aps.14.19": [39, true], "aps.14.20": [39, true], "aps.14.21": [39, true], "aps.14.22": [39, true], "aps.14.23": [39, true], "aps.14.24": [39, true], "aps.14.25": [39, true], "aps.14.26": [39, true], "aps.14.27": [39, true], "aps.14.28": [39, true], "aps.14.29": [39, true], "aps.14.30": [39, true], "aps.14.31": [39, true], "aps.14.32": [39, true], "aps.14.33": [39, true], "aps.14.34": [39, true], "aps.14.35": [39, true], "aps.14.36": [39, true], "aps.14.37": [39, true], "aps.14.38": [39, true], "aps.14.39": [39, true], "aps.15.00": [18, true], "aps.15.01": [20, true], "aps.15.02": [22, true], "aps.15.03": [25, true], "aps.15.04": [27, true], "aps.15.05": [29, true], "aps.15.06": [31, true], "aps.15.07": [40, true], "aps.15.08": [49, true], "aps.15.09": [62, true], "aps.15.10": [82, true], "aps.15.11": [103, true], "aps.15.12": [103, true], "aps.15.13": [102, true], "aps.15.14": [13, true], "aps.15.15": [14, true], "aps.15.16": [15, true], "aps.15.17": [16, true], "aps.15.18": [17, true], "aps.15.19": [18, true], "aps.15.20": [19, true], "aps.15.21": [31, true], "aps.15.22": [27, true], "aps.15.23": [18, true], "aps.15.24": [30, true], "aps.15.25": [68, true], "aps.15.26": [19, true], "aps.15.27": [24, true], "aps.15.28": [31, true], "aps.15.29": [43, true], "aps.15.30": [80, true]}}, "CHA": {"total": 4670, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [76, true], "fun1.2": [60, true], "fun1.3": [64, true], "fun1.4": [112, true], "fun1.5": [61, true], "fun2.1": [79, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [58, true], "fun2.5": [66, true], "fun3.1": [88, true], "fun3.2": [92, true], "fun3.3": [112, true], "fun3.4": [124, true], "fun3.5": [153, true], "fun4.1": [76, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [52, false], "fun7.3": [53, false], "fun7.4": [56, false], "fun7.5": [55, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [13, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.ratio.derived.none", "spec": ["pure", "ratio", "derived", "none"], "APS": {"total": 3154, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [15, true], "aps.02.01": [12, true], "aps.02.02": [31, true], "aps.02.03": [11, true], "aps.02.04": [19, true], "aps.02.05": [11, true], "aps.02.06": [46, true], "aps.02.07": [22, true], "aps.02.08": [21, true], "aps.02.09": [20, true], "aps.03.00": [23, true], "aps.03.01": [14, true], "aps.03.02": [30, true], "aps.04.00": [28, true], "aps.04.01": [23, true], "aps.04.02": [20, true], "aps.04.03": [21, true], "aps.04.04": [24, true], "aps.04.05": [16, true], "aps.04.06": [18, true], "aps.04.07": [18, true], "aps.04.08": [16, true], "aps.04.09": [19, true], "aps.04.10": [25, true], "aps.04.11": [21, true], "aps.04.12": [20, true], "aps.04.13": [23, true], "aps.05.00": [10, true], "aps.06.00": [8, true], "aps.06.01": [10, true], "aps.06.02": [12, true], "aps.06.03": [12, true], "aps.06.04": [10, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [15, true], "aps.06.08": [15, true], "aps.06.09": [15, true], "aps.07.00": [12, true], "aps.07.01": [10, true], "aps.07.02": [10, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [15, true], "aps.08.04": [14, true], "aps.09.00": [11, true], "aps.09.01": [23, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [9, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [9, true], "aps.10.01": [16, true], "aps.10.02": [15, true], "aps.10.03": [10, true], "aps.10.04": [14, true], "aps.11.00": [20, true], "aps.11.01": [15, true], "aps.11.02": [18, true], "aps.11.03": [17, true], "aps.12.00": [10, true], "aps.12.01": [12, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [12, true], "aps.12.05": [13, true], "aps.12.06": [12, true], "aps.12.07": [12, true], "aps.12.08": [13, true], "aps.12.09": [13, true], "aps.12.10": [12, true], "aps.12.11": [12, true], "aps.12.12": [12, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [12, true], "aps.13.00": [200, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [33, true], "aps.15.01": [34, true], "aps.15.02": [33, true], "aps.15.03": [33, true], "aps.15.04": [35, true], "aps.15.05": [35, true], "aps.15.06": [33, true], "aps.15.07": [32, true], "aps.15.08": [31, true], "aps.15.09": [31, true], "aps.15.10": [32, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [33, true], "aps.15.15": [33, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [33, true], "aps.15.21": [34, true], "aps.15.22": [37, true], "aps.15.23": [37, true], "aps.15.24": [34, true], "aps.15.25": [35, true], "aps.15.26": [37, true], "aps.15.27": [38, true], "aps.15.28": [40, true], "aps.15.29": [36, true], "aps.15.30": [35, true]}}, "CHA": {"total": 5532, "solved": 20, "n": 45, "over": 0, "per": {"fun1.1": [9, true], "fun1.2": [18, true], "fun1.3": [20, true], "fun1.4": [18, true], "fun1.5": [87, true], "fun2.1": [12, true], "fun2.2": [29, true], "fun2.3": [33, true], "fun2.4": [45, true], "fun2.5": [50, true], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [7, false], "fun8.1": [10, true], "fun8.2": [13, true], "fun8.3": [16, true], "fun8.4": [19, true], "fun8.5": [21, true], "fun9.1": [10, true], "fun9.2": [10, true], "fun9.3": [26, true], "fun9.4": [45, true], "fun9.5": [41, true]}}}, {"label": "pure.ratio.start.both", "spec": ["pure", "ratio", "start", "both"], "APS": {"total": 9808, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [58, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [62, true], "aps.04.01": [64, true], "aps.04.02": [63, true], "aps.04.03": [62, true], "aps.04.04": [62, true], "aps.04.05": [62, true], "aps.04.06": [61, true], "aps.04.07": [63, true], "aps.04.08": [64, true], "aps.04.09": [60, true], "aps.04.10": [55, true], "aps.04.11": [56, true], "aps.04.12": [59, true], "aps.04.13": [57, true], "aps.05.00": [59, true], "aps.06.00": [63, true], "aps.06.01": [61, true], "aps.06.02": [61, true], "aps.06.03": [60, true], "aps.06.04": [57, true], "aps.06.05": [63, true], "aps.06.06": [63, true], "aps.06.07": [67, true], "aps.06.08": [63, true], "aps.06.09": [63, true], "aps.07.00": [60, true], "aps.07.01": [58, true], "aps.07.02": [62, true], "aps.08.00": [3, true], "aps.08.01": [60, true], "aps.08.02": [64, true], "aps.08.03": [62, true], "aps.08.04": [61, true], "aps.09.00": [61, true], "aps.09.01": [61, true], "aps.09.02": [58, true], "aps.09.03": [55, true], "aps.09.04": [58, true], "aps.09.05": [55, true], "aps.09.06": [61, true], "aps.10.00": [61, true], "aps.10.01": [60, true], "aps.10.02": [58, true], "aps.10.03": [59, true], "aps.10.04": [57, true], "aps.11.00": [54, true], "aps.11.01": [61, true], "aps.11.02": [59, true], "aps.11.03": [59, true], "aps.12.00": [69, true], "aps.12.01": [69, true], "aps.12.02": [64, true], "aps.12.03": [68, true], "aps.12.04": [65, true], "aps.12.05": [67, true], "aps.12.06": [67, true], "aps.12.07": [67, true], "aps.12.08": [66, true], "aps.12.09": [63, true], "aps.12.10": [63, true], "aps.12.11": [67, true], "aps.12.12": [69, true], "aps.12.13": [64, true], "aps.12.14": [67, true], "aps.12.15": [66, true], "aps.12.16": [69, true], "aps.12.17": [67, true], "aps.12.18": [70, true], "aps.13.00": [9, false], "aps.14.00": [67, true], "aps.14.01": [67, true], "aps.14.02": [67, true], "aps.14.03": [67, true], "aps.14.04": [67, true], "aps.14.05": [67, true], "aps.14.06": [67, true], "aps.14.07": [67, true], "aps.14.08": [67, true], "aps.14.09": [67, true], "aps.14.10": [67, true], "aps.14.11": [67, true], "aps.14.12": [67, true], "aps.14.13": [67, true], "aps.14.14": [67, true], "aps.14.15": [67, true], "aps.14.16": [67, true], "aps.14.17": [67, true], "aps.14.18": [67, true], "aps.14.19": [67, true], "aps.14.20": [67, true], "aps.14.21": [67, true], "aps.14.22": [67, true], "aps.14.23": [67, true], "aps.14.24": [67, true], "aps.14.25": [67, true], "aps.14.26": [67, true], "aps.14.27": [67, true], "aps.14.28": [67, true], "aps.14.29": [67, true], "aps.14.30": [67, true], "aps.14.31": [67, true], "aps.14.32": [67, true], "aps.14.33": [67, true], "aps.14.34": [67, true], "aps.14.35": [67, true], "aps.14.36": [67, true], "aps.14.37": [67, true], "aps.14.38": [67, true], "aps.14.39": [67, true], "aps.15.00": [71, true], "aps.15.01": [70, true], "aps.15.02": [72, true], "aps.15.03": [70, true], "aps.15.04": [70, true], "aps.15.05": [69, true], "aps.15.06": [69, true], "aps.15.07": [67, true], "aps.15.08": [64, true], "aps.15.09": [64, true], "aps.15.10": [64, true], "aps.15.11": [66, true], "aps.15.12": [69, true], "aps.15.13": [71, true], "aps.15.14": [70, true], "aps.15.15": [69, true], "aps.15.16": [69, true], "aps.15.17": [71, true], "aps.15.18": [73, true], "aps.15.19": [69, true], "aps.15.20": [72, true], "aps.15.21": [64, true], "aps.15.22": [66, true], "aps.15.23": [69, true], "aps.15.24": [61, true], "aps.15.25": [65, true], "aps.15.26": [70, true], "aps.15.27": [66, true], "aps.15.28": [67, true], "aps.15.29": [63, true], "aps.15.30": [63, true]}}, "CHA": {"total": 3631, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [57, true], "fun1.2": [59, true], "fun1.3": [67, true], "fun1.4": [70, true], "fun1.5": [93, true], "fun2.1": [52, true], "fun2.2": [81, true], "fun2.3": [101, true], "fun2.4": [118, true], "fun2.5": [127, true], "fun3.1": [56, true], "fun3.2": [58, true], "fun3.3": [72, true], "fun3.4": [79, true], "fun3.5": [93, true], "fun4.1": [50, true], "fun4.2": [53, true], "fun4.3": [67, true], "fun4.4": [73, true], "fun4.5": [87, true], "fun5.1": [48, true], "fun5.2": [47, true], "fun5.3": [50, true], "fun5.4": [51, true], "fun5.5": [52, true], "fun6.1": [46, true], "fun6.2": [47, true], "fun6.3": [48, true], "fun6.4": [51, true], "fun6.5": [52, true], "fun7.1": [9, false], "fun7.2": [9, false], "fun7.3": [9, false], "fun7.4": [12, false], "fun7.5": [13, false], "fun8.1": [57, true], "fun8.2": [61, true], "fun8.3": [65, true], "fun8.4": [64, true], "fun8.5": [64, true], "fun9.1": [63, true], "fun9.2": [57, true], "fun9.3": [63, true], "fun9.4": [68, true], "fun9.5": [64, true]}}}, {"label": "pure.ratio.bracket.safe", "spec": ["pure", "ratio", "bracket", "safe"], "APS": {"total": 6669, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [37, true], "aps.02.00": [22, true], "aps.02.01": [22, true], "aps.02.02": [19, true], "aps.02.03": [43, true], "aps.02.04": [15, true], "aps.02.05": [35, true], "aps.02.06": [23, true], "aps.02.07": [16, true], "aps.02.08": [25, true], "aps.02.09": [36, true], "aps.03.00": [84, true], "aps.03.01": [48, true], "aps.03.02": [91, true], "aps.04.00": [33, true], "aps.04.01": [72, true], "aps.04.02": [81, true], "aps.04.03": [87, true], "aps.04.04": [86, true], "aps.04.05": [38, true], "aps.04.06": [87, true], "aps.04.07": [27, true], "aps.04.08": [34, true], "aps.04.09": [40, true], "aps.04.10": [43, true], "aps.04.11": [33, true], "aps.04.12": [75, true], "aps.04.13": [79, true], "aps.05.00": [26, true], "aps.06.00": [18, true], "aps.06.01": [20, true], "aps.06.02": [51, true], "aps.06.03": [13, true], "aps.06.04": [25, true], "aps.06.05": [30, true], "aps.06.06": [31, true], "aps.06.07": [49, true], "aps.06.08": [33, true], "aps.06.09": [60, true], "aps.07.00": [50, true], "aps.07.01": [49, true], "aps.07.02": [49, true], "aps.08.00": [3, true], "aps.08.01": [81, true], "aps.08.02": [73, true], "aps.08.03": [73, true], "aps.08.04": [58, true], "aps.09.00": [32, true], "aps.09.01": [33, true], "aps.09.02": [43, true], "aps.09.03": [19, true], "aps.09.04": [25, true], "aps.09.05": [27, true], "aps.09.06": [25, true], "aps.10.00": [60, true], "aps.10.01": [71, true], "aps.10.02": [20, true], "aps.10.03": [34, true], "aps.10.04": [24, true], "aps.11.00": [44, true], "aps.11.01": [37, true], "aps.11.02": [26, true], "aps.11.03": [27, true], "aps.12.00": [21, true], "aps.12.01": [26, true], "aps.12.02": [25, true], "aps.12.03": [44, true], "aps.12.04": [36, true], "aps.12.05": [17, true], "aps.12.06": [28, true], "aps.12.07": [93, true], "aps.12.08": [93, true], "aps.12.09": [90, true], "aps.12.10": [90, true], "aps.12.11": [92, true], "aps.12.12": [85, true], "aps.12.13": [96, true], "aps.12.14": [85, true], "aps.12.15": [96, true], "aps.12.16": [96, true], "aps.12.17": [81, true], "aps.12.18": [89, true], "aps.13.00": [11, false], "aps.14.00": [37, true], "aps.14.01": [37, true], "aps.14.02": [37, true], "aps.14.03": [37, true], "aps.14.04": [37, true], "aps.14.05": [37, true], "aps.14.06": [37, true], "aps.14.07": [37, true], "aps.14.08": [37, true], "aps.14.09": [37, true], "aps.14.10": [37, true], "aps.14.11": [37, true], "aps.14.12": [37, true], "aps.14.13": [37, true], "aps.14.14": [37, true], "aps.14.15": [37, true], "aps.14.16": [37, true], "aps.14.17": [37, true], "aps.14.18": [37, true], "aps.14.19": [37, true], "aps.14.20": [37, true], "aps.14.21": [37, true], "aps.14.22": [37, true], "aps.14.23": [37, true], "aps.14.24": [37, true], "aps.14.25": [37, true], "aps.14.26": [37, true], "aps.14.27": [37, true], "aps.14.28": [37, true], "aps.14.29": [37, true], "aps.14.30": [37, true], "aps.14.31": [37, true], "aps.14.32": [37, true], "aps.14.33": [37, true], "aps.14.34": [37, true], "aps.14.35": [37, true], "aps.14.36": [37, true], "aps.14.37": [37, true], "aps.14.38": [37, true], "aps.14.39": [37, true], "aps.15.00": [17, true], "aps.15.01": [19, true], "aps.15.02": [21, true], "aps.15.03": [24, true], "aps.15.04": [26, true], "aps.15.05": [28, true], "aps.15.06": [26, true], "aps.15.07": [28, true], "aps.15.08": [30, true], "aps.15.09": [32, true], "aps.15.10": [33, true], "aps.15.11": [36, true], "aps.15.12": [38, true], "aps.15.13": [41, true], "aps.15.14": [44, true], "aps.15.15": [47, true], "aps.15.16": [52, true], "aps.15.17": [57, true], "aps.15.18": [64, true], "aps.15.19": [34, true], "aps.15.20": [28, true], "aps.15.21": [28, true], "aps.15.22": [28, true], "aps.15.23": [56, true], "aps.15.24": [32, true], "aps.15.25": [21, true], "aps.15.26": [21, true], "aps.15.27": [26, true], "aps.15.28": [32, true], "aps.15.29": [45, true], "aps.15.30": [22, true]}}, "CHA": {"total": 3855, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [76, true], "fun1.2": [19, true], "fun1.3": [75, true], "fun1.4": [96, true], "fun1.5": [61, true], "fun2.1": [79, true], "fun2.2": [62, true], "fun2.3": [82, true], "fun2.4": [58, true], "fun2.5": [56, true], "fun3.1": [89, true], "fun3.2": [92, true], "fun3.3": [113, true], "fun3.4": [113, true], "fun3.5": [147, true], "fun4.1": [82, true], "fun4.2": [83, true], "fun4.3": [82, true], "fun4.4": [94, true], "fun4.5": [122, true], "fun5.1": [87, true], "fun5.2": [85, true], "fun5.3": [90, true], "fun5.4": [90, true], "fun5.5": [93, true], "fun6.1": [75, true], "fun6.2": [79, true], "fun6.3": [59, true], "fun6.4": [60, true], "fun6.5": [60, true], "fun7.1": [11, false], "fun7.2": [12, false], "fun7.3": [12, false], "fun7.4": [27, false], "fun7.5": [18, false], "fun8.1": [56, true], "fun8.2": [40, true], "fun8.3": [34, true], "fun8.4": [83, true], "fun8.5": [44, true], "fun9.1": [39, true], "fun9.2": [24, true], "fun9.3": [24, true], "fun9.4": [27, true], "fun9.5": [25, true]}}}, {"label": "pure.ratio.bracket.credit", "spec": ["pure", "ratio", "bracket", "credit"], "APS": {"total": 6134, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [27, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [20, true], "aps.06.02": [43, true], "aps.06.03": [24, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [30, true], "aps.09.01": [31, true], "aps.09.02": [43, true], "aps.09.03": [19, true], "aps.09.04": [25, true], "aps.09.05": [27, true], "aps.09.06": [43, true], "aps.10.00": [37, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [39, true], "aps.12.01": [26, true], "aps.12.02": [25, true], "aps.12.03": [21, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [21, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [16, true], "aps.12.16": [50, true], "aps.12.17": [41, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [39, true], "aps.14.01": [39, true], "aps.14.02": [39, true], "aps.14.03": [39, true], "aps.14.04": [39, true], "aps.14.05": [39, true], "aps.14.06": [39, true], "aps.14.07": [39, true], "aps.14.08": [39, true], "aps.14.09": [39, true], "aps.14.10": [39, true], "aps.14.11": [39, true], "aps.14.12": [39, true], "aps.14.13": [39, true], "aps.14.14": [39, true], "aps.14.15": [39, true], "aps.14.16": [39, true], "aps.14.17": [39, true], "aps.14.18": [39, true], "aps.14.19": [39, true], "aps.14.20": [39, true], "aps.14.21": [39, true], "aps.14.22": [39, true], "aps.14.23": [39, true], "aps.14.24": [39, true], "aps.14.25": [39, true], "aps.14.26": [39, true], "aps.14.27": [39, true], "aps.14.28": [39, true], "aps.14.29": [39, true], "aps.14.30": [39, true], "aps.14.31": [39, true], "aps.14.32": [39, true], "aps.14.33": [39, true], "aps.14.34": [39, true], "aps.14.35": [39, true], "aps.14.36": [39, true], "aps.14.37": [39, true], "aps.14.38": [39, true], "aps.14.39": [39, true], "aps.15.00": [18, true], "aps.15.01": [20, true], "aps.15.02": [22, true], "aps.15.03": [25, true], "aps.15.04": [27, true], "aps.15.05": [29, true], "aps.15.06": [31, true], "aps.15.07": [40, true], "aps.15.08": [49, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [13, true], "aps.15.15": [14, true], "aps.15.16": [15, true], "aps.15.17": [16, true], "aps.15.18": [17, true], "aps.15.19": [18, true], "aps.15.20": [19, true], "aps.15.21": [31, true], "aps.15.22": [27, true], "aps.15.23": [18, true], "aps.15.24": [30, true], "aps.15.25": [53, true], "aps.15.26": [19, true], "aps.15.27": [24, true], "aps.15.28": [31, true], "aps.15.29": [43, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3113, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [66, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.ratio.derived.bracket", "spec": ["pure", "ratio", "derived", "bracket"], "APS": {"total": 4186, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [21, true], "aps.02.00": [20, true], "aps.02.01": [21, true], "aps.02.02": [20, true], "aps.02.03": [33, true], "aps.02.04": [15, true], "aps.02.05": [31, true], "aps.02.06": [32, true], "aps.02.07": [26, true], "aps.02.08": [25, true], "aps.02.09": [23, true], "aps.03.00": [22, true], "aps.03.01": [28, true], "aps.03.02": [32, true], "aps.04.00": [21, true], "aps.04.01": [28, true], "aps.04.02": [27, true], "aps.04.03": [24, true], "aps.04.04": [22, true], "aps.04.05": [18, true], "aps.04.06": [23, true], "aps.04.07": [23, true], "aps.04.08": [29, true], "aps.04.09": [28, true], "aps.04.10": [21, true], "aps.04.11": [27, true], "aps.04.12": [28, true], "aps.04.13": [28, true], "aps.05.00": [18, true], "aps.06.00": [18, true], "aps.06.01": [22, true], "aps.06.02": [21, true], "aps.06.03": [19, true], "aps.06.04": [15, true], "aps.06.05": [21, true], "aps.06.06": [22, true], "aps.06.07": [27, true], "aps.06.08": [23, true], "aps.06.09": [22, true], "aps.07.00": [21, true], "aps.07.01": [17, true], "aps.07.02": [15, true], "aps.08.00": [3, true], "aps.08.01": [22, true], "aps.08.02": [25, true], "aps.08.03": [20, true], "aps.08.04": [26, true], "aps.09.00": [20, true], "aps.09.01": [23, true], "aps.09.02": [15, true], "aps.09.03": [11, true], "aps.09.04": [11, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [20, true], "aps.10.01": [22, true], "aps.10.02": [24, true], "aps.10.03": [31, true], "aps.10.04": [24, true], "aps.11.00": [4, true], "aps.11.01": [25, true], "aps.11.02": [25, true], "aps.11.03": [22, true], "aps.12.00": [17, true], "aps.12.01": [23, true], "aps.12.02": [18, true], "aps.12.03": [18, true], "aps.12.04": [20, true], "aps.12.05": [20, true], "aps.12.06": [20, true], "aps.12.07": [20, true], "aps.12.08": [23, true], "aps.12.09": [23, true], "aps.12.10": [23, true], "aps.12.11": [23, true], "aps.12.12": [23, true], "aps.12.13": [21, true], "aps.12.14": [21, true], "aps.12.15": [19, true], "aps.12.16": [19, true], "aps.12.17": [19, true], "aps.12.18": [17, true], "aps.13.00": [48, false], "aps.14.00": [24, true], "aps.14.01": [24, true], "aps.14.02": [24, true], "aps.14.03": [24, true], "aps.14.04": [24, true], "aps.14.05": [24, true], "aps.14.06": [24, true], "aps.14.07": [24, true], "aps.14.08": [24, true], "aps.14.09": [24, true], "aps.14.10": [24, true], "aps.14.11": [24, true], "aps.14.12": [24, true], "aps.14.13": [24, true], "aps.14.14": [24, true], "aps.14.15": [24, true], "aps.14.16": [24, true], "aps.14.17": [24, true], "aps.14.18": [24, true], "aps.14.19": [24, true], "aps.14.20": [24, true], "aps.14.21": [24, true], "aps.14.22": [24, true], "aps.14.23": [24, true], "aps.14.24": [24, true], "aps.14.25": [24, true], "aps.14.26": [24, true], "aps.14.27": [24, true], "aps.14.28": [24, true], "aps.14.29": [24, true], "aps.14.30": [24, true], "aps.14.31": [24, true], "aps.14.32": [24, true], "aps.14.33": [24, true], "aps.14.34": [24, true], "aps.14.35": [24, true], "aps.14.36": [24, true], "aps.14.37": [24, true], "aps.14.38": [24, true], "aps.14.39": [24, true], "aps.15.00": [35, true], "aps.15.01": [41, true], "aps.15.02": [42, true], "aps.15.03": [42, true], "aps.15.04": [42, true], "aps.15.05": [44, true], "aps.15.06": [40, true], "aps.15.07": [42, true], "aps.15.08": [38, true], "aps.15.09": [39, true], "aps.15.10": [37, true], "aps.15.11": [39, true], "aps.15.12": [39, true], "aps.15.13": [37, true], "aps.15.14": [39, true], "aps.15.15": [37, true], "aps.15.16": [39, true], "aps.15.17": [41, true], "aps.15.18": [39, true], "aps.15.19": [41, true], "aps.15.20": [39, true], "aps.15.21": [45, true], "aps.15.22": [44, true], "aps.15.23": [47, true], "aps.15.24": [34, true], "aps.15.25": [42, true], "aps.15.26": [46, true], "aps.15.27": [46, true], "aps.15.28": [49, true], "aps.15.29": [47, true], "aps.15.30": [43, true]}}, "CHA": {"total": 3428, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [33, true], "fun1.3": [40, true], "fun1.4": [51, true], "fun1.5": [84, true], "fun2.1": [20, true], "fun2.2": [39, true], "fun2.3": [36, true], "fun2.4": [56, true], "fun2.5": [59, true], "fun3.1": [67, true], "fun3.2": [73, true], "fun3.3": [88, true], "fun3.4": [101, true], "fun3.5": [117, true], "fun4.1": [82, true], "fun4.2": [86, true], "fun4.3": [104, true], "fun4.4": [114, true], "fun4.5": [141, true], "fun5.1": [76, true], "fun5.2": [80, true], "fun5.3": [81, true], "fun5.4": [85, true], "fun5.5": [87, true], "fun6.1": [77, true], "fun6.2": [59, true], "fun6.3": [72, true], "fun6.4": [78, true], "fun6.5": [69, true], "fun7.1": [48, false], "fun7.2": [12, false], "fun7.3": [13, false], "fun7.4": [18, false], "fun7.5": [7, false], "fun8.1": [13, true], "fun8.2": [21, true], "fun8.3": [26, true], "fun8.4": [28, true], "fun8.5": [30, true], "fun9.1": [20, true], "fun9.2": [25, true], "fun9.3": [22, true], "fun9.4": [29, true], "fun9.5": [29, true]}}}, {"label": "pure.rat_sq.derived3.both", "spec": ["pure", "rat_sq", "derived3", "both"], "APS": {"total": 9775, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [54, true], "aps.02.00": [64, true], "aps.02.01": [58, true], "aps.02.02": [60, true], "aps.02.03": [62, true], "aps.02.04": [63, true], "aps.02.05": [59, true], "aps.02.06": [63, true], "aps.02.07": [64, true], "aps.02.08": [63, true], "aps.02.09": [63, true], "aps.03.00": [66, true], "aps.03.01": [65, true], "aps.03.02": [67, true], "aps.04.00": [60, true], "aps.04.01": [62, true], "aps.04.02": [64, true], "aps.04.03": [60, true], "aps.04.04": [61, true], "aps.04.05": [65, true], "aps.04.06": [65, true], "aps.04.07": [61, true], "aps.04.08": [60, true], "aps.04.09": [58, true], "aps.04.10": [62, true], "aps.04.11": [63, true], "aps.04.12": [62, true], "aps.04.13": [60, true], "aps.05.00": [61, true], "aps.06.00": [59, true], "aps.06.01": [56, true], "aps.06.02": [56, true], "aps.06.03": [56, true], "aps.06.04": [54, true], "aps.06.05": [54, true], "aps.06.06": [55, true], "aps.06.07": [54, true], "aps.06.08": [56, true], "aps.06.09": [56, true], "aps.07.00": [56, true], "aps.07.01": [57, true], "aps.07.02": [54, true], "aps.08.00": [57, true], "aps.08.01": [57, true], "aps.08.02": [56, true], "aps.08.03": [55, true], "aps.08.04": [52, true], "aps.09.00": [58, true], "aps.09.01": [54, true], "aps.09.02": [54, true], "aps.09.03": [54, true], "aps.09.04": [53, true], "aps.09.05": [51, true], "aps.09.06": [50, true], "aps.10.00": [59, true], "aps.10.01": [58, true], "aps.10.02": [56, true], "aps.10.03": [58, true], "aps.10.04": [58, true], "aps.11.00": [58, true], "aps.11.01": [57, true], "aps.11.02": [59, true], "aps.11.03": [57, true], "aps.12.00": [62, true], "aps.12.01": [64, true], "aps.12.02": [62, true], "aps.12.03": [62, true], "aps.12.04": [62, true], "aps.12.05": [65, true], "aps.12.06": [67, true], "aps.12.07": [67, true], "aps.12.08": [63, true], "aps.12.09": [67, true], "aps.12.10": [65, true], "aps.12.11": [65, true], "aps.12.12": [69, true], "aps.12.13": [65, true], "aps.12.14": [68, true], "aps.12.15": [67, true], "aps.12.16": [70, true], "aps.12.17": [64, true], "aps.12.18": [67, true], "aps.13.00": [8, false], "aps.14.00": [68, true], "aps.14.01": [68, true], "aps.14.02": [68, true], "aps.14.03": [68, true], "aps.14.04": [68, true], "aps.14.05": [68, true], "aps.14.06": [68, true], "aps.14.07": [68, true], "aps.14.08": [68, true], "aps.14.09": [68, true], "aps.14.10": [68, true], "aps.14.11": [68, true], "aps.14.12": [68, true], "aps.14.13": [68, true], "aps.14.14": [68, true], "aps.14.15": [68, true], "aps.14.16": [68, true], "aps.14.17": [68, true], "aps.14.18": [68, true], "aps.14.19": [68, true], "aps.14.20": [68, true], "aps.14.21": [68, true], "aps.14.22": [68, true], "aps.14.23": [68, true], "aps.14.24": [68, true], "aps.14.25": [68, true], "aps.14.26": [68, true], "aps.14.27": [68, true], "aps.14.28": [68, true], "aps.14.29": [68, true], "aps.14.30": [68, true], "aps.14.31": [68, true], "aps.14.32": [68, true], "aps.14.33": [68, true], "aps.14.34": [68, true], "aps.14.35": [68, true], "aps.14.36": [68, true], "aps.14.37": [68, true], "aps.14.38": [68, true], "aps.14.39": [68, true], "aps.15.00": [64, true], "aps.15.01": [63, true], "aps.15.02": [64, true], "aps.15.03": [63, true], "aps.15.04": [64, true], "aps.15.05": [63, true], "aps.15.06": [63, true], "aps.15.07": [63, true], "aps.15.08": [63, true], "aps.15.09": [62, true], "aps.15.10": [63, true], "aps.15.11": [63, true], "aps.15.12": [63, true], "aps.15.13": [63, true], "aps.15.14": [63, true], "aps.15.15": [64, true], "aps.15.16": [63, true], "aps.15.17": [64, true], "aps.15.18": [63, true], "aps.15.19": [62, true], "aps.15.20": [62, true], "aps.15.21": [63, true], "aps.15.22": [59, true], "aps.15.23": [57, true], "aps.15.24": [60, true], "aps.15.25": [60, true], "aps.15.26": [61, true], "aps.15.27": [59, true], "aps.15.28": [60, true], "aps.15.29": [62, true], "aps.15.30": [59, true]}}, "CHA": {"total": 3797, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [55, true], "fun1.2": [65, true], "fun1.3": [68, true], "fun1.4": [80, true], "fun1.5": [103, true], "fun2.1": [58, true], "fun2.2": [77, true], "fun2.3": [81, true], "fun2.4": [94, true], "fun2.5": [101, true], "fun3.1": [65, true], "fun3.2": [68, true], "fun3.3": [75, true], "fun3.4": [89, true], "fun3.5": [109, true], "fun4.1": [67, true], "fun4.2": [73, true], "fun4.3": [86, true], "fun4.4": [91, true], "fun4.5": [109, true], "fun5.1": [67, true], "fun5.2": [70, true], "fun5.3": [68, true], "fun5.4": [73, true], "fun5.5": [75, true], "fun6.1": [41, true], "fun6.2": [40, true], "fun6.3": [42, true], "fun6.4": [44, true], "fun6.5": [46, true], "fun7.1": [8, false], "fun7.2": [10, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [14, false], "fun8.1": [57, true], "fun8.2": [58, true], "fun8.3": [62, true], "fun8.4": [63, true], "fun8.5": [68, true], "fun9.1": [59, true], "fun9.2": [58, true], "fun9.3": [65, true], "fun9.4": [63, true], "fun9.5": [64, true]}}}, {"label": "pure.ratio.derived.project", "spec": ["pure", "ratio", "derived", "project"], "APS": {"total": 3154, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [15, true], "aps.02.01": [12, true], "aps.02.02": [31, true], "aps.02.03": [11, true], "aps.02.04": [19, true], "aps.02.05": [11, true], "aps.02.06": [46, true], "aps.02.07": [22, true], "aps.02.08": [21, true], "aps.02.09": [20, true], "aps.03.00": [23, true], "aps.03.01": [14, true], "aps.03.02": [30, true], "aps.04.00": [28, true], "aps.04.01": [23, true], "aps.04.02": [20, true], "aps.04.03": [21, true], "aps.04.04": [24, true], "aps.04.05": [16, true], "aps.04.06": [18, true], "aps.04.07": [18, true], "aps.04.08": [16, true], "aps.04.09": [19, true], "aps.04.10": [25, true], "aps.04.11": [21, true], "aps.04.12": [20, true], "aps.04.13": [23, true], "aps.05.00": [10, true], "aps.06.00": [8, true], "aps.06.01": [10, true], "aps.06.02": [12, true], "aps.06.03": [12, true], "aps.06.04": [10, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [15, true], "aps.06.08": [15, true], "aps.06.09": [15, true], "aps.07.00": [12, true], "aps.07.01": [10, true], "aps.07.02": [10, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [15, true], "aps.08.04": [14, true], "aps.09.00": [11, true], "aps.09.01": [23, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [9, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [9, true], "aps.10.01": [16, true], "aps.10.02": [15, true], "aps.10.03": [10, true], "aps.10.04": [14, true], "aps.11.00": [20, true], "aps.11.01": [15, true], "aps.11.02": [18, true], "aps.11.03": [17, true], "aps.12.00": [10, true], "aps.12.01": [12, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [12, true], "aps.12.05": [13, true], "aps.12.06": [12, true], "aps.12.07": [12, true], "aps.12.08": [13, true], "aps.12.09": [13, true], "aps.12.10": [12, true], "aps.12.11": [12, true], "aps.12.12": [12, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [12, true], "aps.13.00": [51, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [33, true], "aps.15.01": [34, true], "aps.15.02": [33, true], "aps.15.03": [33, true], "aps.15.04": [35, true], "aps.15.05": [35, true], "aps.15.06": [33, true], "aps.15.07": [32, true], "aps.15.08": [31, true], "aps.15.09": [31, true], "aps.15.10": [32, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [33, true], "aps.15.15": [33, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [33, true], "aps.15.21": [34, true], "aps.15.22": [37, true], "aps.15.23": [37, true], "aps.15.24": [34, true], "aps.15.25": [35, true], "aps.15.26": [37, true], "aps.15.27": [38, true], "aps.15.28": [40, true], "aps.15.29": [36, true], "aps.15.30": [35, true]}}, "CHA": {"total": 3584, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [9, true], "fun1.2": [18, true], "fun1.3": [20, true], "fun1.4": [18, true], "fun1.5": [87, true], "fun2.1": [12, true], "fun2.2": [29, true], "fun2.3": [33, true], "fun2.4": [45, true], "fun2.5": [50, true], "fun3.1": [88, true], "fun3.2": [93, true], "fun3.3": [112, true], "fun3.4": [124, true], "fun3.5": [153, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [89, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [51, false], "fun7.3": [51, false], "fun7.4": [57, false], "fun7.5": [7, false], "fun8.1": [10, true], "fun8.2": [13, true], "fun8.3": [16, true], "fun8.4": [19, true], "fun8.5": [21, true], "fun9.1": [10, true], "fun9.2": [10, true], "fun9.3": [26, true], "fun9.4": [45, true], "fun9.5": [41, true]}}}, {"label": "pure.ratio.derived3.none", "spec": ["pure", "ratio", "derived3", "none"], "APS": {"total": 2806, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [12, true], "aps.02.01": [13, true], "aps.02.02": [11, true], "aps.02.03": [24, true], "aps.02.04": [23, true], "aps.02.05": [26, true], "aps.02.06": [23, true], "aps.02.07": [28, true], "aps.02.08": [12, true], "aps.02.09": [12, true], "aps.03.00": [19, true], "aps.03.01": [22, true], "aps.03.02": [22, true], "aps.04.00": [17, true], "aps.04.01": [22, true], "aps.04.02": [14, true], "aps.04.03": [18, true], "aps.04.04": [22, true], "aps.04.05": [14, true], "aps.04.06": [12, true], "aps.04.07": [12, true], "aps.04.08": [21, true], "aps.04.09": [15, true], "aps.04.10": [15, true], "aps.04.11": [15, true], "aps.04.12": [13, true], "aps.04.13": [15, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [9, true], "aps.06.04": [9, true], "aps.06.05": [10, true], "aps.06.06": [10, true], "aps.06.07": [10, true], "aps.06.08": [13, true], "aps.06.09": [13, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [15, true], "aps.08.04": [11, true], "aps.09.00": [8, true], "aps.09.01": [10, true], "aps.09.02": [12, true], "aps.09.03": [10, true], "aps.09.04": [10, true], "aps.09.05": [11, true], "aps.09.06": [10, true], "aps.10.00": [9, true], "aps.10.01": [12, true], "aps.10.02": [15, true], "aps.10.03": [21, true], "aps.10.04": [16, true], "aps.11.00": [5, true], "aps.11.01": [5, true], "aps.11.02": [5, true], "aps.11.03": [5, true], "aps.12.00": [9, true], "aps.12.01": [9, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [9, true], "aps.12.14": [9, true], "aps.12.15": [9, true], "aps.12.16": [9, true], "aps.12.17": [9, true], "aps.12.18": [9, true], "aps.13.00": [28, false], "aps.14.00": [15, true], "aps.14.01": [15, true], "aps.14.02": [15, true], "aps.14.03": [15, true], "aps.14.04": [15, true], "aps.14.05": [15, true], "aps.14.06": [15, true], "aps.14.07": [15, true], "aps.14.08": [15, true], "aps.14.09": [15, true], "aps.14.10": [15, true], "aps.14.11": [15, true], "aps.14.12": [15, true], "aps.14.13": [15, true], "aps.14.14": [15, true], "aps.14.15": [15, true], "aps.14.16": [15, true], "aps.14.17": [15, true], "aps.14.18": [15, true], "aps.14.19": [15, true], "aps.14.20": [15, true], "aps.14.21": [15, true], "aps.14.22": [15, true], "aps.14.23": [15, true], "aps.14.24": [15, true], "aps.14.25": [15, true], "aps.14.26": [15, true], "aps.14.27": [15, true], "aps.14.28": [15, true], "aps.14.29": [15, true], "aps.14.30": [15, true], "aps.14.31": [15, true], "aps.14.32": [15, true], "aps.14.33": [15, true], "aps.14.34": [15, true], "aps.14.35": [15, true], "aps.14.36": [15, true], "aps.14.37": [15, true], "aps.14.38": [15, true], "aps.14.39": [15, true], "aps.15.00": [31, true], "aps.15.01": [30, true], "aps.15.02": [29, true], "aps.15.03": [29, true], "aps.15.04": [29, true], "aps.15.05": [29, true], "aps.15.06": [29, true], "aps.15.07": [29, true], "aps.15.08": [29, true], "aps.15.09": [30, true], "aps.15.10": [30, true], "aps.15.11": [30, true], "aps.15.12": [30, true], "aps.15.13": [30, true], "aps.15.14": [30, true], "aps.15.15": [30, true], "aps.15.16": [30, true], "aps.15.17": [30, true], "aps.15.18": [30, true], "aps.15.19": [31, true], "aps.15.20": [31, true], "aps.15.21": [36, true], "aps.15.22": [34, true], "aps.15.23": [33, true], "aps.15.24": [35, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [39, true], "aps.15.28": [40, true], "aps.15.29": [38, true], "aps.15.30": [38, true]}}, "CHA": {"total": 4104, "solved": 35, "n": 45, "over": 10, "per": {"fun1.1": [7, true], "fun1.2": [11, true], "fun1.3": [18, true], "fun1.4": [19, true], "fun1.5": [44, true], "fun2.1": [9, true], "fun2.2": [24, true], "fun2.3": [16, true], "fun2.4": [43, true], "fun2.5": [49, true], "fun3.1": [51, true], "fun3.2": [74, true], "fun3.3": [66, true], "fun3.4": [54, true], "fun3.5": [93, true], "fun4.1": [121, true], "fun4.2": [126, true], "fun4.3": [144, true], "fun4.4": [148, true], "fun4.5": [192, true], "fun5.1": [158, true], "fun5.2": [117, true], "fun5.3": [133, true], "fun5.4": [113, true], "fun5.5": [117, true], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [28, false], "fun7.2": [200, false], "fun7.3": [47, false], "fun7.4": [6, false], "fun7.5": [6, false], "fun8.1": [10, true], "fun8.2": [9, true], "fun8.3": [11, true], "fun8.4": [11, true], "fun8.5": [11, true], "fun9.1": [8, true], "fun9.2": [11, true], "fun9.3": [21, true], "fun9.4": [39, true], "fun9.5": [26, true]}}}, {"label": "pure.ratio.derived.credit", "spec": ["pure", "ratio", "derived", "credit"], "APS": {"total": 4339, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [12, true], "aps.02.00": [45, true], "aps.02.01": [20, true], "aps.02.02": [46, true], "aps.02.03": [26, true], "aps.02.04": [10, true], "aps.02.05": [13, true], "aps.02.06": [10, true], "aps.02.07": [17, true], "aps.02.08": [15, true], "aps.02.09": [12, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [28, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [10, true], "aps.06.00": [13, true], "aps.06.01": [14, true], "aps.06.02": [18, true], "aps.06.03": [18, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [15, true], "aps.06.09": [15, true], "aps.07.00": [12, true], "aps.07.01": [10, true], "aps.07.02": [10, true], "aps.08.00": [3, true], "aps.08.01": [20, true], "aps.08.02": [13, true], "aps.08.03": [19, true], "aps.08.04": [14, true], "aps.09.00": [15, true], "aps.09.01": [16, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [9, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [15, true], "aps.10.01": [14, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [13, true], "aps.11.02": [12, true], "aps.11.03": [25, true], "aps.12.00": [10, true], "aps.12.01": [12, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [12, true], "aps.12.05": [13, true], "aps.12.06": [13, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [49, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [34, true], "aps.15.01": [33, true], "aps.15.02": [38, true], "aps.15.03": [35, true], "aps.15.04": [39, true], "aps.15.05": [35, true], "aps.15.06": [33, true], "aps.15.07": [32, true], "aps.15.08": [31, true], "aps.15.09": [31, true], "aps.15.10": [32, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [33, true], "aps.15.15": [33, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [33, true], "aps.15.21": [34, true], "aps.15.22": [53, true], "aps.15.23": [40, true], "aps.15.24": [34, true], "aps.15.25": [35, true], "aps.15.26": [37, true], "aps.15.27": [38, true], "aps.15.28": [43, true], "aps.15.29": [36, true], "aps.15.30": [35, true]}}, "CHA": {"total": 3056, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [23, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [22, true], "fun9.2": [12, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.ratio.derived3.step", "spec": ["pure", "ratio", "derived3", "step"], "APS": {"total": 3036, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [19, true], "aps.02.01": [35, true], "aps.02.02": [47, true], "aps.02.03": [20, true], "aps.02.04": [22, true], "aps.02.05": [15, true], "aps.02.06": [21, true], "aps.02.07": [21, true], "aps.02.08": [17, true], "aps.02.09": [17, true], "aps.03.00": [17, true], "aps.03.01": [16, true], "aps.03.02": [20, true], "aps.04.00": [19, true], "aps.04.01": [15, true], "aps.04.02": [42, true], "aps.04.03": [17, true], "aps.04.04": [17, true], "aps.04.05": [11, true], "aps.04.06": [15, true], "aps.04.07": [15, true], "aps.04.08": [16, true], "aps.04.09": [15, true], "aps.04.10": [16, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [17, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [9, true], "aps.06.04": [9, true], "aps.06.05": [10, true], "aps.06.06": [10, true], "aps.06.07": [10, true], "aps.06.08": [13, true], "aps.06.09": [13, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [14, true], "aps.08.04": [18, true], "aps.09.00": [8, true], "aps.09.01": [10, true], "aps.09.02": [12, true], "aps.09.03": [10, true], "aps.09.04": [10, true], "aps.09.05": [11, true], "aps.09.06": [10, true], "aps.10.00": [9, true], "aps.10.01": [12, true], "aps.10.02": [34, true], "aps.10.03": [16, true], "aps.10.04": [39, true], "aps.11.00": [5, true], "aps.11.01": [11, true], "aps.11.02": [16, true], "aps.11.03": [15, true], "aps.12.00": [9, true], "aps.12.01": [9, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [9, true], "aps.12.14": [9, true], "aps.12.15": [9, true], "aps.12.16": [9, true], "aps.12.17": [9, true], "aps.12.18": [9, true], "aps.13.00": [10, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [31, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [31, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [31, true], "aps.15.07": [32, true], "aps.15.08": [31, true], "aps.15.09": [30, true], "aps.15.10": [30, true], "aps.15.11": [31, true], "aps.15.12": [31, true], "aps.15.13": [31, true], "aps.15.14": [31, true], "aps.15.15": [31, true], "aps.15.16": [31, true], "aps.15.17": [31, true], "aps.15.18": [31, true], "aps.15.19": [31, true], "aps.15.20": [31, true], "aps.15.21": [35, true], "aps.15.22": [33, true], "aps.15.23": [36, true], "aps.15.24": [36, true], "aps.15.25": [35, true], "aps.15.26": [35, true], "aps.15.27": [37, true], "aps.15.28": [36, true], "aps.15.29": [36, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3460, "solved": 40, "n": 45, "over": 10, "per": {"fun1.1": [7, true], "fun1.2": [22, true], "fun1.3": [21, true], "fun1.4": [20, true], "fun1.5": [48, true], "fun2.1": [9, true], "fun2.2": [24, true], "fun2.3": [30, true], "fun2.4": [43, true], "fun2.5": [49, true], "fun3.1": [85, true], "fun3.2": [85, true], "fun3.3": [99, true], "fun3.4": [110, true], "fun3.5": [113, true], "fun4.1": [92, true], "fun4.2": [97, true], "fun4.3": [118, true], "fun4.4": [131, true], "fun4.5": [160, true], "fun5.1": [102, true], "fun5.2": [105, true], "fun5.3": [104, true], "fun5.4": [107, true], "fun5.5": [110, true], "fun6.1": [81, true], "fun6.2": [85, true], "fun6.3": [87, true], "fun6.4": [86, true], "fun6.5": [90, true], "fun7.1": [10, false], "fun7.2": [13, false], "fun7.3": [11, false], "fun7.4": [10, false], "fun7.5": [8, false], "fun8.1": [12, true], "fun8.2": [11, true], "fun8.3": [12, true], "fun8.4": [16, true], "fun8.5": [18, true], "fun9.1": [8, true], "fun9.2": [10, true], "fun9.3": [17, true], "fun9.4": [18, true], "fun9.5": [18, true]}}}, {"label": "pure.ratio.derived3.safe", "spec": ["pure", "ratio", "derived3", "safe"], "APS": {"total": 3036, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [19, true], "aps.02.01": [35, true], "aps.02.02": [47, true], "aps.02.03": [20, true], "aps.02.04": [22, true], "aps.02.05": [15, true], "aps.02.06": [21, true], "aps.02.07": [21, true], "aps.02.08": [17, true], "aps.02.09": [17, true], "aps.03.00": [17, true], "aps.03.01": [16, true], "aps.03.02": [20, true], "aps.04.00": [19, true], "aps.04.01": [15, true], "aps.04.02": [42, true], "aps.04.03": [17, true], "aps.04.04": [17, true], "aps.04.05": [11, true], "aps.04.06": [15, true], "aps.04.07": [15, true], "aps.04.08": [16, true], "aps.04.09": [15, true], "aps.04.10": [16, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [17, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [9, true], "aps.06.04": [9, true], "aps.06.05": [10, true], "aps.06.06": [10, true], "aps.06.07": [10, true], "aps.06.08": [13, true], "aps.06.09": [13, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [14, true], "aps.08.04": [18, true], "aps.09.00": [8, true], "aps.09.01": [10, true], "aps.09.02": [12, true], "aps.09.03": [10, true], "aps.09.04": [10, true], "aps.09.05": [11, true], "aps.09.06": [10, true], "aps.10.00": [9, true], "aps.10.01": [12, true], "aps.10.02": [34, true], "aps.10.03": [16, true], "aps.10.04": [39, true], "aps.11.00": [5, true], "aps.11.01": [11, true], "aps.11.02": [16, true], "aps.11.03": [15, true], "aps.12.00": [9, true], "aps.12.01": [9, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [9, true], "aps.12.14": [9, true], "aps.12.15": [9, true], "aps.12.16": [9, true], "aps.12.17": [9, true], "aps.12.18": [9, true], "aps.13.00": [10, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [31, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [31, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [31, true], "aps.15.07": [32, true], "aps.15.08": [31, true], "aps.15.09": [30, true], "aps.15.10": [30, true], "aps.15.11": [31, true], "aps.15.12": [31, true], "aps.15.13": [31, true], "aps.15.14": [31, true], "aps.15.15": [31, true], "aps.15.16": [31, true], "aps.15.17": [31, true], "aps.15.18": [31, true], "aps.15.19": [31, true], "aps.15.20": [31, true], "aps.15.21": [35, true], "aps.15.22": [33, true], "aps.15.23": [36, true], "aps.15.24": [36, true], "aps.15.25": [35, true], "aps.15.26": [35, true], "aps.15.27": [37, true], "aps.15.28": [36, true], "aps.15.29": [36, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3363, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [7, true], "fun1.2": [22, true], "fun1.3": [21, true], "fun1.4": [20, true], "fun1.5": [48, true], "fun2.1": [9, true], "fun2.2": [24, true], "fun2.3": [30, true], "fun2.4": [43, true], "fun2.5": [49, true], "fun3.1": [85, true], "fun3.2": [85, true], "fun3.3": [99, true], "fun3.4": [110, true], "fun3.5": [113, true], "fun4.1": [89, true], "fun4.2": [93, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [89, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [81, true], "fun6.2": [85, true], "fun6.3": [87, true], "fun6.4": [86, true], "fun6.5": [90, true], "fun7.1": [10, false], "fun7.2": [13, false], "fun7.3": [11, false], "fun7.4": [10, false], "fun7.5": [8, false], "fun8.1": [12, true], "fun8.2": [11, true], "fun8.3": [12, true], "fun8.4": [16, true], "fun8.5": [18, true], "fun9.1": [8, true], "fun9.2": [10, true], "fun9.3": [17, true], "fun9.4": [18, true], "fun9.5": [18, true]}}}, {"label": "pure.ratio.derived3.project", "spec": ["pure", "ratio", "derived3", "project"], "APS": {"total": 2806, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [12, true], "aps.02.01": [13, true], "aps.02.02": [11, true], "aps.02.03": [24, true], "aps.02.04": [23, true], "aps.02.05": [26, true], "aps.02.06": [23, true], "aps.02.07": [28, true], "aps.02.08": [12, true], "aps.02.09": [12, true], "aps.03.00": [19, true], "aps.03.01": [22, true], "aps.03.02": [22, true], "aps.04.00": [17, true], "aps.04.01": [22, true], "aps.04.02": [14, true], "aps.04.03": [18, true], "aps.04.04": [22, true], "aps.04.05": [14, true], "aps.04.06": [12, true], "aps.04.07": [12, true], "aps.04.08": [21, true], "aps.04.09": [15, true], "aps.04.10": [15, true], "aps.04.11": [15, true], "aps.04.12": [13, true], "aps.04.13": [15, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [9, true], "aps.06.04": [9, true], "aps.06.05": [10, true], "aps.06.06": [10, true], "aps.06.07": [10, true], "aps.06.08": [13, true], "aps.06.09": [13, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [15, true], "aps.08.04": [11, true], "aps.09.00": [8, true], "aps.09.01": [10, true], "aps.09.02": [12, true], "aps.09.03": [10, true], "aps.09.04": [10, true], "aps.09.05": [11, true], "aps.09.06": [10, true], "aps.10.00": [9, true], "aps.10.01": [12, true], "aps.10.02": [15, true], "aps.10.03": [21, true], "aps.10.04": [16, true], "aps.11.00": [5, true], "aps.11.01": [5, true], "aps.11.02": [5, true], "aps.11.03": [5, true], "aps.12.00": [9, true], "aps.12.01": [9, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [9, true], "aps.12.14": [9, true], "aps.12.15": [9, true], "aps.12.16": [9, true], "aps.12.17": [9, true], "aps.12.18": [9, true], "aps.13.00": [28, false], "aps.14.00": [15, true], "aps.14.01": [15, true], "aps.14.02": [15, true], "aps.14.03": [15, true], "aps.14.04": [15, true], "aps.14.05": [15, true], "aps.14.06": [15, true], "aps.14.07": [15, true], "aps.14.08": [15, true], "aps.14.09": [15, true], "aps.14.10": [15, true], "aps.14.11": [15, true], "aps.14.12": [15, true], "aps.14.13": [15, true], "aps.14.14": [15, true], "aps.14.15": [15, true], "aps.14.16": [15, true], "aps.14.17": [15, true], "aps.14.18": [15, true], "aps.14.19": [15, true], "aps.14.20": [15, true], "aps.14.21": [15, true], "aps.14.22": [15, true], "aps.14.23": [15, true], "aps.14.24": [15, true], "aps.14.25": [15, true], "aps.14.26": [15, true], "aps.14.27": [15, true], "aps.14.28": [15, true], "aps.14.29": [15, true], "aps.14.30": [15, true], "aps.14.31": [15, true], "aps.14.32": [15, true], "aps.14.33": [15, true], "aps.14.34": [15, true], "aps.14.35": [15, true], "aps.14.36": [15, true], "aps.14.37": [15, true], "aps.14.38": [15, true], "aps.14.39": [15, true], "aps.15.00": [31, true], "aps.15.01": [30, true], "aps.15.02": [29, true], "aps.15.03": [29, true], "aps.15.04": [29, true], "aps.15.05": [29, true], "aps.15.06": [29, true], "aps.15.07": [29, true], "aps.15.08": [29, true], "aps.15.09": [30, true], "aps.15.10": [30, true], "aps.15.11": [30, true], "aps.15.12": [30, true], "aps.15.13": [30, true], "aps.15.14": [30, true], "aps.15.15": [30, true], "aps.15.16": [30, true], "aps.15.17": [30, true], "aps.15.18": [30, true], "aps.15.19": [31, true], "aps.15.20": [31, true], "aps.15.21": [36, true], "aps.15.22": [34, true], "aps.15.23": [33, true], "aps.15.24": [35, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [39, true], "aps.15.28": [40, true], "aps.15.29": [38, true], "aps.15.30": [38, true]}}, "CHA": {"total": 3220, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [7, true], "fun1.2": [11, true], "fun1.3": [18, true], "fun1.4": [19, true], "fun1.5": [44, true], "fun2.1": [9, true], "fun2.2": [24, true], "fun2.3": [16, true], "fun2.4": [43, true], "fun2.5": [49, true], "fun3.1": [51, true], "fun3.2": [74, true], "fun3.3": [66, true], "fun3.4": [54, true], "fun3.5": [93, true], "fun4.1": [89, true], "fun4.2": [93, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [28, false], "fun7.2": [50, false], "fun7.3": [47, false], "fun7.4": [6, false], "fun7.5": [6, false], "fun8.1": [10, true], "fun8.2": [9, true], "fun8.3": [11, true], "fun8.4": [11, true], "fun8.5": [11, true], "fun9.1": [8, true], "fun9.2": [11, true], "fun9.3": [21, true], "fun9.4": [39, true], "fun9.5": [26, true]}}}, {"label": "pure.ratio.derived3.credit", "spec": ["pure", "ratio", "derived3", "credit"], "APS": {"total": 3568, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [13, true], "aps.02.00": [45, true], "aps.02.01": [15, true], "aps.02.02": [46, true], "aps.02.03": [25, true], "aps.02.04": [30, true], "aps.02.05": [25, true], "aps.02.06": [13, true], "aps.02.07": [14, true], "aps.02.08": [12, true], "aps.02.09": [12, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [33, true], "aps.06.00": [10, true], "aps.06.01": [11, true], "aps.06.02": [30, true], "aps.06.03": [12, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [40, true], "aps.07.00": [13, true], "aps.07.01": [21, true], "aps.07.02": [34, true], "aps.08.00": [3, true], "aps.08.01": [20, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [10, true], "aps.09.01": [11, true], "aps.09.02": [21, true], "aps.09.03": [14, true], "aps.09.04": [10, true], "aps.09.05": [11, true], "aps.09.06": [10, true], "aps.10.00": [10, true], "aps.10.01": [16, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [33, true], "aps.11.01": [18, true], "aps.11.02": [11, true], "aps.11.03": [26, true], "aps.12.00": [9, true], "aps.12.01": [9, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [12, true], "aps.12.09": [12, true], "aps.12.10": [11, true], "aps.12.11": [16, true], "aps.12.12": [14, true], "aps.12.13": [13, true], "aps.12.14": [13, true], "aps.12.15": [13, true], "aps.12.16": [11, true], "aps.12.17": [17, true], "aps.12.18": [16, true], "aps.13.00": [9, false], "aps.14.00": [13, true], "aps.14.01": [13, true], "aps.14.02": [13, true], "aps.14.03": [13, true], "aps.14.04": [13, true], "aps.14.05": [13, true], "aps.14.06": [13, true], "aps.14.07": [13, true], "aps.14.08": [13, true], "aps.14.09": [13, true], "aps.14.10": [13, true], "aps.14.11": [13, true], "aps.14.12": [13, true], "aps.14.13": [13, true], "aps.14.14": [13, true], "aps.14.15": [13, true], "aps.14.16": [13, true], "aps.14.17": [13, true], "aps.14.18": [13, true], "aps.14.19": [13, true], "aps.14.20": [13, true], "aps.14.21": [13, true], "aps.14.22": [13, true], "aps.14.23": [13, true], "aps.14.24": [13, true], "aps.14.25": [13, true], "aps.14.26": [13, true], "aps.14.27": [13, true], "aps.14.28": [13, true], "aps.14.29": [13, true], "aps.14.30": [13, true], "aps.14.31": [13, true], "aps.14.32": [13, true], "aps.14.33": [13, true], "aps.14.34": [13, true], "aps.14.35": [13, true], "aps.14.36": [13, true], "aps.14.37": [13, true], "aps.14.38": [13, true], "aps.14.39": [13, true], "aps.15.00": [19, true], "aps.15.01": [19, true], "aps.15.02": [19, true], "aps.15.03": [19, true], "aps.15.04": [20, true], "aps.15.05": [20, true], "aps.15.06": [20, true], "aps.15.07": [20, true], "aps.15.08": [21, true], "aps.15.09": [20, true], "aps.15.10": [20, true], "aps.15.11": [21, true], "aps.15.12": [22, true], "aps.15.13": [23, true], "aps.15.14": [23, true], "aps.15.15": [22, true], "aps.15.16": [22, true], "aps.15.17": [23, true], "aps.15.18": [22, true], "aps.15.19": [22, true], "aps.15.20": [22, true], "aps.15.21": [21, true], "aps.15.22": [23, true], "aps.15.23": [25, true], "aps.15.24": [24, true], "aps.15.25": [24, true], "aps.15.26": [23, true], "aps.15.27": [23, true], "aps.15.28": [26, true], "aps.15.29": [25, true], "aps.15.30": [27, true]}}, "CHA": {"total": 3020, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [25, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [12, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [58, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [36, true], "fun9.1": [16, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.ratio.derived3.bracket", "spec": ["pure", "ratio", "derived3", "bracket"], "APS": {"total": 7260, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [54, true], "aps.02.00": [54, true], "aps.02.01": [32, true], "aps.02.02": [59, true], "aps.02.03": [51, true], "aps.02.04": [39, true], "aps.02.05": [18, true], "aps.02.06": [14, true], "aps.02.07": [23, true], "aps.02.08": [15, true], "aps.02.09": [28, true], "aps.03.00": [83, true], "aps.03.01": [72, true], "aps.03.02": [64, true], "aps.04.00": [38, true], "aps.04.01": [66, true], "aps.04.02": [69, true], "aps.04.03": [16, true], "aps.04.04": [57, true], "aps.04.05": [15, true], "aps.04.06": [16, true], "aps.04.07": [18, true], "aps.04.08": [56, true], "aps.04.09": [57, true], "aps.04.10": [15, true], "aps.04.11": [14, true], "aps.04.12": [55, true], "aps.04.13": [57, true], "aps.05.00": [57, true], "aps.06.00": [10, true], "aps.06.01": [52, true], "aps.06.02": [56, true], "aps.06.03": [56, true], "aps.06.04": [56, true], "aps.06.05": [60, true], "aps.06.06": [62, true], "aps.06.07": [64, true], "aps.06.08": [63, true], "aps.06.09": [65, true], "aps.07.00": [58, true], "aps.07.01": [57, true], "aps.07.02": [63, true], "aps.08.00": [3, true], "aps.08.01": [56, true], "aps.08.02": [13, true], "aps.08.03": [42, true], "aps.08.04": [13, true], "aps.09.00": [13, true], "aps.09.01": [13, true], "aps.09.02": [58, true], "aps.09.03": [62, true], "aps.09.04": [53, true], "aps.09.05": [12, true], "aps.09.06": [44, true], "aps.10.00": [10, true], "aps.10.01": [54, true], "aps.10.02": [40, true], "aps.10.03": [52, true], "aps.10.04": [61, true], "aps.11.00": [4, true], "aps.11.01": [59, true], "aps.11.02": [17, true], "aps.11.03": [62, true], "aps.12.00": [11, true], "aps.12.01": [50, true], "aps.12.02": [52, true], "aps.12.03": [51, true], "aps.12.04": [51, true], "aps.12.05": [51, true], "aps.12.06": [50, true], "aps.12.07": [51, true], "aps.12.08": [13, true], "aps.12.09": [13, true], "aps.12.10": [13, true], "aps.12.11": [48, true], "aps.12.12": [49, true], "aps.12.13": [12, true], "aps.12.14": [12, true], "aps.12.15": [12, true], "aps.12.16": [12, true], "aps.12.17": [12, true], "aps.12.18": [12, true], "aps.13.00": [8, false], "aps.14.00": [46, true], "aps.14.01": [46, true], "aps.14.02": [46, true], "aps.14.03": [46, true], "aps.14.04": [46, true], "aps.14.05": [46, true], "aps.14.06": [46, true], "aps.14.07": [46, true], "aps.14.08": [46, true], "aps.14.09": [46, true], "aps.14.10": [46, true], "aps.14.11": [46, true], "aps.14.12": [46, true], "aps.14.13": [46, true], "aps.14.14": [46, true], "aps.14.15": [46, true], "aps.14.16": [46, true], "aps.14.17": [46, true], "aps.14.18": [46, true], "aps.14.19": [46, true], "aps.14.20": [46, true], "aps.14.21": [46, true], "aps.14.22": [46, true], "aps.14.23": [46, true], "aps.14.24": [46, true], "aps.14.25": [46, true], "aps.14.26": [46, true], "aps.14.27": [46, true], "aps.14.28": [46, true], "aps.14.29": [46, true], "aps.14.30": [46, true], "aps.14.31": [46, true], "aps.14.32": [46, true], "aps.14.33": [46, true], "aps.14.34": [46, true], "aps.14.35": [46, true], "aps.14.36": [46, true], "aps.14.37": [46, true], "aps.14.38": [46, true], "aps.14.39": [46, true], "aps.15.00": [75, true], "aps.15.01": [75, true], "aps.15.02": [75, true], "aps.15.03": [75, true], "aps.15.04": [74, true], "aps.15.05": [73, true], "aps.15.06": [72, true], "aps.15.07": [71, true], "aps.15.08": [71, true], "aps.15.09": [67, true], "aps.15.10": [74, true], "aps.15.11": [75, true], "aps.15.12": [75, true], "aps.15.13": [35, true], "aps.15.14": [35, true], "aps.15.15": [35, true], "aps.15.16": [34, true], "aps.15.17": [34, true], "aps.15.18": [71, true], "aps.15.19": [73, true], "aps.15.20": [72, true], "aps.15.21": [67, true], "aps.15.22": [37, true], "aps.15.23": [74, true], "aps.15.24": [67, true], "aps.15.25": [72, true], "aps.15.26": [72, true], "aps.15.27": [41, true], "aps.15.28": [66, true], "aps.15.29": [67, true], "aps.15.30": [66, true]}}, "CHA": {"total": 3555, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [16, true], "fun1.2": [47, true], "fun1.3": [57, true], "fun1.4": [70, true], "fun1.5": [84, true], "fun2.1": [11, true], "fun2.2": [71, true], "fun2.3": [32, true], "fun2.4": [44, true], "fun2.5": [51, true], "fun3.1": [77, true], "fun3.2": [82, true], "fun3.3": [91, true], "fun3.4": [85, true], "fun3.5": [112, true], "fun4.1": [72, true], "fun4.2": [74, true], "fun4.3": [96, true], "fun4.4": [109, true], "fun4.5": [131, true], "fun5.1": [77, true], "fun5.2": [78, true], "fun5.3": [78, true], "fun5.4": [83, true], "fun5.5": [85, true], "fun6.1": [66, true], "fun6.2": [69, true], "fun6.3": [69, true], "fun6.4": [73, true], "fun6.5": [74, true], "fun7.1": [8, false], "fun7.2": [9, false], "fun7.3": [11, false], "fun7.4": [6, false], "fun7.5": [6, false], "fun8.1": [11, true], "fun8.2": [18, true], "fun8.3": [17, true], "fun8.4": [21, true], "fun8.5": [22, true], "fun9.1": [50, true], "fun9.2": [52, true], "fun9.3": [60, true], "fun9.4": [66, true], "fun9.5": [74, true]}}}, {"label": "pure.ratio.derived3.both", "spec": ["pure", "ratio", "derived3", "both"], "APS": {"total": 7239, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [52, true], "aps.02.00": [58, true], "aps.02.01": [49, true], "aps.02.02": [64, true], "aps.02.03": [30, true], "aps.02.04": [28, true], "aps.02.05": [16, true], "aps.02.06": [21, true], "aps.02.07": [20, true], "aps.02.08": [36, true], "aps.02.09": [26, true], "aps.03.00": [19, true], "aps.03.01": [83, true], "aps.03.02": [83, true], "aps.04.00": [56, true], "aps.04.01": [70, true], "aps.04.02": [37, true], "aps.04.03": [19, true], "aps.04.04": [20, true], "aps.04.05": [16, true], "aps.04.06": [16, true], "aps.04.07": [36, true], "aps.04.08": [56, true], "aps.04.09": [52, true], "aps.04.10": [56, true], "aps.04.11": [16, true], "aps.04.12": [21, true], "aps.04.13": [56, true], "aps.05.00": [53, true], "aps.06.00": [26, true], "aps.06.01": [52, true], "aps.06.02": [56, true], "aps.06.03": [56, true], "aps.06.04": [56, true], "aps.06.05": [60, true], "aps.06.06": [62, true], "aps.06.07": [64, true], "aps.06.08": [63, true], "aps.06.09": [65, true], "aps.07.00": [58, true], "aps.07.01": [57, true], "aps.07.02": [63, true], "aps.08.00": [3, true], "aps.08.01": [56, true], "aps.08.02": [32, true], "aps.08.03": [19, true], "aps.08.04": [27, true], "aps.09.00": [37, true], "aps.09.01": [37, true], "aps.09.02": [58, true], "aps.09.03": [62, true], "aps.09.04": [53, true], "aps.09.05": [14, true], "aps.09.06": [44, true], "aps.10.00": [32, true], "aps.10.01": [58, true], "aps.10.02": [54, true], "aps.10.03": [55, true], "aps.10.04": [63, true], "aps.11.00": [4, true], "aps.11.01": [13, true], "aps.11.02": [60, true], "aps.11.03": [17, true], "aps.12.00": [11, true], "aps.12.01": [50, true], "aps.12.02": [23, true], "aps.12.03": [53, true], "aps.12.04": [51, true], "aps.12.05": [51, true], "aps.12.06": [51, true], "aps.12.07": [47, true], "aps.12.08": [14, true], "aps.12.09": [24, true], "aps.12.10": [14, true], "aps.12.11": [48, true], "aps.12.12": [49, true], "aps.12.13": [20, true], "aps.12.14": [15, true], "aps.12.15": [14, true], "aps.12.16": [15, true], "aps.12.17": [14, true], "aps.12.18": [14, true], "aps.13.00": [7, false], "aps.14.00": [47, true], "aps.14.01": [47, true], "aps.14.02": [45, true], "aps.14.03": [47, true], "aps.14.04": [47, true], "aps.14.05": [45, true], "aps.14.06": [47, true], "aps.14.07": [47, true], "aps.14.08": [45, true], "aps.14.09": [47, true], "aps.14.10": [45, true], "aps.14.11": [45, true], "aps.14.12": [47, true], "aps.14.13": [47, true], "aps.14.14": [47, true], "aps.14.15": [47, true], "aps.14.16": [45, true], "aps.14.17": [45, true], "aps.14.18": [47, true], "aps.14.19": [47, true], "aps.14.20": [47, true], "aps.14.21": [45, true], "aps.14.22": [45, true], "aps.14.23": [45, true], "aps.14.24": [45, true], "aps.14.25": [47, true], "aps.14.26": [47, true], "aps.14.27": [47, true], "aps.14.28": [47, true], "aps.14.29": [47, true], "aps.14.30": [47, true], "aps.14.31": [47, true], "aps.14.32": [45, true], "aps.14.33": [45, true], "aps.14.34": [45, true], "aps.14.35": [45, true], "aps.14.36": [45, true], "aps.14.37": [47, true], "aps.14.38": [45, true], "aps.14.39": [47, true], "aps.15.00": [73, true], "aps.15.01": [73, true], "aps.15.02": [73, true], "aps.15.03": [73, true], "aps.15.04": [73, true], "aps.15.05": [72, true], "aps.15.06": [72, true], "aps.15.07": [69, true], "aps.15.08": [70, true], "aps.15.09": [66, true], "aps.15.10": [74, true], "aps.15.11": [75, true], "aps.15.12": [75, true], "aps.15.13": [38, true], "aps.15.14": [38, true], "aps.15.15": [35, true], "aps.15.16": [36, true], "aps.15.17": [38, true], "aps.15.18": [71, true], "aps.15.19": [73, true], "aps.15.20": [72, true], "aps.15.21": [67, true], "aps.15.22": [48, true], "aps.15.23": [71, true], "aps.15.24": [38, true], "aps.15.25": [72, true], "aps.15.26": [42, true], "aps.15.27": [39, true], "aps.15.28": [65, true], "aps.15.29": [67, true], "aps.15.30": [66, true]}}, "CHA": {"total": 3490, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [48, true], "fun1.2": [56, true], "fun1.3": [21, true], "fun1.4": [69, true], "fun1.5": [87, true], "fun2.1": [54, true], "fun2.2": [68, true], "fun2.3": [33, true], "fun2.4": [44, true], "fun2.5": [51, true], "fun3.1": [63, true], "fun3.2": [66, true], "fun3.3": [77, true], "fun3.4": [83, true], "fun3.5": [92, true], "fun4.1": [70, true], "fun4.2": [73, true], "fun4.3": [89, true], "fun4.4": [94, true], "fun4.5": [116, true], "fun5.1": [69, true], "fun5.2": [71, true], "fun5.3": [75, true], "fun5.4": [73, true], "fun5.5": [74, true], "fun6.1": [60, true], "fun6.2": [66, true], "fun6.3": [64, true], "fun6.4": [64, true], "fun6.5": [65, true], "fun7.1": [7, false], "fun7.2": [9, false], "fun7.3": [9, false], "fun7.4": [6, false], "fun7.5": [6, false], "fun8.1": [55, true], "fun8.2": [37, true], "fun8.3": [14, true], "fun8.4": [18, true], "fun8.5": [63, true], "fun9.1": [50, true], "fun9.2": [70, true], "fun9.3": [19, true], "fun9.4": [65, true], "fun9.5": [64, true]}}}, {"label": "pure.ratio_soft.start.bracket", "spec": ["pure", "ratio_soft", "start", "bracket"], "APS": {"total": 10179, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [66, true], "aps.02.00": [45, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [73, true], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [70, true], "aps.04.01": [70, true], "aps.04.02": [68, true], "aps.04.03": [67, true], "aps.04.04": [68, true], "aps.04.05": [68, true], "aps.04.06": [70, true], "aps.04.07": [70, true], "aps.04.08": [71, true], "aps.04.09": [70, true], "aps.04.10": [69, true], "aps.04.11": [70, true], "aps.04.12": [70, true], "aps.04.13": [70, true], "aps.05.00": [67, true], "aps.06.00": [65, true], "aps.06.01": [67, true], "aps.06.02": [65, true], "aps.06.03": [67, true], "aps.06.04": [66, true], "aps.06.05": [66, true], "aps.06.06": [65, true], "aps.06.07": [66, true], "aps.06.08": [65, true], "aps.06.09": [59, true], "aps.07.00": [69, true], "aps.07.01": [71, true], "aps.07.02": [73, true], "aps.08.00": [67, true], "aps.08.01": [63, true], "aps.08.02": [68, true], "aps.08.03": [68, true], "aps.08.04": [68, true], "aps.09.00": [67, true], "aps.09.01": [67, true], "aps.09.02": [72, true], "aps.09.03": [73, true], "aps.09.04": [77, true], "aps.09.05": [79, true], "aps.09.06": [79, true], "aps.10.00": [64, true], "aps.10.01": [67, true], "aps.10.02": [66, true], "aps.10.03": [65, true], "aps.10.04": [64, true], "aps.11.00": [66, true], "aps.11.01": [64, true], "aps.11.02": [64, true], "aps.11.03": [64, true], "aps.12.00": [73, true], "aps.12.01": [72, true], "aps.12.02": [72, true], "aps.12.03": [70, true], "aps.12.04": [72, true], "aps.12.05": [73, true], "aps.12.06": [73, true], "aps.12.07": [74, true], "aps.12.08": [72, true], "aps.12.09": [72, true], "aps.12.10": [70, true], "aps.12.11": [71, true], "aps.12.12": [71, true], "aps.12.13": [69, true], "aps.12.14": [67, true], "aps.12.15": [73, true], "aps.12.16": [73, true], "aps.12.17": [73, true], "aps.12.18": [73, true], "aps.13.00": [8, false], "aps.14.00": [67, true], "aps.14.01": [67, true], "aps.14.02": [67, true], "aps.14.03": [67, true], "aps.14.04": [67, true], "aps.14.05": [67, true], "aps.14.06": [67, true], "aps.14.07": [67, true], "aps.14.08": [67, true], "aps.14.09": [67, true], "aps.14.10": [67, true], "aps.14.11": [67, true], "aps.14.12": [67, true], "aps.14.13": [67, true], "aps.14.14": [67, true], "aps.14.15": [67, true], "aps.14.16": [67, true], "aps.14.17": [67, true], "aps.14.18": [67, true], "aps.14.19": [67, true], "aps.14.20": [67, true], "aps.14.21": [67, true], "aps.14.22": [67, true], "aps.14.23": [67, true], "aps.14.24": [67, true], "aps.14.25": [67, true], "aps.14.26": [67, true], "aps.14.27": [67, true], "aps.14.28": [67, true], "aps.14.29": [67, true], "aps.14.30": [67, true], "aps.14.31": [67, true], "aps.14.32": [67, true], "aps.14.33": [67, true], "aps.14.34": [67, true], "aps.14.35": [67, true], "aps.14.36": [67, true], "aps.14.37": [67, true], "aps.14.38": [67, true], "aps.14.39": [67, true], "aps.15.00": [63, true], "aps.15.01": [63, true], "aps.15.02": [62, true], "aps.15.03": [61, true], "aps.15.04": [63, true], "aps.15.05": [61, true], "aps.15.06": [61, true], "aps.15.07": [61, true], "aps.15.08": [59, true], "aps.15.09": [59, true], "aps.15.10": [63, true], "aps.15.11": [63, true], "aps.15.12": [63, true], "aps.15.13": [63, true], "aps.15.14": [63, true], "aps.15.15": [63, true], "aps.15.16": [63, true], "aps.15.17": [63, true], "aps.15.18": [63, true], "aps.15.19": [63, true], "aps.15.20": [63, true], "aps.15.21": [61, true], "aps.15.22": [62, true], "aps.15.23": [63, true], "aps.15.24": [52, true], "aps.15.25": [62, true], "aps.15.26": [61, true], "aps.15.27": [58, true], "aps.15.28": [59, true], "aps.15.29": [60, true], "aps.15.30": [62, true]}}, "CHA": {"total": 3654, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [66, true], "fun1.2": [70, true], "fun1.3": [77, true], "fun1.4": [77, true], "fun1.5": [92, true], "fun2.1": [65, true], "fun2.2": [71, true], "fun2.3": [73, true], "fun2.4": [81, true], "fun2.5": [86, true], "fun3.1": [57, true], "fun3.2": [60, true], "fun3.3": [73, true], "fun3.4": [81, true], "fun3.5": [92, true], "fun4.1": [54, true], "fun4.2": [56, true], "fun4.3": [65, true], "fun4.4": [74, true], "fun4.5": [87, true], "fun5.1": [50, true], "fun5.2": [50, true], "fun5.3": [53, true], "fun5.4": [55, true], "fun5.5": [56, true], "fun6.1": [48, true], "fun6.2": [48, true], "fun6.3": [49, true], "fun6.4": [52, true], "fun6.5": [53, true], "fun7.1": [8, false], "fun7.2": [12, false], "fun7.3": [13, false], "fun7.4": [15, false], "fun7.5": [14, false], "fun8.1": [66, true], "fun8.2": [67, true], "fun8.3": [68, true], "fun8.4": [68, true], "fun8.5": [69, true], "fun9.1": [67, true], "fun9.2": [62, true], "fun9.3": [72, true], "fun9.4": [72, true], "fun9.5": [72, true]}}}, {"label": "pure.ratio_soft.start.step", "spec": ["pure", "ratio_soft", "start", "step"], "APS": {"total": 12323, "solved": 153, "n": 154, "over": 28, "per": {"aps.01.00": [27, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [75, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [73, true], "aps.04.01": [99, true], "aps.04.02": [121, true], "aps.04.03": [76, true], "aps.04.04": [61, true], "aps.04.05": [47, true], "aps.04.06": [73, true], "aps.04.07": [85, true], "aps.04.08": [147, true], "aps.04.09": [49, true], "aps.04.10": [32, true], "aps.04.11": [80, true], "aps.04.12": [77, true], "aps.04.13": [37, true], "aps.05.00": [27, true], "aps.06.00": [172, true], "aps.06.01": [75, true], "aps.06.02": [77, true], "aps.06.03": [79, true], "aps.06.04": [71, true], "aps.06.05": [69, true], "aps.06.06": [72, true], "aps.06.07": [74, true], "aps.06.08": [68, true], "aps.06.09": [92, true], "aps.07.00": [148, true], "aps.07.01": [46, true], "aps.07.02": [82, true], "aps.08.00": [3, true], "aps.08.01": [135, true], "aps.08.02": [125, true], "aps.08.03": [150, true], "aps.08.04": [178, true], "aps.09.00": [73, true], "aps.09.01": [81, true], "aps.09.02": [73, true], "aps.09.03": [151, true], "aps.09.04": [139, true], "aps.09.05": [138, true], "aps.09.06": [166, true], "aps.10.00": [149, true], "aps.10.01": [40, true], "aps.10.02": [80, true], "aps.10.03": [78, true], "aps.10.04": [74, true], "aps.11.00": [74, true], "aps.11.01": [158, true], "aps.11.02": [75, true], "aps.11.03": [80, true], "aps.12.00": [157, true], "aps.12.01": [57, true], "aps.12.02": [74, true], "aps.12.03": [174, true], "aps.12.04": [58, true], "aps.12.05": [73, true], "aps.12.06": [19, true], "aps.12.07": [23, true], "aps.12.08": [23, true], "aps.12.09": [18, true], "aps.12.10": [71, true], "aps.12.11": [78, true], "aps.12.12": [79, true], "aps.12.13": [78, true], "aps.12.14": [77, true], "aps.12.15": [85, true], "aps.12.16": [85, true], "aps.12.17": [87, true], "aps.12.18": [166, true], "aps.13.00": [14, false], "aps.14.00": [71, true], "aps.14.01": [71, true], "aps.14.02": [71, true], "aps.14.03": [71, true], "aps.14.04": [71, true], "aps.14.05": [71, true], "aps.14.06": [71, true], "aps.14.07": [71, true], "aps.14.08": [71, true], "aps.14.09": [71, true], "aps.14.10": [71, true], "aps.14.11": [71, true], "aps.14.12": [71, true], "aps.14.13": [71, true], "aps.14.14": [71, true], "aps.14.15": [71, true], "aps.14.16": [71, true], "aps.14.17": [71, true], "aps.14.18": [71, true], "aps.14.19": [71, true], "aps.14.20": [71, true], "aps.14.21": [71, true], "aps.14.22": [71, true], "aps.14.23": [71, true], "aps.14.24": [71, true], "aps.14.25": [71, true], "aps.14.26": [71, true], "aps.14.27": [71, true], "aps.14.28": [71, true], "aps.14.29": [71, true], "aps.14.30": [71, true], "aps.14.31": [71, true], "aps.14.32": [71, true], "aps.14.33": [71, true], "aps.14.34": [71, true], "aps.14.35": [71, true], "aps.14.36": [71, true], "aps.14.37": [71, true], "aps.14.38": [71, true], "aps.14.39": [71, true], "aps.15.00": [130, true], "aps.15.01": [49, true], "aps.15.02": [38, true], "aps.15.03": [71, true], "aps.15.04": [73, true], "aps.15.05": [82, true], "aps.15.06": [141, true], "aps.15.07": [141, true], "aps.15.08": [151, true], "aps.15.09": [165, true], "aps.15.10": [74, true], "aps.15.11": [79, true], "aps.15.12": [67, true], "aps.15.13": [67, true], "aps.15.14": [72, true], "aps.15.15": [77, true], "aps.15.16": [78, true], "aps.15.17": [162, true], "aps.15.18": [141, true], "aps.15.19": [132, true], "aps.15.20": [60, true], "aps.15.21": [73, true], "aps.15.22": [77, true], "aps.15.23": [52, true], "aps.15.24": [66, true], "aps.15.25": [47, true], "aps.15.26": [69, true], "aps.15.27": [122, true], "aps.15.28": [64, true], "aps.15.29": [46, true], "aps.15.30": [50, true]}}, "CHA": {"total": 4169, "solved": 40, "n": 45, "over": 6, "per": {"fun1.1": [161, true], "fun1.2": [170, true], "fun1.3": [145, true], "fun1.4": [95, true], "fun1.5": [109, true], "fun2.1": [70, true], "fun2.2": [46, true], "fun2.3": [42, true], "fun2.4": [162, true], "fun2.5": [64, true], "fun3.1": [64, true], "fun3.2": [66, true], "fun3.3": [87, true], "fun3.4": [94, true], "fun3.5": [109, true], "fun4.1": [55, true], "fun4.2": [57, true], "fun4.3": [76, true], "fun4.4": [82, true], "fun4.5": [95, true], "fun5.1": [51, true], "fun5.2": [56, true], "fun5.3": [56, true], "fun5.4": [58, true], "fun5.5": [59, true], "fun6.1": [48, true], "fun6.2": [48, true], "fun6.3": [50, true], "fun6.4": [53, true], "fun6.5": [54, true], "fun7.1": [14, false], "fun7.2": [9, false], "fun7.3": [17, false], "fun7.4": [18, false], "fun7.5": [21, false], "fun8.1": [77, true], "fun8.2": [73, true], "fun8.3": [47, true], "fun8.4": [38, true], "fun8.5": [158, true], "fun9.1": [50, true], "fun9.2": [144, true], "fun9.3": [76, true], "fun9.4": [35, true], "fun9.5": [89, true]}}}, {"label": "pure.ratio.derived.safe", "spec": ["pure", "ratio", "derived", "safe"], "APS": {"total": 3104, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [14, true], "aps.02.01": [13, true], "aps.02.02": [12, true], "aps.02.03": [18, true], "aps.02.04": [28, true], "aps.02.05": [26, true], "aps.02.06": [11, true], "aps.02.07": [20, true], "aps.02.08": [19, true], "aps.02.09": [29, true], "aps.03.00": [25, true], "aps.03.01": [15, true], "aps.03.02": [21, true], "aps.04.00": [17, true], "aps.04.01": [18, true], "aps.04.02": [24, true], "aps.04.03": [19, true], "aps.04.04": [20, true], "aps.04.05": [17, true], "aps.04.06": [17, true], "aps.04.07": [17, true], "aps.04.08": [15, true], "aps.04.09": [18, true], "aps.04.10": [16, true], "aps.04.11": [17, true], "aps.04.12": [18, true], "aps.04.13": [18, true], "aps.05.00": [10, true], "aps.06.00": [8, true], "aps.06.01": [10, true], "aps.06.02": [12, true], "aps.06.03": [11, true], "aps.06.04": [10, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [15, true], "aps.06.08": [15, true], "aps.06.09": [15, true], "aps.07.00": [12, true], "aps.07.01": [10, true], "aps.07.02": [10, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [16, true], "aps.08.04": [15, true], "aps.09.00": [11, true], "aps.09.01": [23, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [9, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [9, true], "aps.10.01": [16, true], "aps.10.02": [15, true], "aps.10.03": [17, true], "aps.10.04": [45, true], "aps.11.00": [4, true], "aps.11.01": [13, true], "aps.11.02": [17, true], "aps.11.03": [18, true], "aps.12.00": [10, true], "aps.12.01": [12, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [12, true], "aps.12.05": [13, true], "aps.12.06": [12, true], "aps.12.07": [12, true], "aps.12.08": [11, true], "aps.12.09": [10, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [33, true], "aps.15.01": [34, true], "aps.15.02": [33, true], "aps.15.03": [33, true], "aps.15.04": [37, true], "aps.15.05": [37, true], "aps.15.06": [33, true], "aps.15.07": [32, true], "aps.15.08": [31, true], "aps.15.09": [31, true], "aps.15.10": [32, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [33, true], "aps.15.15": [33, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [33, true], "aps.15.21": [34, true], "aps.15.22": [37, true], "aps.15.23": [37, true], "aps.15.24": [34, true], "aps.15.25": [35, true], "aps.15.26": [37, true], "aps.15.27": [38, true], "aps.15.28": [40, true], "aps.15.29": [36, true], "aps.15.30": [35, true]}}, "CHA": {"total": 3446, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [9, true], "fun1.2": [14, true], "fun1.3": [19, true], "fun1.4": [21, true], "fun1.5": [69, true], "fun2.1": [11, true], "fun2.2": [29, true], "fun2.3": [32, true], "fun2.4": [45, true], "fun2.5": [50, true], "fun3.1": [85, true], "fun3.2": [88, true], "fun3.3": [108, true], "fun3.4": [117, true], "fun3.5": [141, true], "fun4.1": [87, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [124, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [74, true], "fun6.2": [88, true], "fun6.3": [86, true], "fun6.4": [93, true], "fun6.5": [87, true], "fun7.1": [10, false], "fun7.2": [13, false], "fun7.3": [11, false], "fun7.4": [10, false], "fun7.5": [8, false], "fun8.1": [12, true], "fun8.2": [13, true], "fun8.3": [13, true], "fun8.4": [18, true], "fun8.5": [21, true], "fun9.1": [10, true], "fun9.2": [12, true], "fun9.3": [15, true], "fun9.4": [20, true], "fun9.5": [22, true]}}}, {"label": "pure.ratio_soft.start.both", "spec": ["pure", "ratio_soft", "start", "both"], "APS": {"total": 9539, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [61, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [74, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [64, true], "aps.04.01": [68, true], "aps.04.02": [61, true], "aps.04.03": [58, true], "aps.04.04": [65, true], "aps.04.05": [63, true], "aps.04.06": [65, true], "aps.04.07": [63, true], "aps.04.08": [64, true], "aps.04.09": [66, true], "aps.04.10": [67, true], "aps.04.11": [61, true], "aps.04.12": [64, true], "aps.04.13": [63, true], "aps.05.00": [61, true], "aps.06.00": [58, true], "aps.06.01": [58, true], "aps.06.02": [61, true], "aps.06.03": [61, true], "aps.06.04": [54, true], "aps.06.05": [55, true], "aps.06.06": [59, true], "aps.06.07": [57, true], "aps.06.08": [56, true], "aps.06.09": [53, true], "aps.07.00": [60, true], "aps.07.01": [63, true], "aps.07.02": [65, true], "aps.08.00": [3, true], "aps.08.01": [58, true], "aps.08.02": [58, true], "aps.08.03": [60, true], "aps.08.04": [65, true], "aps.09.00": [61, true], "aps.09.01": [57, true], "aps.09.02": [64, true], "aps.09.03": [69, true], "aps.09.04": [70, true], "aps.09.05": [71, true], "aps.09.06": [71, true], "aps.10.00": [59, true], "aps.10.01": [61, true], "aps.10.02": [58, true], "aps.10.03": [56, true], "aps.10.04": [58, true], "aps.11.00": [55, true], "aps.11.01": [59, true], "aps.11.02": [56, true], "aps.11.03": [58, true], "aps.12.00": [63, true], "aps.12.01": [64, true], "aps.12.02": [55, true], "aps.12.03": [63, true], "aps.12.04": [64, true], "aps.12.05": [64, true], "aps.12.06": [65, true], "aps.12.07": [64, true], "aps.12.08": [65, true], "aps.12.09": [67, true], "aps.12.10": [63, true], "aps.12.11": [64, true], "aps.12.12": [59, true], "aps.12.13": [68, true], "aps.12.14": [67, true], "aps.12.15": [68, true], "aps.12.16": [66, true], "aps.12.17": [65, true], "aps.12.18": [64, true], "aps.13.00": [11, false], "aps.14.00": [68, true], "aps.14.01": [68, true], "aps.14.02": [68, true], "aps.14.03": [68, true], "aps.14.04": [68, true], "aps.14.05": [68, true], "aps.14.06": [68, true], "aps.14.07": [68, true], "aps.14.08": [68, true], "aps.14.09": [68, true], "aps.14.10": [68, true], "aps.14.11": [68, true], "aps.14.12": [68, true], "aps.14.13": [68, true], "aps.14.14": [68, true], "aps.14.15": [68, true], "aps.14.16": [68, true], "aps.14.17": [68, true], "aps.14.18": [68, true], "aps.14.19": [68, true], "aps.14.20": [68, true], "aps.14.21": [68, true], "aps.14.22": [68, true], "aps.14.23": [68, true], "aps.14.24": [68, true], "aps.14.25": [68, true], "aps.14.26": [68, true], "aps.14.27": [68, true], "aps.14.28": [68, true], "aps.14.29": [68, true], "aps.14.30": [68, true], "aps.14.31": [68, true], "aps.14.32": [68, true], "aps.14.33": [68, true], "aps.14.34": [68, true], "aps.14.35": [68, true], "aps.14.36": [68, true], "aps.14.37": [68, true], "aps.14.38": [68, true], "aps.14.39": [68, true], "aps.15.00": [59, true], "aps.15.01": [56, true], "aps.15.02": [59, true], "aps.15.03": [56, true], "aps.15.04": [57, true], "aps.15.05": [59, true], "aps.15.06": [57, true], "aps.15.07": [58, true], "aps.15.08": [61, true], "aps.15.09": [57, true], "aps.15.10": [58, true], "aps.15.11": [60, true], "aps.15.12": [59, true], "aps.15.13": [58, true], "aps.15.14": [59, true], "aps.15.15": [55, true], "aps.15.16": [57, true], "aps.15.17": [57, true], "aps.15.18": [57, true], "aps.15.19": [54, true], "aps.15.20": [60, true], "aps.15.21": [59, true], "aps.15.22": [57, true], "aps.15.23": [51, true], "aps.15.24": [57, true], "aps.15.25": [51, true], "aps.15.26": [56, true], "aps.15.27": [60, true], "aps.15.28": [57, true], "aps.15.29": [56, true], "aps.15.30": [55, true]}}, "CHA": {"total": 3508, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [60, true], "fun1.2": [65, true], "fun1.3": [72, true], "fun1.4": [74, true], "fun1.5": [93, true], "fun2.1": [55, true], "fun2.2": [65, true], "fun2.3": [67, true], "fun2.4": [77, true], "fun2.5": [79, true], "fun3.1": [54, true], "fun3.2": [57, true], "fun3.3": [72, true], "fun3.4": [79, true], "fun3.5": [93, true], "fun4.1": [50, true], "fun4.2": [52, true], "fun4.3": [67, true], "fun4.4": [73, true], "fun4.5": [86, true], "fun5.1": [49, true], "fun5.2": [51, true], "fun5.3": [51, true], "fun5.4": [54, true], "fun5.5": [55, true], "fun6.1": [47, true], "fun6.2": [46, true], "fun6.3": [49, true], "fun6.4": [51, true], "fun6.5": [52, true], "fun7.1": [11, false], "fun7.2": [9, false], "fun7.3": [50, false], "fun7.4": [13, false], "fun7.5": [15, false], "fun8.1": [59, true], "fun8.2": [55, true], "fun8.3": [60, true], "fun8.4": [61, true], "fun8.5": [63, true], "fun9.1": [60, true], "fun9.2": [61, true], "fun9.3": [56, true], "fun9.4": [71, true], "fun9.5": [67, true]}}}, {"label": "pure.ratio_soft.start.none", "spec": ["pure", "ratio_soft", "start", "none"], "APS": {"total": 23249, "solved": 52, "n": 154, "over": 3, "per": {"aps.01.00": [38, true], "aps.02.00": [45, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [200, false], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [30, true], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [53, true], "aps.04.07": [52, true], "aps.04.08": [200, false], "aps.04.09": [51, true], "aps.04.10": [57, true], "aps.04.11": [200, false], "aps.04.12": [31, true], "aps.04.13": [200, false], "aps.05.00": [52, true], "aps.06.00": [49, true], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [45, true], "aps.06.05": [45, true], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [46, true], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [36, true], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [200, false], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [52, true], "aps.11.02": [37, true], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [65, true], "aps.12.02": [190, true], "aps.12.03": [53, true], "aps.12.04": [33, true], "aps.12.05": [200, false], "aps.12.06": [19, true], "aps.12.07": [23, true], "aps.12.08": [23, true], "aps.12.09": [17, true], "aps.12.10": [200, false], "aps.12.11": [59, true], "aps.12.12": [96, true], "aps.12.13": [178, true], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [163, true], "aps.12.17": [98, true], "aps.12.18": [69, true], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [31, true], "aps.15.01": [38, true], "aps.15.02": [46, true], "aps.15.03": [55, true], "aps.15.04": [65, true], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [51, true], "aps.15.18": [44, true], "aps.15.19": [38, true], "aps.15.20": [32, true], "aps.15.21": [200, false], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [63, true], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [69, true]}}, "CHA": {"total": 8095, "solved": 6, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [61, true], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [27, true], "fun8.2": [38, true], "fun8.3": [89, true], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [22, true], "fun9.2": [58, true], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.ratio_soft.start.credit", "spec": ["pure", "ratio_soft", "start", "credit"], "APS": {"total": 7683, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [9, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [49, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [9, false], "fun7.4": [11, false], "fun7.5": [14, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.ratio_soft.start.safe", "spec": ["pure", "ratio_soft", "start", "safe"], "APS": {"total": 12147, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [27, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [75, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [73, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [76, true], "aps.04.04": [61, true], "aps.04.05": [47, true], "aps.04.06": [73, true], "aps.04.07": [85, true], "aps.04.08": [89, true], "aps.04.09": [49, true], "aps.04.10": [32, true], "aps.04.11": [80, true], "aps.04.12": [77, true], "aps.04.13": [37, true], "aps.05.00": [27, true], "aps.06.00": [82, true], "aps.06.01": [75, true], "aps.06.02": [77, true], "aps.06.03": [79, true], "aps.06.04": [71, true], "aps.06.05": [69, true], "aps.06.06": [72, true], "aps.06.07": [74, true], "aps.06.08": [68, true], "aps.06.09": [83, true], "aps.07.00": [83, true], "aps.07.01": [46, true], "aps.07.02": [82, true], "aps.08.00": [3, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [73, true], "aps.09.01": [81, true], "aps.09.02": [73, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [40, true], "aps.10.02": [80, true], "aps.10.03": [78, true], "aps.10.04": [74, true], "aps.11.00": [74, true], "aps.11.01": [83, true], "aps.11.02": [75, true], "aps.11.03": [80, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [74, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [73, true], "aps.12.06": [19, true], "aps.12.07": [23, true], "aps.12.08": [23, true], "aps.12.09": [18, true], "aps.12.10": [71, true], "aps.12.11": [78, true], "aps.12.12": [79, true], "aps.12.13": [78, true], "aps.12.14": [77, true], "aps.12.15": [85, true], "aps.12.16": [85, true], "aps.12.17": [87, true], "aps.12.18": [97, true], "aps.13.00": [14, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [103, true], "aps.15.01": [49, true], "aps.15.02": [38, true], "aps.15.03": [71, true], "aps.15.04": [73, true], "aps.15.05": [82, true], "aps.15.06": [103, true], "aps.15.07": [103, true], "aps.15.08": [103, true], "aps.15.09": [103, true], "aps.15.10": [74, true], "aps.15.11": [79, true], "aps.15.12": [67, true], "aps.15.13": [67, true], "aps.15.14": [72, true], "aps.15.15": [77, true], "aps.15.16": [78, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [60, true], "aps.15.21": [73, true], "aps.15.22": [77, true], "aps.15.23": [52, true], "aps.15.24": [66, true], "aps.15.25": [47, true], "aps.15.26": [69, true], "aps.15.27": [103, true], "aps.15.28": [64, true], "aps.15.29": [46, true], "aps.15.30": [50, true]}}, "CHA": {"total": 3864, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [95, true], "fun1.5": [109, true], "fun2.1": [70, true], "fun2.2": [46, true], "fun2.3": [42, true], "fun2.4": [150, true], "fun2.5": [64, true], "fun3.1": [64, true], "fun3.2": [66, true], "fun3.3": [87, true], "fun3.4": [94, true], "fun3.5": [109, true], "fun4.1": [55, true], "fun4.2": [57, true], "fun4.3": [76, true], "fun4.4": [82, true], "fun4.5": [95, true], "fun5.1": [51, true], "fun5.2": [56, true], "fun5.3": [56, true], "fun5.4": [58, true], "fun5.5": [59, true], "fun6.1": [48, true], "fun6.2": [48, true], "fun6.3": [50, true], "fun6.4": [53, true], "fun6.5": [54, true], "fun7.1": [14, false], "fun7.2": [9, false], "fun7.3": [17, false], "fun7.4": [18, false], "fun7.5": [21, false], "fun8.1": [77, true], "fun8.2": [73, true], "fun8.3": [47, true], "fun8.4": [38, true], "fun8.5": [96, true], "fun9.1": [82, true], "fun9.2": [86, true], "fun9.3": [76, true], "fun9.4": [35, true], "fun9.5": [89, true]}}}, {"label": "pure.ratio_soft.bracket.step", "spec": ["pure", "ratio_soft", "bracket", "step"], "APS": {"total": 8731, "solved": 153, "n": 154, "over": 4, "per": {"aps.01.00": [56, true], "aps.02.00": [61, true], "aps.02.01": [59, true], "aps.02.02": [63, true], "aps.02.03": [57, true], "aps.02.04": [57, true], "aps.02.05": [62, true], "aps.02.06": [61, true], "aps.02.07": [58, true], "aps.02.08": [62, true], "aps.02.09": [63, true], "aps.03.00": [59, true], "aps.03.01": [66, true], "aps.03.02": [66, true], "aps.04.00": [67, true], "aps.04.01": [63, true], "aps.04.02": [64, true], "aps.04.03": [65, true], "aps.04.04": [66, true], "aps.04.05": [61, true], "aps.04.06": [52, true], "aps.04.07": [32, true], "aps.04.08": [48, true], "aps.04.09": [91, true], "aps.04.10": [60, true], "aps.04.11": [62, true], "aps.04.12": [62, true], "aps.04.13": [55, true], "aps.05.00": [60, true], "aps.06.00": [58, true], "aps.06.01": [58, true], "aps.06.02": [57, true], "aps.06.03": [52, true], "aps.06.04": [53, true], "aps.06.05": [52, true], "aps.06.06": [54, true], "aps.06.07": [50, true], "aps.06.08": [50, true], "aps.06.09": [51, true], "aps.07.00": [55, true], "aps.07.01": [54, true], "aps.07.02": [52, true], "aps.08.00": [3, true], "aps.08.01": [55, true], "aps.08.02": [60, true], "aps.08.03": [87, true], "aps.08.04": [113, true], "aps.09.00": [57, true], "aps.09.01": [53, true], "aps.09.02": [54, true], "aps.09.03": [54, true], "aps.09.04": [49, true], "aps.09.05": [45, true], "aps.09.06": [36, true], "aps.10.00": [58, true], "aps.10.01": [40, true], "aps.10.02": [55, true], "aps.10.03": [36, true], "aps.10.04": [53, true], "aps.11.00": [52, true], "aps.11.01": [50, true], "aps.11.02": [61, true], "aps.11.03": [98, true], "aps.12.00": [64, true], "aps.12.01": [64, true], "aps.12.02": [63, true], "aps.12.03": [61, true], "aps.12.04": [57, true], "aps.12.05": [52, true], "aps.12.06": [19, true], "aps.12.07": [23, true], "aps.12.08": [26, true], "aps.12.09": [29, true], "aps.12.10": [30, true], "aps.12.11": [32, true], "aps.12.12": [34, true], "aps.12.13": [35, true], "aps.12.14": [36, true], "aps.12.15": [37, true], "aps.12.16": [39, true], "aps.12.17": [40, true], "aps.12.18": [40, true], "aps.13.00": [7, false], "aps.14.00": [65, true], "aps.14.01": [65, true], "aps.14.02": [65, true], "aps.14.03": [65, true], "aps.14.04": [65, true], "aps.14.05": [65, true], "aps.14.06": [65, true], "aps.14.07": [65, true], "aps.14.08": [65, true], "aps.14.09": [65, true], "aps.14.10": [65, true], "aps.14.11": [65, true], "aps.14.12": [65, true], "aps.14.13": [65, true], "aps.14.14": [65, true], "aps.14.15": [65, true], "aps.14.16": [65, true], "aps.14.17": [65, true], "aps.14.18": [65, true], "aps.14.19": [65, true], "aps.14.20": [65, true], "aps.14.21": [65, true], "aps.14.22": [65, true], "aps.14.23": [65, true], "aps.14.24": [65, true], "aps.14.25": [65, true], "aps.14.26": [65, true], "aps.14.27": [65, true], "aps.14.28": [65, true], "aps.14.29": [65, true], "aps.14.30": [65, true], "aps.14.31": [65, true], "aps.14.32": [65, true], "aps.14.33": [65, true], "aps.14.34": [65, true], "aps.14.35": [65, true], "aps.14.36": [65, true], "aps.14.37": [65, true], "aps.14.38": [65, true], "aps.14.39": [65, true], "aps.15.00": [51, true], "aps.15.01": [51, true], "aps.15.02": [52, true], "aps.15.03": [52, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [52, true], "aps.15.07": [52, true], "aps.15.08": [52, true], "aps.15.09": [52, true], "aps.15.10": [51, true], "aps.15.11": [51, true], "aps.15.12": [49, true], "aps.15.13": [42, true], "aps.15.14": [49, true], "aps.15.15": [50, true], "aps.15.16": [51, true], "aps.15.17": [52, true], "aps.15.18": [52, true], "aps.15.19": [52, true], "aps.15.20": [53, true], "aps.15.21": [48, true], "aps.15.22": [50, true], "aps.15.23": [50, true], "aps.15.24": [46, true], "aps.15.25": [45, true], "aps.15.26": [45, true], "aps.15.27": [39, true], "aps.15.28": [45, true], "aps.15.29": [44, true], "aps.15.30": [43, true]}}, "CHA": {"total": 4004, "solved": 40, "n": 45, "over": 2, "per": {"fun1.1": [55, true], "fun1.2": [55, true], "fun1.3": [65, true], "fun1.4": [69, true], "fun1.5": [77, true], "fun2.1": [36, true], "fun2.2": [100, true], "fun2.3": [117, true], "fun2.4": [89, true], "fun2.5": [99, true], "fun3.1": [74, true], "fun3.2": [84, true], "fun3.3": [82, true], "fun3.4": [78, true], "fun3.5": [105, true], "fun4.1": [69, true], "fun4.2": [70, true], "fun4.3": [74, true], "fun4.4": [79, true], "fun4.5": [92, true], "fun5.1": [83, true], "fun5.2": [76, true], "fun5.3": [92, true], "fun5.4": [97, true], "fun5.5": [100, true], "fun6.1": [76, true], "fun6.2": [60, true], "fun6.3": [69, true], "fun6.4": [71, true], "fun6.5": [75, true], "fun7.1": [7, false], "fun7.2": [7, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [16, false], "fun8.1": [58, true], "fun8.2": [62, true], "fun8.3": [67, true], "fun8.4": [73, true], "fun8.5": [79, true], "fun9.1": [59, true], "fun9.2": [49, true], "fun9.3": [62, true], "fun9.4": [63, true], "fun9.5": [64, true]}}}, {"label": "pure.ratio_soft.bracket.bracket", "spec": ["pure", "ratio_soft", "bracket", "bracket"], "APS": {"total": 7511, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [46, true], "aps.02.00": [47, true], "aps.02.01": [48, true], "aps.02.02": [49, true], "aps.02.03": [47, true], "aps.02.04": [51, true], "aps.02.05": [50, true], "aps.02.06": [52, true], "aps.02.07": [52, true], "aps.02.08": [51, true], "aps.02.09": [52, true], "aps.03.00": [54, true], "aps.03.01": [51, true], "aps.03.02": [54, true], "aps.04.00": [46, true], "aps.04.01": [50, true], "aps.04.02": [49, true], "aps.04.03": [46, true], "aps.04.04": [47, true], "aps.04.05": [51, true], "aps.04.06": [52, true], "aps.04.07": [50, true], "aps.04.08": [55, true], "aps.04.09": [56, true], "aps.04.10": [51, true], "aps.04.11": [49, true], "aps.04.12": [49, true], "aps.04.13": [48, true], "aps.05.00": [46, true], "aps.06.00": [46, true], "aps.06.01": [44, true], "aps.06.02": [47, true], "aps.06.03": [46, true], "aps.06.04": [44, true], "aps.06.05": [40, true], "aps.06.06": [44, true], "aps.06.07": [43, true], "aps.06.08": [39, true], "aps.06.09": [40, true], "aps.07.00": [47, true], "aps.07.01": [46, true], "aps.07.02": [44, true], "aps.08.00": [47, true], "aps.08.01": [43, true], "aps.08.02": [46, true], "aps.08.03": [44, true], "aps.08.04": [47, true], "aps.09.00": [46, true], "aps.09.01": [47, true], "aps.09.02": [45, true], "aps.09.03": [43, true], "aps.09.04": [41, true], "aps.09.05": [39, true], "aps.09.06": [36, true], "aps.10.00": [45, true], "aps.10.01": [46, true], "aps.10.02": [45, true], "aps.10.03": [48, true], "aps.10.04": [47, true], "aps.11.00": [40, true], "aps.11.01": [48, true], "aps.11.02": [48, true], "aps.11.03": [45, true], "aps.12.00": [51, true], "aps.12.01": [47, true], "aps.12.02": [52, true], "aps.12.03": [50, true], "aps.12.04": [49, true], "aps.12.05": [50, true], "aps.12.06": [52, true], "aps.12.07": [53, true], "aps.12.08": [53, true], "aps.12.09": [54, true], "aps.12.10": [55, true], "aps.12.11": [54, true], "aps.12.12": [54, true], "aps.12.13": [54, true], "aps.12.14": [54, true], "aps.12.15": [54, true], "aps.12.16": [55, true], "aps.12.17": [55, true], "aps.12.18": [55, true], "aps.13.00": [6, false], "aps.14.00": [51, true], "aps.14.01": [51, true], "aps.14.02": [51, true], "aps.14.03": [51, true], "aps.14.04": [51, true], "aps.14.05": [51, true], "aps.14.06": [51, true], "aps.14.07": [51, true], "aps.14.08": [51, true], "aps.14.09": [51, true], "aps.14.10": [51, true], "aps.14.11": [51, true], "aps.14.12": [51, true], "aps.14.13": [51, true], "aps.14.14": [51, true], "aps.14.15": [51, true], "aps.14.16": [51, true], "aps.14.17": [51, true], "aps.14.18": [51, true], "aps.14.19": [51, true], "aps.14.20": [51, true], "aps.14.21": [51, true], "aps.14.22": [51, true], "aps.14.23": [51, true], "aps.14.24": [51, true], "aps.14.25": [51, true], "aps.14.26": [51, true], "aps.14.27": [51, true], "aps.14.28": [51, true], "aps.14.29": [51, true], "aps.14.30": [51, true], "aps.14.31": [51, true], "aps.14.32": [51, true], "aps.14.33": [51, true], "aps.14.34": [51, true], "aps.14.35": [51, true], "aps.14.36": [51, true], "aps.14.37": [51, true], "aps.14.38": [51, true], "aps.14.39": [51, true], "aps.15.00": [42, true], "aps.15.01": [43, true], "aps.15.02": [43, true], "aps.15.03": [42, true], "aps.15.04": [43, true], "aps.15.05": [44, true], "aps.15.06": [42, true], "aps.15.07": [39, true], "aps.15.08": [41, true], "aps.15.09": [37, true], "aps.15.10": [40, true], "aps.15.11": [38, true], "aps.15.12": [43, true], "aps.15.13": [42, true], "aps.15.14": [42, true], "aps.15.15": [40, true], "aps.15.16": [43, true], "aps.15.17": [41, true], "aps.15.18": [43, true], "aps.15.19": [45, true], "aps.15.20": [44, true], "aps.15.21": [44, true], "aps.15.22": [38, true], "aps.15.23": [47, true], "aps.15.24": [45, true], "aps.15.25": [46, true], "aps.15.26": [43, true], "aps.15.27": [44, true], "aps.15.28": [43, true], "aps.15.29": [43, true], "aps.15.30": [45, true]}}, "CHA": {"total": 3321, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [44, true], "fun1.2": [48, true], "fun1.3": [49, true], "fun1.4": [60, true], "fun1.5": [82, true], "fun2.1": [46, true], "fun2.2": [73, true], "fun2.3": [83, true], "fun2.4": [75, true], "fun2.5": [81, true], "fun3.1": [44, true], "fun3.2": [46, true], "fun3.3": [60, true], "fun3.4": [67, true], "fun3.5": [85, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [57, true], "fun4.4": [74, true], "fun4.5": [82, true], "fun5.1": [55, true], "fun5.2": [62, true], "fun5.3": [51, true], "fun5.4": [56, true], "fun5.5": [58, true], "fun6.1": [58, true], "fun6.2": [45, true], "fun6.3": [55, true], "fun6.4": [59, true], "fun6.5": [63, true], "fun7.1": [6, false], "fun7.2": [7, false], "fun7.3": [8, false], "fun7.4": [6, false], "fun7.5": [10, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [52, true], "fun8.4": [56, true], "fun8.5": [61, true], "fun9.1": [45, true], "fun9.2": [49, true], "fun9.3": [54, true], "fun9.4": [51, true], "fun9.5": [52, true]}}}, {"label": "pure.ratio_soft.bracket.both", "spec": ["pure", "ratio_soft", "bracket", "both"], "APS": {"total": 7534, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [46, true], "aps.02.00": [45, true], "aps.02.01": [47, true], "aps.02.02": [49, true], "aps.02.03": [45, true], "aps.02.04": [47, true], "aps.02.05": [51, true], "aps.02.06": [51, true], "aps.02.07": [51, true], "aps.02.08": [52, true], "aps.02.09": [51, true], "aps.03.00": [53, true], "aps.03.01": [65, true], "aps.03.02": [65, true], "aps.04.00": [51, true], "aps.04.01": [48, true], "aps.04.02": [51, true], "aps.04.03": [46, true], "aps.04.04": [50, true], "aps.04.05": [44, true], "aps.04.06": [51, true], "aps.04.07": [50, true], "aps.04.08": [51, true], "aps.04.09": [51, true], "aps.04.10": [47, true], "aps.04.11": [50, true], "aps.04.12": [53, true], "aps.04.13": [53, true], "aps.05.00": [46, true], "aps.06.00": [46, true], "aps.06.01": [47, true], "aps.06.02": [45, true], "aps.06.03": [44, true], "aps.06.04": [43, true], "aps.06.05": [42, true], "aps.06.06": [39, true], "aps.06.07": [39, true], "aps.06.08": [41, true], "aps.06.09": [42, true], "aps.07.00": [45, true], "aps.07.01": [44, true], "aps.07.02": [42, true], "aps.08.00": [3, true], "aps.08.01": [44, true], "aps.08.02": [45, true], "aps.08.03": [45, true], "aps.08.04": [41, true], "aps.09.00": [46, true], "aps.09.01": [41, true], "aps.09.02": [42, true], "aps.09.03": [44, true], "aps.09.04": [39, true], "aps.09.05": [37, true], "aps.09.06": [32, true], "aps.10.00": [45, true], "aps.10.01": [47, true], "aps.10.02": [47, true], "aps.10.03": [47, true], "aps.10.04": [48, true], "aps.11.00": [44, true], "aps.11.01": [51, true], "aps.11.02": [45, true], "aps.11.03": [48, true], "aps.12.00": [51, true], "aps.12.01": [47, true], "aps.12.02": [52, true], "aps.12.03": [50, true], "aps.12.04": [45, true], "aps.12.05": [53, true], "aps.12.06": [48, true], "aps.12.07": [53, true], "aps.12.08": [53, true], "aps.12.09": [54, true], "aps.12.10": [54, true], "aps.12.11": [52, true], "aps.12.12": [54, true], "aps.12.13": [50, true], "aps.12.14": [51, true], "aps.12.15": [52, true], "aps.12.16": [55, true], "aps.12.17": [55, true], "aps.12.18": [55, true], "aps.13.00": [8, false], "aps.14.00": [52, true], "aps.14.01": [52, true], "aps.14.02": [52, true], "aps.14.03": [52, true], "aps.14.04": [52, true], "aps.14.05": [52, true], "aps.14.06": [52, true], "aps.14.07": [52, true], "aps.14.08": [52, true], "aps.14.09": [52, true], "aps.14.10": [52, true], "aps.14.11": [52, true], "aps.14.12": [52, true], "aps.14.13": [52, true], "aps.14.14": [52, true], "aps.14.15": [52, true], "aps.14.16": [52, true], "aps.14.17": [52, true], "aps.14.18": [52, true], "aps.14.19": [52, true], "aps.14.20": [52, true], "aps.14.21": [52, true], "aps.14.22": [52, true], "aps.14.23": [52, true], "aps.14.24": [52, true], "aps.14.25": [52, true], "aps.14.26": [52, true], "aps.14.27": [52, true], "aps.14.28": [52, true], "aps.14.29": [52, true], "aps.14.30": [52, true], "aps.14.31": [52, true], "aps.14.32": [52, true], "aps.14.33": [52, true], "aps.14.34": [52, true], "aps.14.35": [52, true], "aps.14.36": [52, true], "aps.14.37": [52, true], "aps.14.38": [52, true], "aps.14.39": [52, true], "aps.15.00": [39, true], "aps.15.01": [44, true], "aps.15.02": [45, true], "aps.15.03": [46, true], "aps.15.04": [46, true], "aps.15.05": [45, true], "aps.15.06": [45, true], "aps.15.07": [45, true], "aps.15.08": [44, true], "aps.15.09": [45, true], "aps.15.10": [44, true], "aps.15.11": [44, true], "aps.15.12": [44, true], "aps.15.13": [45, true], "aps.15.14": [44, true], "aps.15.15": [45, true], "aps.15.16": [45, true], "aps.15.17": [45, true], "aps.15.18": [45, true], "aps.15.19": [43, true], "aps.15.20": [41, true], "aps.15.21": [44, true], "aps.15.22": [46, true], "aps.15.23": [44, true], "aps.15.24": [44, true], "aps.15.25": [43, true], "aps.15.26": [40, true], "aps.15.27": [44, true], "aps.15.28": [45, true], "aps.15.29": [45, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3315, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [44, true], "fun1.2": [50, true], "fun1.3": [50, true], "fun1.4": [56, true], "fun1.5": [65, true], "fun2.1": [47, true], "fun2.2": [72, true], "fun2.3": [85, true], "fun2.4": [77, true], "fun2.5": [87, true], "fun3.1": [52, true], "fun3.2": [53, true], "fun3.3": [53, true], "fun3.4": [63, true], "fun3.5": [78, true], "fun4.1": [50, true], "fun4.2": [61, true], "fun4.3": [52, true], "fun4.4": [59, true], "fun4.5": [69, true], "fun5.1": [58, true], "fun5.2": [56, true], "fun5.3": [58, true], "fun5.4": [64, true], "fun5.5": [65, true], "fun6.1": [59, true], "fun6.2": [50, true], "fun6.3": [54, true], "fun6.4": [57, true], "fun6.5": [58, true], "fun7.1": [8, false], "fun7.2": [7, false], "fun7.3": [9, false], "fun7.4": [6, false], "fun7.5": [12, false], "fun8.1": [47, true], "fun8.2": [50, true], "fun8.3": [53, true], "fun8.4": [52, true], "fun8.5": [58, true], "fun9.1": [47, true], "fun9.2": [49, true], "fun9.3": [54, true], "fun9.4": [52, true], "fun9.5": [51, true]}}}, {"label": "pure.ratio_soft.bracket.none", "spec": ["pure", "ratio_soft", "bracket", "none"], "APS": {"total": 11999, "solved": 131, "n": 154, "over": 4, "per": {"aps.01.00": [56, true], "aps.02.00": [60, true], "aps.02.01": [59, true], "aps.02.02": [62, true], "aps.02.03": [60, true], "aps.02.04": [61, true], "aps.02.05": [64, true], "aps.02.06": [64, true], "aps.02.07": [65, true], "aps.02.08": [65, true], "aps.02.09": [65, true], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [59, true], "aps.06.00": [60, true], "aps.06.01": [59, true], "aps.06.02": [50, true], "aps.06.03": [56, true], "aps.06.04": [57, true], "aps.06.05": [55, true], "aps.06.06": [51, true], "aps.06.07": [52, true], "aps.06.08": [53, true], "aps.06.09": [53, true], "aps.07.00": [55, true], "aps.07.01": [53, true], "aps.07.02": [51, true], "aps.08.00": [60, true], "aps.08.01": [58, true], "aps.08.02": [59, true], "aps.08.03": [87, true], "aps.08.04": [114, true], "aps.09.00": [56, true], "aps.09.01": [56, true], "aps.09.02": [53, true], "aps.09.03": [52, true], "aps.09.04": [51, true], "aps.09.05": [47, true], "aps.09.06": [45, true], "aps.10.00": [60, true], "aps.10.01": [54, true], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [128, true], "aps.11.03": [97, true], "aps.12.00": [64, true], "aps.12.01": [64, true], "aps.12.02": [63, true], "aps.12.03": [61, true], "aps.12.04": [57, true], "aps.12.05": [48, true], "aps.12.06": [19, true], "aps.12.07": [23, true], "aps.12.08": [25, true], "aps.12.09": [28, true], "aps.12.10": [30, true], "aps.12.11": [32, true], "aps.12.12": [33, true], "aps.12.13": [35, true], "aps.12.14": [37, true], "aps.12.15": [38, true], "aps.12.16": [39, true], "aps.12.17": [40, true], "aps.12.18": [40, true], "aps.13.00": [6, false], "aps.14.00": [65, true], "aps.14.01": [65, true], "aps.14.02": [65, true], "aps.14.03": [65, true], "aps.14.04": [65, true], "aps.14.05": [65, true], "aps.14.06": [65, true], "aps.14.07": [65, true], "aps.14.08": [65, true], "aps.14.09": [65, true], "aps.14.10": [65, true], "aps.14.11": [65, true], "aps.14.12": [65, true], "aps.14.13": [65, true], "aps.14.14": [65, true], "aps.14.15": [65, true], "aps.14.16": [65, true], "aps.14.17": [65, true], "aps.14.18": [65, true], "aps.14.19": [65, true], "aps.14.20": [65, true], "aps.14.21": [65, true], "aps.14.22": [65, true], "aps.14.23": [65, true], "aps.14.24": [65, true], "aps.14.25": [65, true], "aps.14.26": [65, true], "aps.14.27": [65, true], "aps.14.28": [65, true], "aps.14.29": [65, true], "aps.14.30": [65, true], "aps.14.31": [65, true], "aps.14.32": [65, true], "aps.14.33": [65, true], "aps.14.34": [65, true], "aps.14.35": [65, true], "aps.14.36": [65, true], "aps.14.37": [65, true], "aps.14.38": [65, true], "aps.14.39": [65, true], "aps.15.00": [51, true], "aps.15.01": [51, true], "aps.15.02": [51, true], "aps.15.03": [51, true], "aps.15.04": [50, true], "aps.15.05": [50, true], "aps.15.06": [49, true], "aps.15.07": [48, true], "aps.15.08": [46, true], "aps.15.09": [43, true], "aps.15.10": [42, true], "aps.15.11": [47, true], "aps.15.12": [48, true], "aps.15.13": [49, true], "aps.15.14": [50, true], "aps.15.15": [50, true], "aps.15.16": [51, true], "aps.15.17": [51, true], "aps.15.18": [51, true], "aps.15.19": [51, true], "aps.15.20": [52, true], "aps.15.21": [49, true], "aps.15.22": [47, true], "aps.15.23": [51, true], "aps.15.24": [51, true], "aps.15.25": [48, true], "aps.15.26": [46, true], "aps.15.27": [37, true], "aps.15.28": [47, true], "aps.15.29": [47, true], "aps.15.30": [46, true]}}, "CHA": {"total": 7988, "solved": 8, "n": 45, "over": 1, "per": {"fun1.1": [55, true], "fun1.2": [190, true], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [36, true], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [54, true], "fun2.5": [91, true], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [6, false], "fun7.2": [7, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [60, true], "fun9.2": [49, true], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [53, true]}}}, {"label": "pure.ratio_soft.start.project", "spec": ["pure", "ratio_soft", "start", "project"], "APS": {"total": 12706, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [38, true], "aps.02.00": [45, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [94, true], "aps.03.01": [47, true], "aps.03.02": [47, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [30, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [88, true], "aps.04.07": [52, true], "aps.04.08": [88, true], "aps.04.09": [51, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [31, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [82, true], "aps.06.03": [83, true], "aps.06.04": [45, true], "aps.06.05": [45, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [46, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [82, true], "aps.07.02": [82, true], "aps.08.00": [36, true], "aps.08.01": [82, true], "aps.08.02": [83, true], "aps.08.03": [82, true], "aps.08.04": [83, true], "aps.09.00": [83, true], "aps.09.01": [83, true], "aps.09.02": [82, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [83, true], "aps.10.00": [82, true], "aps.10.01": [83, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [37, true], "aps.11.03": [82, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [97, true], "aps.12.03": [53, true], "aps.12.04": [33, true], "aps.12.05": [97, true], "aps.12.06": [19, true], "aps.12.07": [23, true], "aps.12.08": [23, true], "aps.12.09": [17, true], "aps.12.10": [97, true], "aps.12.11": [97, true], "aps.12.12": [96, true], "aps.12.13": [97, true], "aps.12.14": [97, true], "aps.12.15": [96, true], "aps.12.16": [97, true], "aps.12.17": [97, true], "aps.12.18": [97, true], "aps.13.00": [52, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [31, true], "aps.15.01": [38, true], "aps.15.02": [46, true], "aps.15.03": [55, true], "aps.15.04": [65, true], "aps.15.05": [103, true], "aps.15.06": [103, true], "aps.15.07": [103, true], "aps.15.08": [103, true], "aps.15.09": [102, true], "aps.15.10": [102, true], "aps.15.11": [102, true], "aps.15.12": [102, true], "aps.15.13": [103, true], "aps.15.14": [103, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [51, true], "aps.15.18": [44, true], "aps.15.19": [38, true], "aps.15.20": [32, true], "aps.15.21": [102, true], "aps.15.22": [103, true], "aps.15.23": [103, true], "aps.15.24": [103, true], "aps.15.25": [103, true], "aps.15.26": [102, true], "aps.15.27": [63, true], "aps.15.28": [102, true], "aps.15.29": [103, true], "aps.15.30": [69, true]}}, "CHA": {"total": 4954, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [112, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [150, true], "fun2.5": [163, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [152, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [52, false], "fun7.2": [52, false], "fun7.3": [54, false], "fun7.4": [57, false], "fun7.5": [59, false], "fun8.1": [27, true], "fun8.2": [38, true], "fun8.3": [91, true], "fun8.4": [93, true], "fun8.5": [97, true], "fun9.1": [22, true], "fun9.2": [86, true], "fun9.3": [90, true], "fun9.4": [93, true], "fun9.5": [96, true]}}}, {"label": "pure.ratio_soft.bracket.project", "spec": ["pure", "ratio_soft", "bracket", "project"], "APS": {"total": 9392, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [56, true], "aps.02.00": [60, true], "aps.02.01": [59, true], "aps.02.02": [62, true], "aps.02.03": [60, true], "aps.02.04": [61, true], "aps.02.05": [64, true], "aps.02.06": [64, true], "aps.02.07": [65, true], "aps.02.08": [65, true], "aps.02.09": [65, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [59, true], "aps.06.00": [60, true], "aps.06.01": [59, true], "aps.06.02": [50, true], "aps.06.03": [56, true], "aps.06.04": [57, true], "aps.06.05": [55, true], "aps.06.06": [51, true], "aps.06.07": [52, true], "aps.06.08": [53, true], "aps.06.09": [53, true], "aps.07.00": [55, true], "aps.07.01": [53, true], "aps.07.02": [51, true], "aps.08.00": [60, true], "aps.08.01": [58, true], "aps.08.02": [59, true], "aps.08.03": [67, true], "aps.08.04": [74, true], "aps.09.00": [56, true], "aps.09.01": [56, true], "aps.09.02": [53, true], "aps.09.03": [52, true], "aps.09.04": [51, true], "aps.09.05": [47, true], "aps.09.06": [45, true], "aps.10.00": [60, true], "aps.10.01": [54, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [82, true], "aps.11.03": [71, true], "aps.12.00": [64, true], "aps.12.01": [64, true], "aps.12.02": [63, true], "aps.12.03": [61, true], "aps.12.04": [57, true], "aps.12.05": [48, true], "aps.12.06": [19, true], "aps.12.07": [23, true], "aps.12.08": [25, true], "aps.12.09": [28, true], "aps.12.10": [30, true], "aps.12.11": [32, true], "aps.12.12": [33, true], "aps.12.13": [35, true], "aps.12.14": [37, true], "aps.12.15": [38, true], "aps.12.16": [39, true], "aps.12.17": [40, true], "aps.12.18": [40, true], "aps.13.00": [6, false], "aps.14.00": [65, true], "aps.14.01": [65, true], "aps.14.02": [65, true], "aps.14.03": [65, true], "aps.14.04": [65, true], "aps.14.05": [65, true], "aps.14.06": [65, true], "aps.14.07": [65, true], "aps.14.08": [65, true], "aps.14.09": [65, true], "aps.14.10": [65, true], "aps.14.11": [65, true], "aps.14.12": [65, true], "aps.14.13": [65, true], "aps.14.14": [65, true], "aps.14.15": [65, true], "aps.14.16": [65, true], "aps.14.17": [65, true], "aps.14.18": [65, true], "aps.14.19": [65, true], "aps.14.20": [65, true], "aps.14.21": [65, true], "aps.14.22": [65, true], "aps.14.23": [65, true], "aps.14.24": [65, true], "aps.14.25": [65, true], "aps.14.26": [65, true], "aps.14.27": [65, true], "aps.14.28": [65, true], "aps.14.29": [65, true], "aps.14.30": [65, true], "aps.14.31": [65, true], "aps.14.32": [65, true], "aps.14.33": [65, true], "aps.14.34": [65, true], "aps.14.35": [65, true], "aps.14.36": [65, true], "aps.14.37": [65, true], "aps.14.38": [65, true], "aps.14.39": [65, true], "aps.15.00": [51, true], "aps.15.01": [51, true], "aps.15.02": [51, true], "aps.15.03": [51, true], "aps.15.04": [50, true], "aps.15.05": [50, true], "aps.15.06": [49, true], "aps.15.07": [48, true], "aps.15.08": [46, true], "aps.15.09": [43, true], "aps.15.10": [42, true], "aps.15.11": [47, true], "aps.15.12": [48, true], "aps.15.13": [49, true], "aps.15.14": [50, true], "aps.15.15": [50, true], "aps.15.16": [51, true], "aps.15.17": [51, true], "aps.15.18": [51, true], "aps.15.19": [51, true], "aps.15.20": [52, true], "aps.15.21": [49, true], "aps.15.22": [47, true], "aps.15.23": [51, true], "aps.15.24": [51, true], "aps.15.25": [48, true], "aps.15.26": [46, true], "aps.15.27": [37, true], "aps.15.28": [47, true], "aps.15.29": [47, true], "aps.15.30": [46, true]}}, "CHA": {"total": 4763, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [55, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [112, true], "fun1.5": [152, true], "fun2.1": [36, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [54, true], "fun2.5": [91, true], "fun3.1": [88, true], "fun3.2": [92, true], "fun3.3": [112, true], "fun3.4": [124, true], "fun3.5": [152, true], "fun4.1": [76, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [6, false], "fun7.2": [7, false], "fun7.3": [90, false], "fun7.4": [58, false], "fun7.5": [57, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [60, true], "fun9.2": [64, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [53, true]}}}, {"label": "pure.ratio_soft.bracket.safe", "spec": ["pure", "ratio_soft", "bracket", "safe"], "APS": {"total": 8635, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [56, true], "aps.02.00": [61, true], "aps.02.01": [59, true], "aps.02.02": [63, true], "aps.02.03": [57, true], "aps.02.04": [57, true], "aps.02.05": [62, true], "aps.02.06": [61, true], "aps.02.07": [58, true], "aps.02.08": [62, true], "aps.02.09": [63, true], "aps.03.00": [59, true], "aps.03.01": [66, true], "aps.03.02": [66, true], "aps.04.00": [67, true], "aps.04.01": [63, true], "aps.04.02": [64, true], "aps.04.03": [65, true], "aps.04.04": [66, true], "aps.04.05": [61, true], "aps.04.06": [52, true], "aps.04.07": [32, true], "aps.04.08": [48, true], "aps.04.09": [75, true], "aps.04.10": [60, true], "aps.04.11": [62, true], "aps.04.12": [62, true], "aps.04.13": [55, true], "aps.05.00": [60, true], "aps.06.00": [58, true], "aps.06.01": [58, true], "aps.06.02": [57, true], "aps.06.03": [52, true], "aps.06.04": [53, true], "aps.06.05": [52, true], "aps.06.06": [54, true], "aps.06.07": [50, true], "aps.06.08": [50, true], "aps.06.09": [51, true], "aps.07.00": [55, true], "aps.07.01": [54, true], "aps.07.02": [52, true], "aps.08.00": [3, true], "aps.08.01": [55, true], "aps.08.02": [60, true], "aps.08.03": [68, true], "aps.08.04": [78, true], "aps.09.00": [57, true], "aps.09.01": [53, true], "aps.09.02": [54, true], "aps.09.03": [54, true], "aps.09.04": [49, true], "aps.09.05": [45, true], "aps.09.06": [36, true], "aps.10.00": [58, true], "aps.10.01": [40, true], "aps.10.02": [55, true], "aps.10.03": [36, true], "aps.10.04": [53, true], "aps.11.00": [52, true], "aps.11.01": [50, true], "aps.11.02": [61, true], "aps.11.03": [72, true], "aps.12.00": [64, true], "aps.12.01": [64, true], "aps.12.02": [63, true], "aps.12.03": [61, true], "aps.12.04": [57, true], "aps.12.05": [52, true], "aps.12.06": [19, true], "aps.12.07": [23, true], "aps.12.08": [26, true], "aps.12.09": [29, true], "aps.12.10": [30, true], "aps.12.11": [32, true], "aps.12.12": [34, true], "aps.12.13": [35, true], "aps.12.14": [36, true], "aps.12.15": [37, true], "aps.12.16": [39, true], "aps.12.17": [40, true], "aps.12.18": [40, true], "aps.13.00": [7, false], "aps.14.00": [65, true], "aps.14.01": [65, true], "aps.14.02": [65, true], "aps.14.03": [65, true], "aps.14.04": [65, true], "aps.14.05": [65, true], "aps.14.06": [65, true], "aps.14.07": [65, true], "aps.14.08": [65, true], "aps.14.09": [65, true], "aps.14.10": [65, true], "aps.14.11": [65, true], "aps.14.12": [65, true], "aps.14.13": [65, true], "aps.14.14": [65, true], "aps.14.15": [65, true], "aps.14.16": [65, true], "aps.14.17": [65, true], "aps.14.18": [65, true], "aps.14.19": [65, true], "aps.14.20": [65, true], "aps.14.21": [65, true], "aps.14.22": [65, true], "aps.14.23": [65, true], "aps.14.24": [65, true], "aps.14.25": [65, true], "aps.14.26": [65, true], "aps.14.27": [65, true], "aps.14.28": [65, true], "aps.14.29": [65, true], "aps.14.30": [65, true], "aps.14.31": [65, true], "aps.14.32": [65, true], "aps.14.33": [65, true], "aps.14.34": [65, true], "aps.14.35": [65, true], "aps.14.36": [65, true], "aps.14.37": [65, true], "aps.14.38": [65, true], "aps.14.39": [65, true], "aps.15.00": [51, true], "aps.15.01": [51, true], "aps.15.02": [52, true], "aps.15.03": [52, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [52, true], "aps.15.07": [52, true], "aps.15.08": [52, true], "aps.15.09": [52, true], "aps.15.10": [51, true], "aps.15.11": [51, true], "aps.15.12": [49, true], "aps.15.13": [42, true], "aps.15.14": [49, true], "aps.15.15": [50, true], "aps.15.16": [51, true], "aps.15.17": [52, true], "aps.15.18": [52, true], "aps.15.19": [52, true], "aps.15.20": [53, true], "aps.15.21": [48, true], "aps.15.22": [50, true], "aps.15.23": [50, true], "aps.15.24": [46, true], "aps.15.25": [45, true], "aps.15.26": [45, true], "aps.15.27": [39, true], "aps.15.28": [45, true], "aps.15.29": [44, true], "aps.15.30": [43, true]}}, "CHA": {"total": 3998, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [55, true], "fun1.2": [55, true], "fun1.3": [65, true], "fun1.4": [69, true], "fun1.5": [77, true], "fun2.1": [36, true], "fun2.2": [100, true], "fun2.3": [105, true], "fun2.4": [89, true], "fun2.5": [99, true], "fun3.1": [74, true], "fun3.2": [84, true], "fun3.3": [82, true], "fun3.4": [78, true], "fun3.5": [105, true], "fun4.1": [69, true], "fun4.2": [70, true], "fun4.3": [74, true], "fun4.4": [79, true], "fun4.5": [92, true], "fun5.1": [83, true], "fun5.2": [76, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [76, true], "fun6.2": [60, true], "fun6.3": [69, true], "fun6.4": [71, true], "fun6.5": [75, true], "fun7.1": [7, false], "fun7.2": [7, false], "fun7.3": [11, false], "fun7.4": [13, false], "fun7.5": [16, false], "fun8.1": [58, true], "fun8.2": [62, true], "fun8.3": [67, true], "fun8.4": [73, true], "fun8.5": [79, true], "fun9.1": [59, true], "fun9.2": [64, true], "fun9.3": [62, true], "fun9.4": [63, true], "fun9.5": [64, true]}}}, {"label": "pure.ratio_soft.derived.none", "spec": ["pure", "ratio_soft", "derived", "none"], "APS": {"total": 5967, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [27, true], "aps.02.00": [32, true], "aps.02.01": [33, true], "aps.02.02": [33, true], "aps.02.03": [35, true], "aps.02.04": [34, true], "aps.02.05": [33, true], "aps.02.06": [35, true], "aps.02.07": [36, true], "aps.02.08": [36, true], "aps.02.09": [36, true], "aps.03.00": [43, true], "aps.03.01": [43, true], "aps.03.02": [45, true], "aps.04.00": [36, true], "aps.04.01": [34, true], "aps.04.02": [35, true], "aps.04.03": [35, true], "aps.04.04": [37, true], "aps.04.05": [34, true], "aps.04.06": [36, true], "aps.04.07": [36, true], "aps.04.08": [36, true], "aps.04.09": [35, true], "aps.04.10": [41, true], "aps.04.11": [40, true], "aps.04.12": [40, true], "aps.04.13": [41, true], "aps.05.00": [32, true], "aps.06.00": [32, true], "aps.06.01": [29, true], "aps.06.02": [32, true], "aps.06.03": [33, true], "aps.06.04": [33, true], "aps.06.05": [34, true], "aps.06.06": [34, true], "aps.06.07": [36, true], "aps.06.08": [35, true], "aps.06.09": [36, true], "aps.07.00": [32, true], "aps.07.01": [29, true], "aps.07.02": [29, true], "aps.08.00": [31, true], "aps.08.01": [31, true], "aps.08.02": [32, true], "aps.08.03": [29, true], "aps.08.04": [32, true], "aps.09.00": [31, true], "aps.09.01": [33, true], "aps.09.02": [29, true], "aps.09.03": [29, true], "aps.09.04": [30, true], "aps.09.05": [29, true], "aps.09.06": [28, true], "aps.10.00": [32, true], "aps.10.01": [31, true], "aps.10.02": [30, true], "aps.10.03": [30, true], "aps.10.04": [29, true], "aps.11.00": [34, true], "aps.11.01": [37, true], "aps.11.02": [39, true], "aps.11.03": [38, true], "aps.12.00": [35, true], "aps.12.01": [34, true], "aps.12.02": [34, true], "aps.12.03": [35, true], "aps.12.04": [36, true], "aps.12.05": [36, true], "aps.12.06": [36, true], "aps.12.07": [35, true], "aps.12.08": [38, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [36, true], "aps.12.13": [36, true], "aps.12.14": [35, true], "aps.12.15": [34, true], "aps.12.16": [34, true], "aps.12.17": [35, true], "aps.12.18": [36, true], "aps.13.00": [200, false], "aps.14.00": [40, true], "aps.14.01": [40, true], "aps.14.02": [40, true], "aps.14.03": [40, true], "aps.14.04": [40, true], "aps.14.05": [40, true], "aps.14.06": [40, true], "aps.14.07": [40, true], "aps.14.08": [40, true], "aps.14.09": [40, true], "aps.14.10": [40, true], "aps.14.11": [40, true], "aps.14.12": [40, true], "aps.14.13": [40, true], "aps.14.14": [40, true], "aps.14.15": [40, true], "aps.14.16": [40, true], "aps.14.17": [40, true], "aps.14.18": [40, true], "aps.14.19": [40, true], "aps.14.20": [40, true], "aps.14.21": [40, true], "aps.14.22": [40, true], "aps.14.23": [40, true], "aps.14.24": [40, true], "aps.14.25": [40, true], "aps.14.26": [40, true], "aps.14.27": [40, true], "aps.14.28": [40, true], "aps.14.29": [40, true], "aps.14.30": [40, true], "aps.14.31": [40, true], "aps.14.32": [40, true], "aps.14.33": [40, true], "aps.14.34": [40, true], "aps.14.35": [40, true], "aps.14.36": [40, true], "aps.14.37": [40, true], "aps.14.38": [40, true], "aps.14.39": [40, true], "aps.15.00": [45, true], "aps.15.01": [45, true], "aps.15.02": [44, true], "aps.15.03": [43, true], "aps.15.04": [40, true], "aps.15.05": [41, true], "aps.15.06": [42, true], "aps.15.07": [42, true], "aps.15.08": [41, true], "aps.15.09": [41, true], "aps.15.10": [42, true], "aps.15.11": [43, true], "aps.15.12": [43, true], "aps.15.13": [43, true], "aps.15.14": [44, true], "aps.15.15": [44, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [44, true], "aps.15.21": [47, true], "aps.15.22": [44, true], "aps.15.23": [48, true], "aps.15.24": [40, true], "aps.15.25": [45, true], "aps.15.26": [46, true], "aps.15.27": [47, true], "aps.15.28": [45, true], "aps.15.29": [43, true], "aps.15.30": [46, true]}}, "CHA": {"total": 5994, "solved": 23, "n": 45, "over": 4, "per": {"fun1.1": [30, true], "fun1.2": [35, true], "fun1.3": [35, true], "fun1.4": [51, true], "fun1.5": [74, true], "fun2.1": [31, true], "fun2.2": [124, true], "fun2.3": [103, true], "fun2.4": [106, true], "fun2.5": [118, true], "fun3.1": [143, true], "fun3.2": [148, true], "fun3.3": [181, true], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [35, true], "fun8.2": [38, true], "fun8.3": [41, true], "fun8.4": [47, true], "fun8.5": [53, true], "fun9.1": [31, true], "fun9.2": [31, true], "fun9.3": [39, true], "fun9.4": [56, true], "fun9.5": [44, true]}}}, {"label": "pure.ratio_soft.derived.step", "spec": ["pure", "ratio_soft", "derived", "step"], "APS": {"total": 5822, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [27, true], "aps.02.00": [35, true], "aps.02.01": [33, true], "aps.02.02": [35, true], "aps.02.03": [31, true], "aps.02.04": [34, true], "aps.02.05": [35, true], "aps.02.06": [35, true], "aps.02.07": [34, true], "aps.02.08": [35, true], "aps.02.09": [35, true], "aps.03.00": [34, true], "aps.03.01": [40, true], "aps.03.02": [42, true], "aps.04.00": [38, true], "aps.04.01": [35, true], "aps.04.02": [36, true], "aps.04.03": [34, true], "aps.04.04": [34, true], "aps.04.05": [33, true], "aps.04.06": [36, true], "aps.04.07": [35, true], "aps.04.08": [37, true], "aps.04.09": [38, true], "aps.04.10": [37, true], "aps.04.11": [36, true], "aps.04.12": [33, true], "aps.04.13": [34, true], "aps.05.00": [33, true], "aps.06.00": [32, true], "aps.06.01": [28, true], "aps.06.02": [32, true], "aps.06.03": [33, true], "aps.06.04": [33, true], "aps.06.05": [34, true], "aps.06.06": [34, true], "aps.06.07": [36, true], "aps.06.08": [36, true], "aps.06.09": [35, true], "aps.07.00": [32, true], "aps.07.01": [30, true], "aps.07.02": [30, true], "aps.08.00": [3, true], "aps.08.01": [30, true], "aps.08.02": [32, true], "aps.08.03": [28, true], "aps.08.04": [31, true], "aps.09.00": [30, true], "aps.09.01": [33, true], "aps.09.02": [28, true], "aps.09.03": [29, true], "aps.09.04": [30, true], "aps.09.05": [29, true], "aps.09.06": [28, true], "aps.10.00": [32, true], "aps.10.01": [27, true], "aps.10.02": [31, true], "aps.10.03": [32, true], "aps.10.04": [31, true], "aps.11.00": [31, true], "aps.11.01": [32, true], "aps.11.02": [35, true], "aps.11.03": [29, true], "aps.12.00": [35, true], "aps.12.01": [34, true], "aps.12.02": [34, true], "aps.12.03": [35, true], "aps.12.04": [36, true], "aps.12.05": [36, true], "aps.12.06": [36, true], "aps.12.07": [34, true], "aps.12.08": [38, true], "aps.12.09": [38, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [36, true], "aps.12.13": [36, true], "aps.12.14": [35, true], "aps.12.15": [33, true], "aps.12.16": [34, true], "aps.12.17": [36, true], "aps.12.18": [36, true], "aps.13.00": [13, false], "aps.14.00": [38, true], "aps.14.01": [38, true], "aps.14.02": [38, true], "aps.14.03": [38, true], "aps.14.04": [38, true], "aps.14.05": [38, true], "aps.14.06": [38, true], "aps.14.07": [38, true], "aps.14.08": [38, true], "aps.14.09": [38, true], "aps.14.10": [38, true], "aps.14.11": [38, true], "aps.14.12": [38, true], "aps.14.13": [38, true], "aps.14.14": [38, true], "aps.14.15": [38, true], "aps.14.16": [38, true], "aps.14.17": [38, true], "aps.14.18": [38, true], "aps.14.19": [38, true], "aps.14.20": [38, true], "aps.14.21": [38, true], "aps.14.22": [38, true], "aps.14.23": [38, true], "aps.14.24": [38, true], "aps.14.25": [38, true], "aps.14.26": [38, true], "aps.14.27": [38, true], "aps.14.28": [38, true], "aps.14.29": [38, true], "aps.14.30": [38, true], "aps.14.31": [38, true], "aps.14.32": [38, true], "aps.14.33": [38, true], "aps.14.34": [38, true], "aps.14.35": [38, true], "aps.14.36": [38, true], "aps.14.37": [38, true], "aps.14.38": [38, true], "aps.14.39": [38, true], "aps.15.00": [46, true], "aps.15.01": [46, true], "aps.15.02": [45, true], "aps.15.03": [44, true], "aps.15.04": [43, true], "aps.15.05": [42, true], "aps.15.06": [44, true], "aps.15.07": [44, true], "aps.15.08": [44, true], "aps.15.09": [43, true], "aps.15.10": [42, true], "aps.15.11": [44, true], "aps.15.12": [44, true], "aps.15.13": [44, true], "aps.15.14": [44, true], "aps.15.15": [44, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [44, true], "aps.15.21": [43, true], "aps.15.22": [46, true], "aps.15.23": [47, true], "aps.15.24": [44, true], "aps.15.25": [46, true], "aps.15.26": [46, true], "aps.15.27": [47, true], "aps.15.28": [45, true], "aps.15.29": [43, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3704, "solved": 40, "n": 45, "over": 8, "per": {"fun1.1": [30, true], "fun1.2": [35, true], "fun1.3": [30, true], "fun1.4": [36, true], "fun1.5": [77, true], "fun2.1": [32, true], "fun2.2": [52, true], "fun2.3": [64, true], "fun2.4": [75, true], "fun2.5": [82, true], "fun3.1": [102, true], "fun3.2": [105, true], "fun3.3": [122, true], "fun3.4": [102, true], "fun3.5": [162, true], "fun4.1": [83, true], "fun4.2": [85, true], "fun4.3": [100, true], "fun4.4": [116, true], "fun4.5": [141, true], "fun5.1": [88, true], "fun5.2": [93, true], "fun5.3": [94, true], "fun5.4": [99, true], "fun5.5": [100, true], "fun6.1": [49, true], "fun6.2": [39, true], "fun6.3": [49, true], "fun6.4": [48, true], "fun6.5": [54, true], "fun7.1": [13, false], "fun7.2": [12, false], "fun7.3": [15, false], "fun7.4": [12, false], "fun7.5": [12, false], "fun8.1": [33, true], "fun8.2": [32, true], "fun8.3": [35, true], "fun8.4": [38, true], "fun8.5": [41, true], "fun9.1": [31, true], "fun9.2": [33, true], "fun9.3": [38, true], "fun9.4": [40, true], "fun9.5": [39, true]}}}, {"label": "pure.ratio_soft.derived.bracket", "spec": ["pure", "ratio_soft", "derived", "bracket"], "APS": {"total": 6070, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [31, true], "aps.02.00": [35, true], "aps.02.01": [33, true], "aps.02.02": [35, true], "aps.02.03": [35, true], "aps.02.04": [35, true], "aps.02.05": [34, true], "aps.02.06": [36, true], "aps.02.07": [36, true], "aps.02.08": [36, true], "aps.02.09": [35, true], "aps.03.00": [40, true], "aps.03.01": [40, true], "aps.03.02": [40, true], "aps.04.00": [35, true], "aps.04.01": [36, true], "aps.04.02": [37, true], "aps.04.03": [37, true], "aps.04.04": [37, true], "aps.04.05": [35, true], "aps.04.06": [37, true], "aps.04.07": [36, true], "aps.04.08": [37, true], "aps.04.09": [38, true], "aps.04.10": [38, true], "aps.04.11": [38, true], "aps.04.12": [37, true], "aps.04.13": [36, true], "aps.05.00": [33, true], "aps.06.00": [33, true], "aps.06.01": [33, true], "aps.06.02": [33, true], "aps.06.03": [33, true], "aps.06.04": [33, true], "aps.06.05": [34, true], "aps.06.06": [35, true], "aps.06.07": [34, true], "aps.06.08": [35, true], "aps.06.09": [33, true], "aps.07.00": [34, true], "aps.07.01": [31, true], "aps.07.02": [30, true], "aps.08.00": [32, true], "aps.08.01": [32, true], "aps.08.02": [32, true], "aps.08.03": [32, true], "aps.08.04": [30, true], "aps.09.00": [27, true], "aps.09.01": [33, true], "aps.09.02": [32, true], "aps.09.03": [31, true], "aps.09.04": [31, true], "aps.09.05": [29, true], "aps.09.06": [29, true], "aps.10.00": [31, true], "aps.10.01": [32, true], "aps.10.02": [33, true], "aps.10.03": [33, true], "aps.10.04": [33, true], "aps.11.00": [30, true], "aps.11.01": [36, true], "aps.11.02": [33, true], "aps.11.03": [31, true], "aps.12.00": [34, true], "aps.12.01": [36, true], "aps.12.02": [37, true], "aps.12.03": [38, true], "aps.12.04": [38, true], "aps.12.05": [38, true], "aps.12.06": [38, true], "aps.12.07": [38, true], "aps.12.08": [37, true], "aps.12.09": [38, true], "aps.12.10": [38, true], "aps.12.11": [37, true], "aps.12.12": [36, true], "aps.12.13": [38, true], "aps.12.14": [38, true], "aps.12.15": [36, true], "aps.12.16": [37, true], "aps.12.17": [33, true], "aps.12.18": [33, true], "aps.13.00": [9, false], "aps.14.00": [41, true], "aps.14.01": [41, true], "aps.14.02": [41, true], "aps.14.03": [41, true], "aps.14.04": [41, true], "aps.14.05": [41, true], "aps.14.06": [41, true], "aps.14.07": [41, true], "aps.14.08": [41, true], "aps.14.09": [41, true], "aps.14.10": [41, true], "aps.14.11": [41, true], "aps.14.12": [41, true], "aps.14.13": [41, true], "aps.14.14": [41, true], "aps.14.15": [41, true], "aps.14.16": [41, true], "aps.14.17": [41, true], "aps.14.18": [41, true], "aps.14.19": [41, true], "aps.14.20": [41, true], "aps.14.21": [41, true], "aps.14.22": [41, true], "aps.14.23": [41, true], "aps.14.24": [41, true], "aps.14.25": [41, true], "aps.14.26": [41, true], "aps.14.27": [41, true], "aps.14.28": [41, true], "aps.14.29": [41, true], "aps.14.30": [41, true], "aps.14.31": [41, true], "aps.14.32": [41, true], "aps.14.33": [41, true], "aps.14.34": [41, true], "aps.14.35": [41, true], "aps.14.36": [41, true], "aps.14.37": [41, true], "aps.14.38": [41, true], "aps.14.39": [41, true], "aps.15.00": [46, true], "aps.15.01": [46, true], "aps.15.02": [46, true], "aps.15.03": [45, true], "aps.15.04": [41, true], "aps.15.05": [41, true], "aps.15.06": [45, true], "aps.15.07": [44, true], "aps.15.08": [45, true], "aps.15.09": [46, true], "aps.15.10": [46, true], "aps.15.11": [45, true], "aps.15.12": [45, true], "aps.15.13": [45, true], "aps.15.14": [41, true], "aps.15.15": [46, true], "aps.15.16": [44, true], "aps.15.17": [45, true], "aps.15.18": [45, true], "aps.15.19": [45, true], "aps.15.20": [45, true], "aps.15.21": [46, true], "aps.15.22": [47, true], "aps.15.23": [46, true], "aps.15.24": [46, true], "aps.15.25": [45, true], "aps.15.26": [48, true], "aps.15.27": [44, true], "aps.15.28": [46, true], "aps.15.29": [47, true], "aps.15.30": [39, true]}}, "CHA": {"total": 3167, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [29, true], "fun1.2": [36, true], "fun1.3": [40, true], "fun1.4": [48, true], "fun1.5": [74, true], "fun2.1": [33, true], "fun2.2": [59, true], "fun2.3": [69, true], "fun2.4": [78, true], "fun2.5": [81, true], "fun3.1": [54, true], "fun3.2": [56, true], "fun3.3": [68, true], "fun3.4": [73, true], "fun3.5": [95, true], "fun4.1": [60, true], "fun4.2": [63, true], "fun4.3": [70, true], "fun4.4": [78, true], "fun4.5": [94, true], "fun5.1": [59, true], "fun5.2": [62, true], "fun5.3": [57, true], "fun5.4": [61, true], "fun5.5": [62, true], "fun6.1": [48, true], "fun6.2": [50, true], "fun6.3": [45, true], "fun6.4": [48, true], "fun6.5": [52, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [16, false], "fun7.4": [7, false], "fun7.5": [6, false], "fun8.1": [33, true], "fun8.2": [37, true], "fun8.3": [36, true], "fun8.4": [39, true], "fun8.5": [43, true], "fun9.1": [32, true], "fun9.2": [30, true], "fun9.3": [35, true], "fun9.4": [37, true], "fun9.5": [43, true]}}}, {"label": "pure.ratio_soft.bracket.credit", "spec": ["pure", "ratio_soft", "bracket", "credit"], "APS": {"total": 7575, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [43, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [48, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [47, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [8, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [51, true], "aps.15.01": [51, true], "aps.15.02": [51, true], "aps.15.03": [51, true], "aps.15.04": [50, true], "aps.15.05": [50, true], "aps.15.06": [49, true], "aps.15.07": [48, true], "aps.15.08": [46, true], "aps.15.09": [43, true], "aps.15.10": [42, true], "aps.15.11": [47, true], "aps.15.12": [48, true], "aps.15.13": [49, true], "aps.15.14": [50, true], "aps.15.15": [50, true], "aps.15.16": [51, true], "aps.15.17": [51, true], "aps.15.18": [51, true], "aps.15.19": [51, true], "aps.15.20": [52, true], "aps.15.21": [49, true], "aps.15.22": [47, true], "aps.15.23": [51, true], "aps.15.24": [51, true], "aps.15.25": [48, true], "aps.15.26": [46, true], "aps.15.27": [37, true], "aps.15.28": [47, true], "aps.15.29": [47, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [8, false], "fun7.2": [7, false], "fun7.3": [8, false], "fun7.4": [12, false], "fun7.5": [14, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.ratio_soft.derived.both", "spec": ["pure", "ratio_soft", "derived", "both"], "APS": {"total": 5964, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [33, true], "aps.02.00": [34, true], "aps.02.01": [33, true], "aps.02.02": [37, true], "aps.02.03": [36, true], "aps.02.04": [34, true], "aps.02.05": [35, true], "aps.02.06": [35, true], "aps.02.07": [34, true], "aps.02.08": [35, true], "aps.02.09": [36, true], "aps.03.00": [38, true], "aps.03.01": [40, true], "aps.03.02": [41, true], "aps.04.00": [37, true], "aps.04.01": [37, true], "aps.04.02": [37, true], "aps.04.03": [37, true], "aps.04.04": [34, true], "aps.04.05": [37, true], "aps.04.06": [37, true], "aps.04.07": [38, true], "aps.04.08": [39, true], "aps.04.09": [38, true], "aps.04.10": [36, true], "aps.04.11": [37, true], "aps.04.12": [38, true], "aps.04.13": [37, true], "aps.05.00": [30, true], "aps.06.00": [32, true], "aps.06.01": [29, true], "aps.06.02": [31, true], "aps.06.03": [31, true], "aps.06.04": [32, true], "aps.06.05": [33, true], "aps.06.06": [31, true], "aps.06.07": [34, true], "aps.06.08": [33, true], "aps.06.09": [35, true], "aps.07.00": [33, true], "aps.07.01": [30, true], "aps.07.02": [30, true], "aps.08.00": [3, true], "aps.08.01": [33, true], "aps.08.02": [32, true], "aps.08.03": [30, true], "aps.08.04": [32, true], "aps.09.00": [33, true], "aps.09.01": [33, true], "aps.09.02": [29, true], "aps.09.03": [31, true], "aps.09.04": [30, true], "aps.09.05": [29, true], "aps.09.06": [28, true], "aps.10.00": [32, true], "aps.10.01": [32, true], "aps.10.02": [34, true], "aps.10.03": [35, true], "aps.10.04": [35, true], "aps.11.00": [33, true], "aps.11.01": [34, true], "aps.11.02": [35, true], "aps.11.03": [31, true], "aps.12.00": [34, true], "aps.12.01": [36, true], "aps.12.02": [37, true], "aps.12.03": [38, true], "aps.12.04": [38, true], "aps.12.05": [38, true], "aps.12.06": [38, true], "aps.12.07": [38, true], "aps.12.08": [38, true], "aps.12.09": [37, true], "aps.12.10": [38, true], "aps.12.11": [37, true], "aps.12.12": [36, true], "aps.12.13": [38, true], "aps.12.14": [38, true], "aps.12.15": [36, true], "aps.12.16": [37, true], "aps.12.17": [33, true], "aps.12.18": [33, true], "aps.13.00": [9, false], "aps.14.00": [39, true], "aps.14.01": [39, true], "aps.14.02": [39, true], "aps.14.03": [39, true], "aps.14.04": [39, true], "aps.14.05": [39, true], "aps.14.06": [39, true], "aps.14.07": [39, true], "aps.14.08": [39, true], "aps.14.09": [39, true], "aps.14.10": [39, true], "aps.14.11": [39, true], "aps.14.12": [39, true], "aps.14.13": [39, true], "aps.14.14": [39, true], "aps.14.15": [39, true], "aps.14.16": [39, true], "aps.14.17": [39, true], "aps.14.18": [39, true], "aps.14.19": [39, true], "aps.14.20": [39, true], "aps.14.21": [39, true], "aps.14.22": [39, true], "aps.14.23": [39, true], "aps.14.24": [39, true], "aps.14.25": [39, true], "aps.14.26": [39, true], "aps.14.27": [39, true], "aps.14.28": [39, true], "aps.14.29": [39, true], "aps.14.30": [39, true], "aps.14.31": [39, true], "aps.14.32": [39, true], "aps.14.33": [39, true], "aps.14.34": [39, true], "aps.14.35": [39, true], "aps.14.36": [39, true], "aps.14.37": [39, true], "aps.14.38": [39, true], "aps.14.39": [39, true], "aps.15.00": [42, true], "aps.15.01": [45, true], "aps.15.02": [45, true], "aps.15.03": [45, true], "aps.15.04": [45, true], "aps.15.05": [42, true], "aps.15.06": [44, true], "aps.15.07": [44, true], "aps.15.08": [44, true], "aps.15.09": [43, true], "aps.15.10": [44, true], "aps.15.11": [45, true], "aps.15.12": [43, true], "aps.15.13": [46, true], "aps.15.14": [45, true], "aps.15.15": [45, true], "aps.15.16": [46, true], "aps.15.17": [46, true], "aps.15.18": [45, true], "aps.15.19": [45, true], "aps.15.20": [46, true], "aps.15.21": [45, true], "aps.15.22": [46, true], "aps.15.23": [45, true], "aps.15.24": [47, true], "aps.15.25": [47, true], "aps.15.26": [46, true], "aps.15.27": [47, true], "aps.15.28": [46, true], "aps.15.29": [47, true], "aps.15.30": [47, true]}}, "CHA": {"total": 3308, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [29, true], "fun1.2": [36, true], "fun1.3": [41, true], "fun1.4": [47, true], "fun1.5": [79, true], "fun2.1": [33, true], "fun2.2": [53, true], "fun2.3": [62, true], "fun2.4": [75, true], "fun2.5": [81, true], "fun3.1": [59, true], "fun3.2": [65, true], "fun3.3": [76, true], "fun3.4": [82, true], "fun3.5": [103, true], "fun4.1": [65, true], "fun4.2": [67, true], "fun4.3": [71, true], "fun4.4": [95, true], "fun4.5": [116, true], "fun5.1": [69, true], "fun5.2": [65, true], "fun5.3": [75, true], "fun5.4": [77, true], "fun5.5": [78, true], "fun6.1": [54, true], "fun6.2": [49, true], "fun6.3": [44, true], "fun6.4": [48, true], "fun6.5": [48, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [17, false], "fun7.4": [9, false], "fun7.5": [6, false], "fun8.1": [34, true], "fun8.2": [35, true], "fun8.3": [34, true], "fun8.4": [39, true], "fun8.5": [43, true], "fun9.1": [32, true], "fun9.2": [35, true], "fun9.3": [37, true], "fun9.4": [38, true], "fun9.5": [39, true]}}}, {"label": "pure.ratio_soft.derived.safe", "spec": ["pure", "ratio_soft", "derived", "safe"], "APS": {"total": 5822, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [27, true], "aps.02.00": [35, true], "aps.02.01": [33, true], "aps.02.02": [35, true], "aps.02.03": [31, true], "aps.02.04": [34, true], "aps.02.05": [35, true], "aps.02.06": [35, true], "aps.02.07": [34, true], "aps.02.08": [35, true], "aps.02.09": [35, true], "aps.03.00": [34, true], "aps.03.01": [40, true], "aps.03.02": [42, true], "aps.04.00": [38, true], "aps.04.01": [35, true], "aps.04.02": [36, true], "aps.04.03": [34, true], "aps.04.04": [34, true], "aps.04.05": [33, true], "aps.04.06": [36, true], "aps.04.07": [35, true], "aps.04.08": [37, true], "aps.04.09": [38, true], "aps.04.10": [37, true], "aps.04.11": [36, true], "aps.04.12": [33, true], "aps.04.13": [34, true], "aps.05.00": [33, true], "aps.06.00": [32, true], "aps.06.01": [28, true], "aps.06.02": [32, true], "aps.06.03": [33, true], "aps.06.04": [33, true], "aps.06.05": [34, true], "aps.06.06": [34, true], "aps.06.07": [36, true], "aps.06.08": [36, true], "aps.06.09": [35, true], "aps.07.00": [32, true], "aps.07.01": [30, true], "aps.07.02": [30, true], "aps.08.00": [3, true], "aps.08.01": [30, true], "aps.08.02": [32, true], "aps.08.03": [28, true], "aps.08.04": [31, true], "aps.09.00": [30, true], "aps.09.01": [33, true], "aps.09.02": [28, true], "aps.09.03": [29, true], "aps.09.04": [30, true], "aps.09.05": [29, true], "aps.09.06": [28, true], "aps.10.00": [32, true], "aps.10.01": [27, true], "aps.10.02": [31, true], "aps.10.03": [32, true], "aps.10.04": [31, true], "aps.11.00": [31, true], "aps.11.01": [32, true], "aps.11.02": [35, true], "aps.11.03": [29, true], "aps.12.00": [35, true], "aps.12.01": [34, true], "aps.12.02": [34, true], "aps.12.03": [35, true], "aps.12.04": [36, true], "aps.12.05": [36, true], "aps.12.06": [36, true], "aps.12.07": [34, true], "aps.12.08": [38, true], "aps.12.09": [38, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [36, true], "aps.12.13": [36, true], "aps.12.14": [35, true], "aps.12.15": [33, true], "aps.12.16": [34, true], "aps.12.17": [36, true], "aps.12.18": [36, true], "aps.13.00": [13, false], "aps.14.00": [38, true], "aps.14.01": [38, true], "aps.14.02": [38, true], "aps.14.03": [38, true], "aps.14.04": [38, true], "aps.14.05": [38, true], "aps.14.06": [38, true], "aps.14.07": [38, true], "aps.14.08": [38, true], "aps.14.09": [38, true], "aps.14.10": [38, true], "aps.14.11": [38, true], "aps.14.12": [38, true], "aps.14.13": [38, true], "aps.14.14": [38, true], "aps.14.15": [38, true], "aps.14.16": [38, true], "aps.14.17": [38, true], "aps.14.18": [38, true], "aps.14.19": [38, true], "aps.14.20": [38, true], "aps.14.21": [38, true], "aps.14.22": [38, true], "aps.14.23": [38, true], "aps.14.24": [38, true], "aps.14.25": [38, true], "aps.14.26": [38, true], "aps.14.27": [38, true], "aps.14.28": [38, true], "aps.14.29": [38, true], "aps.14.30": [38, true], "aps.14.31": [38, true], "aps.14.32": [38, true], "aps.14.33": [38, true], "aps.14.34": [38, true], "aps.14.35": [38, true], "aps.14.36": [38, true], "aps.14.37": [38, true], "aps.14.38": [38, true], "aps.14.39": [38, true], "aps.15.00": [46, true], "aps.15.01": [46, true], "aps.15.02": [45, true], "aps.15.03": [44, true], "aps.15.04": [43, true], "aps.15.05": [42, true], "aps.15.06": [44, true], "aps.15.07": [44, true], "aps.15.08": [44, true], "aps.15.09": [43, true], "aps.15.10": [42, true], "aps.15.11": [44, true], "aps.15.12": [44, true], "aps.15.13": [44, true], "aps.15.14": [44, true], "aps.15.15": [44, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [44, true], "aps.15.21": [43, true], "aps.15.22": [46, true], "aps.15.23": [47, true], "aps.15.24": [44, true], "aps.15.25": [46, true], "aps.15.26": [46, true], "aps.15.27": [47, true], "aps.15.28": [45, true], "aps.15.29": [43, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3643, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [35, true], "fun1.3": [30, true], "fun1.4": [36, true], "fun1.5": [77, true], "fun2.1": [32, true], "fun2.2": [52, true], "fun2.3": [64, true], "fun2.4": [75, true], "fun2.5": [82, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [102, true], "fun3.5": [153, true], "fun4.1": [83, true], "fun4.2": [85, true], "fun4.3": [100, true], "fun4.4": [116, true], "fun4.5": [141, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [49, true], "fun6.2": [39, true], "fun6.3": [49, true], "fun6.4": [48, true], "fun6.5": [54, true], "fun7.1": [13, false], "fun7.2": [12, false], "fun7.3": [15, false], "fun7.4": [12, false], "fun7.5": [12, false], "fun8.1": [33, true], "fun8.2": [32, true], "fun8.3": [35, true], "fun8.4": [38, true], "fun8.5": [41, true], "fun9.1": [31, true], "fun9.2": [33, true], "fun9.3": [38, true], "fun9.4": [40, true], "fun9.5": [39, true]}}}, {"label": "pure.ratio_soft.derived.credit", "spec": ["pure", "ratio_soft", "derived", "credit"], "APS": {"total": 6237, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [31, true], "aps.02.00": [34, true], "aps.02.01": [31, true], "aps.02.02": [35, true], "aps.02.03": [34, true], "aps.02.04": [34, true], "aps.02.05": [33, true], "aps.02.06": [35, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [37, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [32, true], "aps.06.00": [32, true], "aps.06.01": [27, true], "aps.06.02": [32, true], "aps.06.03": [33, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [32, true], "aps.07.01": [29, true], "aps.07.02": [29, true], "aps.08.00": [31, true], "aps.08.01": [32, true], "aps.08.02": [32, true], "aps.08.03": [32, true], "aps.08.04": [32, true], "aps.09.00": [31, true], "aps.09.01": [33, true], "aps.09.02": [29, true], "aps.09.03": [29, true], "aps.09.04": [30, true], "aps.09.05": [29, true], "aps.09.06": [28, true], "aps.10.00": [32, true], "aps.10.01": [31, true], "aps.10.02": [30, true], "aps.10.03": [29, true], "aps.10.04": [30, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [35, true], "aps.12.01": [34, true], "aps.12.02": [34, true], "aps.12.03": [35, true], "aps.12.04": [36, true], "aps.12.05": [36, true], "aps.12.06": [37, true], "aps.12.07": [38, true], "aps.12.08": [38, true], "aps.12.09": [37, true], "aps.12.10": [35, true], "aps.12.11": [38, true], "aps.12.12": [37, true], "aps.12.13": [38, true], "aps.12.14": [37, true], "aps.12.15": [38, true], "aps.12.16": [34, true], "aps.12.17": [36, true], "aps.12.18": [38, true], "aps.13.00": [9, false], "aps.14.00": [40, true], "aps.14.01": [40, true], "aps.14.02": [40, true], "aps.14.03": [40, true], "aps.14.04": [40, true], "aps.14.05": [40, true], "aps.14.06": [40, true], "aps.14.07": [40, true], "aps.14.08": [40, true], "aps.14.09": [40, true], "aps.14.10": [40, true], "aps.14.11": [40, true], "aps.14.12": [40, true], "aps.14.13": [40, true], "aps.14.14": [40, true], "aps.14.15": [40, true], "aps.14.16": [40, true], "aps.14.17": [40, true], "aps.14.18": [40, true], "aps.14.19": [40, true], "aps.14.20": [40, true], "aps.14.21": [40, true], "aps.14.22": [40, true], "aps.14.23": [40, true], "aps.14.24": [40, true], "aps.14.25": [40, true], "aps.14.26": [40, true], "aps.14.27": [40, true], "aps.14.28": [40, true], "aps.14.29": [40, true], "aps.14.30": [40, true], "aps.14.31": [40, true], "aps.14.32": [40, true], "aps.14.33": [40, true], "aps.14.34": [40, true], "aps.14.35": [40, true], "aps.14.36": [40, true], "aps.14.37": [40, true], "aps.14.38": [40, true], "aps.14.39": [40, true], "aps.15.00": [45, true], "aps.15.01": [45, true], "aps.15.02": [44, true], "aps.15.03": [43, true], "aps.15.04": [40, true], "aps.15.05": [41, true], "aps.15.06": [42, true], "aps.15.07": [42, true], "aps.15.08": [41, true], "aps.15.09": [41, true], "aps.15.10": [42, true], "aps.15.11": [43, true], "aps.15.12": [43, true], "aps.15.13": [43, true], "aps.15.14": [44, true], "aps.15.15": [44, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [44, true], "aps.15.21": [46, true], "aps.15.22": [44, true], "aps.15.23": [53, true], "aps.15.24": [40, true], "aps.15.25": [45, true], "aps.15.26": [46, true], "aps.15.27": [47, true], "aps.15.28": [45, true], "aps.15.29": [43, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3094, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [7, false], "fun7.3": [10, false], "fun7.4": [9, false], "fun7.5": [50, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [31, true], "fun9.2": [34, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.ratio_soft.derived3.bracket", "spec": ["pure", "ratio_soft", "derived3", "bracket"], "APS": {"total": 5903, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [31, true], "aps.02.00": [34, true], "aps.02.01": [35, true], "aps.02.02": [37, true], "aps.02.03": [36, true], "aps.02.04": [34, true], "aps.02.05": [36, true], "aps.02.06": [34, true], "aps.02.07": [37, true], "aps.02.08": [37, true], "aps.02.09": [36, true], "aps.03.00": [37, true], "aps.03.01": [40, true], "aps.03.02": [40, true], "aps.04.00": [37, true], "aps.04.01": [37, true], "aps.04.02": [37, true], "aps.04.03": [35, true], "aps.04.04": [37, true], "aps.04.05": [37, true], "aps.04.06": [35, true], "aps.04.07": [38, true], "aps.04.08": [38, true], "aps.04.09": [38, true], "aps.04.10": [31, true], "aps.04.11": [37, true], "aps.04.12": [36, true], "aps.04.13": [36, true], "aps.05.00": [32, true], "aps.06.00": [29, true], "aps.06.01": [32, true], "aps.06.02": [32, true], "aps.06.03": [33, true], "aps.06.04": [32, true], "aps.06.05": [32, true], "aps.06.06": [33, true], "aps.06.07": [32, true], "aps.06.08": [32, true], "aps.06.09": [33, true], "aps.07.00": [32, true], "aps.07.01": [31, true], "aps.07.02": [31, true], "aps.08.00": [32, true], "aps.08.01": [32, true], "aps.08.02": [33, true], "aps.08.03": [33, true], "aps.08.04": [34, true], "aps.09.00": [29, true], "aps.09.01": [33, true], "aps.09.02": [31, true], "aps.09.03": [31, true], "aps.09.04": [29, true], "aps.09.05": [28, true], "aps.09.06": [29, true], "aps.10.00": [32, true], "aps.10.01": [32, true], "aps.10.02": [35, true], "aps.10.03": [33, true], "aps.10.04": [35, true], "aps.11.00": [30, true], "aps.11.01": [35, true], "aps.11.02": [31, true], "aps.11.03": [35, true], "aps.12.00": [36, true], "aps.12.01": [35, true], "aps.12.02": [34, true], "aps.12.03": [36, true], "aps.12.04": [37, true], "aps.12.05": [37, true], "aps.12.06": [38, true], "aps.12.07": [38, true], "aps.12.08": [37, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [37, true], "aps.12.13": [38, true], "aps.12.14": [38, true], "aps.12.15": [38, true], "aps.12.16": [35, true], "aps.12.17": [35, true], "aps.12.18": [34, true], "aps.13.00": [9, false], "aps.14.00": [38, true], "aps.14.01": [38, true], "aps.14.02": [38, true], "aps.14.03": [38, true], "aps.14.04": [38, true], "aps.14.05": [38, true], "aps.14.06": [38, true], "aps.14.07": [38, true], "aps.14.08": [38, true], "aps.14.09": [38, true], "aps.14.10": [38, true], "aps.14.11": [38, true], "aps.14.12": [38, true], "aps.14.13": [38, true], "aps.14.14": [38, true], "aps.14.15": [38, true], "aps.14.16": [38, true], "aps.14.17": [38, true], "aps.14.18": [38, true], "aps.14.19": [38, true], "aps.14.20": [38, true], "aps.14.21": [38, true], "aps.14.22": [38, true], "aps.14.23": [38, true], "aps.14.24": [38, true], "aps.14.25": [38, true], "aps.14.26": [38, true], "aps.14.27": [38, true], "aps.14.28": [38, true], "aps.14.29": [38, true], "aps.14.30": [38, true], "aps.14.31": [38, true], "aps.14.32": [38, true], "aps.14.33": [38, true], "aps.14.34": [38, true], "aps.14.35": [38, true], "aps.14.36": [38, true], "aps.14.37": [38, true], "aps.14.38": [38, true], "aps.14.39": [38, true], "aps.15.00": [45, true], "aps.15.01": [45, true], "aps.15.02": [45, true], "aps.15.03": [43, true], "aps.15.04": [44, true], "aps.15.05": [43, true], "aps.15.06": [38, true], "aps.15.07": [41, true], "aps.15.08": [41, true], "aps.15.09": [38, true], "aps.15.10": [39, true], "aps.15.11": [44, true], "aps.15.12": [43, true], "aps.15.13": [43, true], "aps.15.14": [44, true], "aps.15.15": [45, true], "aps.15.16": [45, true], "aps.15.17": [45, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [43, true], "aps.15.21": [44, true], "aps.15.22": [45, true], "aps.15.23": [46, true], "aps.15.24": [46, true], "aps.15.25": [45, true], "aps.15.26": [45, true], "aps.15.27": [45, true], "aps.15.28": [45, true], "aps.15.29": [47, true], "aps.15.30": [48, true]}}, "CHA": {"total": 3513, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [37, true], "fun1.3": [40, true], "fun1.4": [47, true], "fun1.5": [77, true], "fun2.1": [33, true], "fun2.2": [58, true], "fun2.3": [70, true], "fun2.4": [76, true], "fun2.5": [81, true], "fun3.1": [66, true], "fun3.2": [71, true], "fun3.3": [81, true], "fun3.4": [87, true], "fun3.5": [104, true], "fun4.1": [73, true], "fun4.2": [77, true], "fun4.3": [94, true], "fun4.4": [103, true], "fun4.5": [128, true], "fun5.1": [75, true], "fun5.2": [81, true], "fun5.3": [74, true], "fun5.4": [77, true], "fun5.5": [79, true], "fun6.1": [59, true], "fun6.2": [61, true], "fun6.3": [64, true], "fun6.4": [72, true], "fun6.5": [72, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [8, false], "fun7.4": [11, false], "fun7.5": [10, false], "fun8.1": [32, true], "fun8.2": [34, true], "fun8.3": [34, true], "fun8.4": [40, true], "fun8.5": [41, true], "fun9.1": [32, true], "fun9.2": [32, true], "fun9.3": [38, true], "fun9.4": [41, true], "fun9.5": [42, true]}}}, {"label": "pure.ratio_soft.derived3.step", "spec": ["pure", "ratio_soft", "derived3", "step"], "APS": {"total": 5778, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [28, true], "aps.02.00": [33, true], "aps.02.01": [35, true], "aps.02.02": [35, true], "aps.02.03": [35, true], "aps.02.04": [34, true], "aps.02.05": [36, true], "aps.02.06": [35, true], "aps.02.07": [34, true], "aps.02.08": [36, true], "aps.02.09": [36, true], "aps.03.00": [38, true], "aps.03.01": [39, true], "aps.03.02": [39, true], "aps.04.00": [35, true], "aps.04.01": [36, true], "aps.04.02": [29, true], "aps.04.03": [38, true], "aps.04.04": [35, true], "aps.04.05": [34, true], "aps.04.06": [35, true], "aps.04.07": [35, true], "aps.04.08": [33, true], "aps.04.09": [35, true], "aps.04.10": [38, true], "aps.04.11": [36, true], "aps.04.12": [37, true], "aps.04.13": [38, true], "aps.05.00": [33, true], "aps.06.00": [32, true], "aps.06.01": [32, true], "aps.06.02": [32, true], "aps.06.03": [30, true], "aps.06.04": [30, true], "aps.06.05": [31, true], "aps.06.06": [33, true], "aps.06.07": [33, true], "aps.06.08": [32, true], "aps.06.09": [29, true], "aps.07.00": [32, true], "aps.07.01": [30, true], "aps.07.02": [29, true], "aps.08.00": [3, true], "aps.08.01": [30, true], "aps.08.02": [28, true], "aps.08.03": [32, true], "aps.08.04": [33, true], "aps.09.00": [32, true], "aps.09.01": [31, true], "aps.09.02": [30, true], "aps.09.03": [29, true], "aps.09.04": [27, true], "aps.09.05": [24, true], "aps.09.06": [22, true], "aps.10.00": [32, true], "aps.10.01": [28, true], "aps.10.02": [31, true], "aps.10.03": [31, true], "aps.10.04": [32, true], "aps.11.00": [32, true], "aps.11.01": [31, true], "aps.11.02": [33, true], "aps.11.03": [33, true], "aps.12.00": [32, true], "aps.12.01": [34, true], "aps.12.02": [35, true], "aps.12.03": [35, true], "aps.12.04": [35, true], "aps.12.05": [35, true], "aps.12.06": [35, true], "aps.12.07": [35, true], "aps.12.08": [37, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [37, true], "aps.12.13": [37, true], "aps.12.14": [37, true], "aps.12.15": [36, true], "aps.12.16": [36, true], "aps.12.17": [36, true], "aps.12.18": [36, true], "aps.13.00": [13, false], "aps.14.00": [38, true], "aps.14.01": [38, true], "aps.14.02": [38, true], "aps.14.03": [38, true], "aps.14.04": [38, true], "aps.14.05": [38, true], "aps.14.06": [38, true], "aps.14.07": [38, true], "aps.14.08": [38, true], "aps.14.09": [38, true], "aps.14.10": [38, true], "aps.14.11": [38, true], "aps.14.12": [38, true], "aps.14.13": [38, true], "aps.14.14": [38, true], "aps.14.15": [38, true], "aps.14.16": [38, true], "aps.14.17": [38, true], "aps.14.18": [38, true], "aps.14.19": [38, true], "aps.14.20": [38, true], "aps.14.21": [38, true], "aps.14.22": [38, true], "aps.14.23": [38, true], "aps.14.24": [38, true], "aps.14.25": [38, true], "aps.14.26": [38, true], "aps.14.27": [38, true], "aps.14.28": [38, true], "aps.14.29": [38, true], "aps.14.30": [38, true], "aps.14.31": [38, true], "aps.14.32": [38, true], "aps.14.33": [38, true], "aps.14.34": [38, true], "aps.14.35": [38, true], "aps.14.36": [38, true], "aps.14.37": [38, true], "aps.14.38": [38, true], "aps.14.39": [38, true], "aps.15.00": [44, true], "aps.15.01": [44, true], "aps.15.02": [44, true], "aps.15.03": [43, true], "aps.15.04": [42, true], "aps.15.05": [41, true], "aps.15.06": [40, true], "aps.15.07": [41, true], "aps.15.08": [41, true], "aps.15.09": [41, true], "aps.15.10": [39, true], "aps.15.11": [39, true], "aps.15.12": [40, true], "aps.15.13": [42, true], "aps.15.14": [43, true], "aps.15.15": [43, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [44, true], "aps.15.21": [39, true], "aps.15.22": [47, true], "aps.15.23": [46, true], "aps.15.24": [48, true], "aps.15.25": [47, true], "aps.15.26": [43, true], "aps.15.27": [47, true], "aps.15.28": [48, true], "aps.15.29": [49, true], "aps.15.30": [49, true]}}, "CHA": {"total": 3724, "solved": 40, "n": 45, "over": 5, "per": {"fun1.1": [30, true], "fun1.2": [32, true], "fun1.3": [36, true], "fun1.4": [33, true], "fun1.5": [54, true], "fun2.1": [32, true], "fun2.2": [51, true], "fun2.3": [64, true], "fun2.4": [73, true], "fun2.5": [78, true], "fun3.1": [70, true], "fun3.2": [71, true], "fun3.3": [84, true], "fun3.4": [92, true], "fun3.5": [110, true], "fun4.1": [87, true], "fun4.2": [91, true], "fun4.3": [107, true], "fun4.4": [125, true], "fun4.5": [145, true], "fun5.1": [95, true], "fun5.2": [97, true], "fun5.3": [98, true], "fun5.4": [104, true], "fun5.5": [106, true], "fun6.1": [71, true], "fun6.2": [81, true], "fun6.3": [74, true], "fun6.4": [82, true], "fun6.5": [88, true], "fun7.1": [13, false], "fun7.2": [12, false], "fun7.3": [13, false], "fun7.4": [11, false], "fun7.5": [12, false], "fun8.1": [34, true], "fun8.2": [35, true], "fun8.3": [36, true], "fun8.4": [38, true], "fun8.5": [40, true], "fun9.1": [32, true], "fun9.2": [32, true], "fun9.3": [39, true], "fun9.4": [41, true], "fun9.5": [36, true]}}}, {"label": "pure.ratio_soft.derived3.none", "spec": ["pure", "ratio_soft", "derived3", "none"], "APS": {"total": 5814, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [28, true], "aps.02.00": [33, true], "aps.02.01": [34, true], "aps.02.02": [34, true], "aps.02.03": [36, true], "aps.02.04": [32, true], "aps.02.05": [36, true], "aps.02.06": [36, true], "aps.02.07": [37, true], "aps.02.08": [37, true], "aps.02.09": [37, true], "aps.03.00": [38, true], "aps.03.01": [40, true], "aps.03.02": [40, true], "aps.04.00": [35, true], "aps.04.01": [35, true], "aps.04.02": [35, true], "aps.04.03": [37, true], "aps.04.04": [38, true], "aps.04.05": [36, true], "aps.04.06": [37, true], "aps.04.07": [35, true], "aps.04.08": [34, true], "aps.04.09": [33, true], "aps.04.10": [39, true], "aps.04.11": [32, true], "aps.04.12": [35, true], "aps.04.13": [32, true], "aps.05.00": [32, true], "aps.06.00": [32, true], "aps.06.01": [32, true], "aps.06.02": [32, true], "aps.06.03": [31, true], "aps.06.04": [30, true], "aps.06.05": [31, true], "aps.06.06": [33, true], "aps.06.07": [33, true], "aps.06.08": [32, true], "aps.06.09": [29, true], "aps.07.00": [32, true], "aps.07.01": [29, true], "aps.07.02": [28, true], "aps.08.00": [31, true], "aps.08.01": [29, true], "aps.08.02": [30, true], "aps.08.03": [33, true], "aps.08.04": [34, true], "aps.09.00": [32, true], "aps.09.01": [32, true], "aps.09.02": [29, true], "aps.09.03": [29, true], "aps.09.04": [28, true], "aps.09.05": [28, true], "aps.09.06": [27, true], "aps.10.00": [32, true], "aps.10.01": [31, true], "aps.10.02": [31, true], "aps.10.03": [30, true], "aps.10.04": [29, true], "aps.11.00": [31, true], "aps.11.01": [32, true], "aps.11.02": [34, true], "aps.11.03": [34, true], "aps.12.00": [32, true], "aps.12.01": [34, true], "aps.12.02": [35, true], "aps.12.03": [35, true], "aps.12.04": [35, true], "aps.12.05": [35, true], "aps.12.06": [35, true], "aps.12.07": [35, true], "aps.12.08": [37, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [37, true], "aps.12.13": [37, true], "aps.12.14": [37, true], "aps.12.15": [36, true], "aps.12.16": [36, true], "aps.12.17": [36, true], "aps.12.18": [36, true], "aps.13.00": [191, false], "aps.14.00": [38, true], "aps.14.01": [38, true], "aps.14.02": [38, true], "aps.14.03": [38, true], "aps.14.04": [38, true], "aps.14.05": [38, true], "aps.14.06": [38, true], "aps.14.07": [38, true], "aps.14.08": [38, true], "aps.14.09": [38, true], "aps.14.10": [38, true], "aps.14.11": [38, true], "aps.14.12": [38, true], "aps.14.13": [38, true], "aps.14.14": [38, true], "aps.14.15": [38, true], "aps.14.16": [38, true], "aps.14.17": [38, true], "aps.14.18": [38, true], "aps.14.19": [38, true], "aps.14.20": [38, true], "aps.14.21": [38, true], "aps.14.22": [38, true], "aps.14.23": [38, true], "aps.14.24": [38, true], "aps.14.25": [38, true], "aps.14.26": [38, true], "aps.14.27": [38, true], "aps.14.28": [38, true], "aps.14.29": [38, true], "aps.14.30": [38, true], "aps.14.31": [38, true], "aps.14.32": [38, true], "aps.14.33": [38, true], "aps.14.34": [38, true], "aps.14.35": [38, true], "aps.14.36": [38, true], "aps.14.37": [38, true], "aps.14.38": [38, true], "aps.14.39": [38, true], "aps.15.00": [44, true], "aps.15.01": [44, true], "aps.15.02": [44, true], "aps.15.03": [43, true], "aps.15.04": [42, true], "aps.15.05": [41, true], "aps.15.06": [37, true], "aps.15.07": [40, true], "aps.15.08": [40, true], "aps.15.09": [37, true], "aps.15.10": [38, true], "aps.15.11": [41, true], "aps.15.12": [42, true], "aps.15.13": [43, true], "aps.15.14": [43, true], "aps.15.15": [44, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [45, true], "aps.15.21": [44, true], "aps.15.22": [45, true], "aps.15.23": [47, true], "aps.15.24": [44, true], "aps.15.25": [48, true], "aps.15.26": [48, true], "aps.15.27": [46, true], "aps.15.28": [45, true], "aps.15.29": [45, true], "aps.15.30": [46, true]}}, "CHA": {"total": 4285, "solved": 35, "n": 45, "over": 5, "per": {"fun1.1": [30, true], "fun1.2": [33, true], "fun1.3": [29, true], "fun1.4": [43, true], "fun1.5": [54, true], "fun2.1": [32, true], "fun2.2": [70, true], "fun2.3": [83, true], "fun2.4": [83, true], "fun2.5": [92, true], "fun3.1": [43, true], "fun3.2": [55, true], "fun3.3": [56, true], "fun3.4": [59, true], "fun3.5": [63, true], "fun4.1": [63, true], "fun4.2": [57, true], "fun4.3": [99, true], "fun4.4": [90, true], "fun4.5": [106, true], "fun5.1": [121, true], "fun5.2": [200, false], "fun5.3": [111, true], "fun5.4": [114, true], "fun5.5": [114, true], "fun6.1": [199, true], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [80, false], "fun7.3": [66, false], "fun7.4": [55, false], "fun7.5": [25, false], "fun8.1": [30, true], "fun8.2": [34, true], "fun8.3": [37, true], "fun8.4": [39, true], "fun8.5": [42, true], "fun9.1": [32, true], "fun9.2": [33, true], "fun9.3": [41, true], "fun9.4": [52, true], "fun9.5": [46, true]}}}, {"label": "pure.ratio_soft.derived3.project", "spec": ["pure", "ratio_soft", "derived3", "project"], "APS": {"total": 5814, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [28, true], "aps.02.00": [33, true], "aps.02.01": [34, true], "aps.02.02": [34, true], "aps.02.03": [36, true], "aps.02.04": [32, true], "aps.02.05": [36, true], "aps.02.06": [36, true], "aps.02.07": [37, true], "aps.02.08": [37, true], "aps.02.09": [37, true], "aps.03.00": [38, true], "aps.03.01": [40, true], "aps.03.02": [40, true], "aps.04.00": [35, true], "aps.04.01": [35, true], "aps.04.02": [35, true], "aps.04.03": [37, true], "aps.04.04": [38, true], "aps.04.05": [36, true], "aps.04.06": [37, true], "aps.04.07": [35, true], "aps.04.08": [34, true], "aps.04.09": [33, true], "aps.04.10": [39, true], "aps.04.11": [32, true], "aps.04.12": [35, true], "aps.04.13": [32, true], "aps.05.00": [32, true], "aps.06.00": [32, true], "aps.06.01": [32, true], "aps.06.02": [32, true], "aps.06.03": [31, true], "aps.06.04": [30, true], "aps.06.05": [31, true], "aps.06.06": [33, true], "aps.06.07": [33, true], "aps.06.08": [32, true], "aps.06.09": [29, true], "aps.07.00": [32, true], "aps.07.01": [29, true], "aps.07.02": [28, true], "aps.08.00": [31, true], "aps.08.01": [29, true], "aps.08.02": [30, true], "aps.08.03": [33, true], "aps.08.04": [34, true], "aps.09.00": [32, true], "aps.09.01": [32, true], "aps.09.02": [29, true], "aps.09.03": [29, true], "aps.09.04": [28, true], "aps.09.05": [28, true], "aps.09.06": [27, true], "aps.10.00": [32, true], "aps.10.01": [31, true], "aps.10.02": [31, true], "aps.10.03": [30, true], "aps.10.04": [29, true], "aps.11.00": [31, true], "aps.11.01": [32, true], "aps.11.02": [34, true], "aps.11.03": [34, true], "aps.12.00": [32, true], "aps.12.01": [34, true], "aps.12.02": [35, true], "aps.12.03": [35, true], "aps.12.04": [35, true], "aps.12.05": [35, true], "aps.12.06": [35, true], "aps.12.07": [35, true], "aps.12.08": [37, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [37, true], "aps.12.13": [37, true], "aps.12.14": [37, true], "aps.12.15": [36, true], "aps.12.16": [36, true], "aps.12.17": [36, true], "aps.12.18": [36, true], "aps.13.00": [52, false], "aps.14.00": [38, true], "aps.14.01": [38, true], "aps.14.02": [38, true], "aps.14.03": [38, true], "aps.14.04": [38, true], "aps.14.05": [38, true], "aps.14.06": [38, true], "aps.14.07": [38, true], "aps.14.08": [38, true], "aps.14.09": [38, true], "aps.14.10": [38, true], "aps.14.11": [38, true], "aps.14.12": [38, true], "aps.14.13": [38, true], "aps.14.14": [38, true], "aps.14.15": [38, true], "aps.14.16": [38, true], "aps.14.17": [38, true], "aps.14.18": [38, true], "aps.14.19": [38, true], "aps.14.20": [38, true], "aps.14.21": [38, true], "aps.14.22": [38, true], "aps.14.23": [38, true], "aps.14.24": [38, true], "aps.14.25": [38, true], "aps.14.26": [38, true], "aps.14.27": [38, true], "aps.14.28": [38, true], "aps.14.29": [38, true], "aps.14.30": [38, true], "aps.14.31": [38, true], "aps.14.32": [38, true], "aps.14.33": [38, true], "aps.14.34": [38, true], "aps.14.35": [38, true], "aps.14.36": [38, true], "aps.14.37": [38, true], "aps.14.38": [38, true], "aps.14.39": [38, true], "aps.15.00": [44, true], "aps.15.01": [44, true], "aps.15.02": [44, true], "aps.15.03": [43, true], "aps.15.04": [42, true], "aps.15.05": [41, true], "aps.15.06": [37, true], "aps.15.07": [40, true], "aps.15.08": [40, true], "aps.15.09": [37, true], "aps.15.10": [38, true], "aps.15.11": [41, true], "aps.15.12": [42, true], "aps.15.13": [43, true], "aps.15.14": [43, true], "aps.15.15": [44, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [45, true], "aps.15.21": [44, true], "aps.15.22": [45, true], "aps.15.23": [47, true], "aps.15.24": [44, true], "aps.15.25": [48, true], "aps.15.26": [48, true], "aps.15.27": [46, true], "aps.15.28": [45, true], "aps.15.29": [45, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3538, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [33, true], "fun1.3": [29, true], "fun1.4": [43, true], "fun1.5": [54, true], "fun2.1": [32, true], "fun2.2": [70, true], "fun2.3": [83, true], "fun2.4": [83, true], "fun2.5": [92, true], "fun3.1": [43, true], "fun3.2": [55, true], "fun3.3": [56, true], "fun3.4": [59, true], "fun3.5": [63, true], "fun4.1": [63, true], "fun4.2": [57, true], "fun4.3": [99, true], "fun4.4": [90, true], "fun4.5": [106, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [52, false], "fun7.2": [52, false], "fun7.3": [54, false], "fun7.4": [55, false], "fun7.5": [25, false], "fun8.1": [30, true], "fun8.2": [34, true], "fun8.3": [37, true], "fun8.4": [39, true], "fun8.5": [42, true], "fun9.1": [32, true], "fun9.2": [33, true], "fun9.3": [41, true], "fun9.4": [52, true], "fun9.5": [46, true]}}}, {"label": "pure.ratio_soft.derived.project", "spec": ["pure", "ratio_soft", "derived", "project"], "APS": {"total": 5967, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [27, true], "aps.02.00": [32, true], "aps.02.01": [33, true], "aps.02.02": [33, true], "aps.02.03": [35, true], "aps.02.04": [34, true], "aps.02.05": [33, true], "aps.02.06": [35, true], "aps.02.07": [36, true], "aps.02.08": [36, true], "aps.02.09": [36, true], "aps.03.00": [43, true], "aps.03.01": [43, true], "aps.03.02": [45, true], "aps.04.00": [36, true], "aps.04.01": [34, true], "aps.04.02": [35, true], "aps.04.03": [35, true], "aps.04.04": [37, true], "aps.04.05": [34, true], "aps.04.06": [36, true], "aps.04.07": [36, true], "aps.04.08": [36, true], "aps.04.09": [35, true], "aps.04.10": [41, true], "aps.04.11": [40, true], "aps.04.12": [40, true], "aps.04.13": [41, true], "aps.05.00": [32, true], "aps.06.00": [32, true], "aps.06.01": [29, true], "aps.06.02": [32, true], "aps.06.03": [33, true], "aps.06.04": [33, true], "aps.06.05": [34, true], "aps.06.06": [34, true], "aps.06.07": [36, true], "aps.06.08": [35, true], "aps.06.09": [36, true], "aps.07.00": [32, true], "aps.07.01": [29, true], "aps.07.02": [29, true], "aps.08.00": [31, true], "aps.08.01": [31, true], "aps.08.02": [32, true], "aps.08.03": [29, true], "aps.08.04": [32, true], "aps.09.00": [31, true], "aps.09.01": [33, true], "aps.09.02": [29, true], "aps.09.03": [29, true], "aps.09.04": [30, true], "aps.09.05": [29, true], "aps.09.06": [28, true], "aps.10.00": [32, true], "aps.10.01": [31, true], "aps.10.02": [30, true], "aps.10.03": [30, true], "aps.10.04": [29, true], "aps.11.00": [34, true], "aps.11.01": [37, true], "aps.11.02": [39, true], "aps.11.03": [38, true], "aps.12.00": [35, true], "aps.12.01": [34, true], "aps.12.02": [34, true], "aps.12.03": [35, true], "aps.12.04": [36, true], "aps.12.05": [36, true], "aps.12.06": [36, true], "aps.12.07": [35, true], "aps.12.08": [38, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [36, true], "aps.12.13": [36, true], "aps.12.14": [35, true], "aps.12.15": [34, true], "aps.12.16": [34, true], "aps.12.17": [35, true], "aps.12.18": [36, true], "aps.13.00": [51, false], "aps.14.00": [40, true], "aps.14.01": [40, true], "aps.14.02": [40, true], "aps.14.03": [40, true], "aps.14.04": [40, true], "aps.14.05": [40, true], "aps.14.06": [40, true], "aps.14.07": [40, true], "aps.14.08": [40, true], "aps.14.09": [40, true], "aps.14.10": [40, true], "aps.14.11": [40, true], "aps.14.12": [40, true], "aps.14.13": [40, true], "aps.14.14": [40, true], "aps.14.15": [40, true], "aps.14.16": [40, true], "aps.14.17": [40, true], "aps.14.18": [40, true], "aps.14.19": [40, true], "aps.14.20": [40, true], "aps.14.21": [40, true], "aps.14.22": [40, true], "aps.14.23": [40, true], "aps.14.24": [40, true], "aps.14.25": [40, true], "aps.14.26": [40, true], "aps.14.27": [40, true], "aps.14.28": [40, true], "aps.14.29": [40, true], "aps.14.30": [40, true], "aps.14.31": [40, true], "aps.14.32": [40, true], "aps.14.33": [40, true], "aps.14.34": [40, true], "aps.14.35": [40, true], "aps.14.36": [40, true], "aps.14.37": [40, true], "aps.14.38": [40, true], "aps.14.39": [40, true], "aps.15.00": [45, true], "aps.15.01": [45, true], "aps.15.02": [44, true], "aps.15.03": [43, true], "aps.15.04": [40, true], "aps.15.05": [41, true], "aps.15.06": [42, true], "aps.15.07": [42, true], "aps.15.08": [41, true], "aps.15.09": [41, true], "aps.15.10": [42, true], "aps.15.11": [43, true], "aps.15.12": [43, true], "aps.15.13": [43, true], "aps.15.14": [44, true], "aps.15.15": [44, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [44, true], "aps.15.21": [47, true], "aps.15.22": [44, true], "aps.15.23": [48, true], "aps.15.24": [40, true], "aps.15.25": [45, true], "aps.15.26": [46, true], "aps.15.27": [47, true], "aps.15.28": [45, true], "aps.15.29": [43, true], "aps.15.30": [46, true]}}, "CHA": {"total": 4159, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [35, true], "fun1.3": [35, true], "fun1.4": [51, true], "fun1.5": [74, true], "fun2.1": [31, true], "fun2.2": [110, true], "fun2.3": [103, true], "fun2.4": [106, true], "fun2.5": [118, true], "fun3.1": [89, true], "fun3.2": [92, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [152, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [112, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [51, false], "fun7.3": [53, false], "fun7.4": [57, false], "fun7.5": [57, false], "fun8.1": [35, true], "fun8.2": [38, true], "fun8.3": [41, true], "fun8.4": [47, true], "fun8.5": [53, true], "fun9.1": [31, true], "fun9.2": [31, true], "fun9.3": [39, true], "fun9.4": [56, true], "fun9.5": [44, true]}}}, {"label": "pure.ratio_soft.derived3.safe", "spec": ["pure", "ratio_soft", "derived3", "safe"], "APS": {"total": 5778, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [28, true], "aps.02.00": [33, true], "aps.02.01": [35, true], "aps.02.02": [35, true], "aps.02.03": [35, true], "aps.02.04": [34, true], "aps.02.05": [36, true], "aps.02.06": [35, true], "aps.02.07": [34, true], "aps.02.08": [36, true], "aps.02.09": [36, true], "aps.03.00": [38, true], "aps.03.01": [39, true], "aps.03.02": [39, true], "aps.04.00": [35, true], "aps.04.01": [36, true], "aps.04.02": [29, true], "aps.04.03": [38, true], "aps.04.04": [35, true], "aps.04.05": [34, true], "aps.04.06": [35, true], "aps.04.07": [35, true], "aps.04.08": [33, true], "aps.04.09": [35, true], "aps.04.10": [38, true], "aps.04.11": [36, true], "aps.04.12": [37, true], "aps.04.13": [38, true], "aps.05.00": [33, true], "aps.06.00": [32, true], "aps.06.01": [32, true], "aps.06.02": [32, true], "aps.06.03": [30, true], "aps.06.04": [30, true], "aps.06.05": [31, true], "aps.06.06": [33, true], "aps.06.07": [33, true], "aps.06.08": [32, true], "aps.06.09": [29, true], "aps.07.00": [32, true], "aps.07.01": [30, true], "aps.07.02": [29, true], "aps.08.00": [3, true], "aps.08.01": [30, true], "aps.08.02": [28, true], "aps.08.03": [32, true], "aps.08.04": [33, true], "aps.09.00": [32, true], "aps.09.01": [31, true], "aps.09.02": [30, true], "aps.09.03": [29, true], "aps.09.04": [27, true], "aps.09.05": [24, true], "aps.09.06": [22, true], "aps.10.00": [32, true], "aps.10.01": [28, true], "aps.10.02": [31, true], "aps.10.03": [31, true], "aps.10.04": [32, true], "aps.11.00": [32, true], "aps.11.01": [31, true], "aps.11.02": [33, true], "aps.11.03": [33, true], "aps.12.00": [32, true], "aps.12.01": [34, true], "aps.12.02": [35, true], "aps.12.03": [35, true], "aps.12.04": [35, true], "aps.12.05": [35, true], "aps.12.06": [35, true], "aps.12.07": [35, true], "aps.12.08": [37, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [37, true], "aps.12.13": [37, true], "aps.12.14": [37, true], "aps.12.15": [36, true], "aps.12.16": [36, true], "aps.12.17": [36, true], "aps.12.18": [36, true], "aps.13.00": [13, false], "aps.14.00": [38, true], "aps.14.01": [38, true], "aps.14.02": [38, true], "aps.14.03": [38, true], "aps.14.04": [38, true], "aps.14.05": [38, true], "aps.14.06": [38, true], "aps.14.07": [38, true], "aps.14.08": [38, true], "aps.14.09": [38, true], "aps.14.10": [38, true], "aps.14.11": [38, true], "aps.14.12": [38, true], "aps.14.13": [38, true], "aps.14.14": [38, true], "aps.14.15": [38, true], "aps.14.16": [38, true], "aps.14.17": [38, true], "aps.14.18": [38, true], "aps.14.19": [38, true], "aps.14.20": [38, true], "aps.14.21": [38, true], "aps.14.22": [38, true], "aps.14.23": [38, true], "aps.14.24": [38, true], "aps.14.25": [38, true], "aps.14.26": [38, true], "aps.14.27": [38, true], "aps.14.28": [38, true], "aps.14.29": [38, true], "aps.14.30": [38, true], "aps.14.31": [38, true], "aps.14.32": [38, true], "aps.14.33": [38, true], "aps.14.34": [38, true], "aps.14.35": [38, true], "aps.14.36": [38, true], "aps.14.37": [38, true], "aps.14.38": [38, true], "aps.14.39": [38, true], "aps.15.00": [44, true], "aps.15.01": [44, true], "aps.15.02": [44, true], "aps.15.03": [43, true], "aps.15.04": [42, true], "aps.15.05": [41, true], "aps.15.06": [40, true], "aps.15.07": [41, true], "aps.15.08": [41, true], "aps.15.09": [41, true], "aps.15.10": [39, true], "aps.15.11": [39, true], "aps.15.12": [40, true], "aps.15.13": [42, true], "aps.15.14": [43, true], "aps.15.15": [43, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [44, true], "aps.15.21": [39, true], "aps.15.22": [47, true], "aps.15.23": [46, true], "aps.15.24": [48, true], "aps.15.25": [47, true], "aps.15.26": [43, true], "aps.15.27": [47, true], "aps.15.28": [48, true], "aps.15.29": [49, true], "aps.15.30": [49, true]}}, "CHA": {"total": 3681, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [32, true], "fun1.3": [36, true], "fun1.4": [33, true], "fun1.5": [54, true], "fun2.1": [32, true], "fun2.2": [51, true], "fun2.3": [64, true], "fun2.4": [73, true], "fun2.5": [78, true], "fun3.1": [70, true], "fun3.2": [71, true], "fun3.3": [84, true], "fun3.4": [92, true], "fun3.5": [110, true], "fun4.1": [87, true], "fun4.2": [91, true], "fun4.3": [107, true], "fun4.4": [125, true], "fun4.5": [145, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [91, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [71, true], "fun6.2": [81, true], "fun6.3": [74, true], "fun6.4": [82, true], "fun6.5": [88, true], "fun7.1": [13, false], "fun7.2": [12, false], "fun7.3": [13, false], "fun7.4": [11, false], "fun7.5": [12, false], "fun8.1": [34, true], "fun8.2": [35, true], "fun8.3": [36, true], "fun8.4": [38, true], "fun8.5": [40, true], "fun9.1": [32, true], "fun9.2": [32, true], "fun9.3": [39, true], "fun9.4": [41, true], "fun9.5": [36, true]}}}, {"label": "pure.ratio_soft.derived3.credit", "spec": ["pure", "ratio_soft", "derived3", "credit"], "APS": {"total": 6132, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [31, true], "aps.02.00": [45, true], "aps.02.01": [33, true], "aps.02.02": [46, true], "aps.02.03": [34, true], "aps.02.04": [32, true], "aps.02.05": [34, true], "aps.02.06": [36, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [32, true], "aps.06.00": [32, true], "aps.06.01": [32, true], "aps.06.02": [31, true], "aps.06.03": [30, true], "aps.06.04": [30, true], "aps.06.05": [31, true], "aps.06.06": [33, true], "aps.06.07": [33, true], "aps.06.08": [32, true], "aps.06.09": [29, true], "aps.07.00": [31, true], "aps.07.01": [30, true], "aps.07.02": [30, true], "aps.08.00": [31, true], "aps.08.01": [29, true], "aps.08.02": [43, true], "aps.08.03": [35, true], "aps.08.04": [43, true], "aps.09.00": [32, true], "aps.09.01": [33, true], "aps.09.02": [31, true], "aps.09.03": [30, true], "aps.09.04": [27, true], "aps.09.05": [26, true], "aps.09.06": [27, true], "aps.10.00": [32, true], "aps.10.01": [30, true], "aps.10.02": [29, true], "aps.10.03": [31, true], "aps.10.04": [31, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [30, true], "aps.11.03": [43, true], "aps.12.00": [32, true], "aps.12.01": [34, true], "aps.12.02": [35, true], "aps.12.03": [35, true], "aps.12.04": [35, true], "aps.12.05": [35, true], "aps.12.06": [35, true], "aps.12.07": [35, true], "aps.12.08": [37, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [37, true], "aps.12.13": [37, true], "aps.12.14": [37, true], "aps.12.15": [36, true], "aps.12.16": [36, true], "aps.12.17": [30, true], "aps.12.18": [37, true], "aps.13.00": [9, false], "aps.14.00": [38, true], "aps.14.01": [38, true], "aps.14.02": [38, true], "aps.14.03": [38, true], "aps.14.04": [38, true], "aps.14.05": [38, true], "aps.14.06": [38, true], "aps.14.07": [38, true], "aps.14.08": [38, true], "aps.14.09": [38, true], "aps.14.10": [38, true], "aps.14.11": [38, true], "aps.14.12": [38, true], "aps.14.13": [38, true], "aps.14.14": [38, true], "aps.14.15": [38, true], "aps.14.16": [38, true], "aps.14.17": [38, true], "aps.14.18": [38, true], "aps.14.19": [38, true], "aps.14.20": [38, true], "aps.14.21": [38, true], "aps.14.22": [38, true], "aps.14.23": [38, true], "aps.14.24": [38, true], "aps.14.25": [38, true], "aps.14.26": [38, true], "aps.14.27": [38, true], "aps.14.28": [38, true], "aps.14.29": [38, true], "aps.14.30": [38, true], "aps.14.31": [38, true], "aps.14.32": [38, true], "aps.14.33": [38, true], "aps.14.34": [38, true], "aps.14.35": [38, true], "aps.14.36": [38, true], "aps.14.37": [38, true], "aps.14.38": [38, true], "aps.14.39": [38, true], "aps.15.00": [44, true], "aps.15.01": [44, true], "aps.15.02": [44, true], "aps.15.03": [43, true], "aps.15.04": [42, true], "aps.15.05": [41, true], "aps.15.06": [37, true], "aps.15.07": [40, true], "aps.15.08": [40, true], "aps.15.09": [37, true], "aps.15.10": [38, true], "aps.15.11": [41, true], "aps.15.12": [42, true], "aps.15.13": [43, true], "aps.15.14": [43, true], "aps.15.15": [44, true], "aps.15.16": [44, true], "aps.15.17": [44, true], "aps.15.18": [44, true], "aps.15.19": [44, true], "aps.15.20": [45, true], "aps.15.21": [44, true], "aps.15.22": [46, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [48, true], "aps.15.29": [45, true], "aps.15.30": [46, true]}}, "CHA": {"total": 3054, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [57, true], "fun2.1": [32, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [7, false], "fun7.3": [10, false], "fun7.4": [12, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [41, true], "fun9.1": [32, true], "fun9.2": [34, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.ratio_soft.derived3.both", "spec": ["pure", "ratio_soft", "derived3", "both"], "APS": {"total": 5960, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [33, true], "aps.02.00": [36, true], "aps.02.01": [35, true], "aps.02.02": [35, true], "aps.02.03": [35, true], "aps.02.04": [32, true], "aps.02.05": [36, true], "aps.02.06": [33, true], "aps.02.07": [37, true], "aps.02.08": [37, true], "aps.02.09": [36, true], "aps.03.00": [38, true], "aps.03.01": [39, true], "aps.03.02": [38, true], "aps.04.00": [35, true], "aps.04.01": [37, true], "aps.04.02": [38, true], "aps.04.03": [38, true], "aps.04.04": [38, true], "aps.04.05": [37, true], "aps.04.06": [37, true], "aps.04.07": [36, true], "aps.04.08": [36, true], "aps.04.09": [38, true], "aps.04.10": [34, true], "aps.04.11": [37, true], "aps.04.12": [38, true], "aps.04.13": [38, true], "aps.05.00": [33, true], "aps.06.00": [32, true], "aps.06.01": [32, true], "aps.06.02": [32, true], "aps.06.03": [32, true], "aps.06.04": [30, true], "aps.06.05": [30, true], "aps.06.06": [33, true], "aps.06.07": [32, true], "aps.06.08": [33, true], "aps.06.09": [27, true], "aps.07.00": [32, true], "aps.07.01": [32, true], "aps.07.02": [32, true], "aps.08.00": [3, true], "aps.08.01": [30, true], "aps.08.02": [32, true], "aps.08.03": [33, true], "aps.08.04": [30, true], "aps.09.00": [32, true], "aps.09.01": [31, true], "aps.09.02": [32, true], "aps.09.03": [32, true], "aps.09.04": [31, true], "aps.09.05": [27, true], "aps.09.06": [31, true], "aps.10.00": [32, true], "aps.10.01": [33, true], "aps.10.02": [34, true], "aps.10.03": [33, true], "aps.10.04": [33, true], "aps.11.00": [32, true], "aps.11.01": [33, true], "aps.11.02": [35, true], "aps.11.03": [35, true], "aps.12.00": [36, true], "aps.12.01": [35, true], "aps.12.02": [34, true], "aps.12.03": [36, true], "aps.12.04": [37, true], "aps.12.05": [37, true], "aps.12.06": [38, true], "aps.12.07": [38, true], "aps.12.08": [37, true], "aps.12.09": [37, true], "aps.12.10": [37, true], "aps.12.11": [37, true], "aps.12.12": [37, true], "aps.12.13": [38, true], "aps.12.14": [38, true], "aps.12.15": [38, true], "aps.12.16": [35, true], "aps.12.17": [35, true], "aps.12.18": [34, true], "aps.13.00": [9, false], "aps.14.00": [40, true], "aps.14.01": [40, true], "aps.14.02": [40, true], "aps.14.03": [40, true], "aps.14.04": [40, true], "aps.14.05": [40, true], "aps.14.06": [40, true], "aps.14.07": [40, true], "aps.14.08": [40, true], "aps.14.09": [40, true], "aps.14.10": [40, true], "aps.14.11": [40, true], "aps.14.12": [40, true], "aps.14.13": [40, true], "aps.14.14": [40, true], "aps.14.15": [40, true], "aps.14.16": [40, true], "aps.14.17": [40, true], "aps.14.18": [40, true], "aps.14.19": [40, true], "aps.14.20": [40, true], "aps.14.21": [40, true], "aps.14.22": [40, true], "aps.14.23": [40, true], "aps.14.24": [40, true], "aps.14.25": [40, true], "aps.14.26": [40, true], "aps.14.27": [40, true], "aps.14.28": [40, true], "aps.14.29": [40, true], "aps.14.30": [40, true], "aps.14.31": [40, true], "aps.14.32": [40, true], "aps.14.33": [40, true], "aps.14.34": [40, true], "aps.14.35": [40, true], "aps.14.36": [40, true], "aps.14.37": [40, true], "aps.14.38": [40, true], "aps.14.39": [40, true], "aps.15.00": [45, true], "aps.15.01": [45, true], "aps.15.02": [46, true], "aps.15.03": [43, true], "aps.15.04": [44, true], "aps.15.05": [44, true], "aps.15.06": [41, true], "aps.15.07": [42, true], "aps.15.08": [42, true], "aps.15.09": [41, true], "aps.15.10": [40, true], "aps.15.11": [40, true], "aps.15.12": [44, true], "aps.15.13": [44, true], "aps.15.14": [45, true], "aps.15.15": [45, true], "aps.15.16": [45, true], "aps.15.17": [45, true], "aps.15.18": [45, true], "aps.15.19": [44, true], "aps.15.20": [43, true], "aps.15.21": [41, true], "aps.15.22": [45, true], "aps.15.23": [45, true], "aps.15.24": [45, true], "aps.15.25": [47, true], "aps.15.26": [46, true], "aps.15.27": [44, true], "aps.15.28": [46, true], "aps.15.29": [46, true], "aps.15.30": [45, true]}}, "CHA": {"total": 3370, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [30, true], "fun1.2": [38, true], "fun1.3": [40, true], "fun1.4": [52, true], "fun1.5": [73, true], "fun2.1": [33, true], "fun2.2": [52, true], "fun2.3": [65, true], "fun2.4": [72, true], "fun2.5": [74, true], "fun3.1": [63, true], "fun3.2": [65, true], "fun3.3": [74, true], "fun3.4": [84, true], "fun3.5": [100, true], "fun4.1": [66, true], "fun4.2": [69, true], "fun4.3": [81, true], "fun4.4": [94, true], "fun4.5": [116, true], "fun5.1": [70, true], "fun5.2": [73, true], "fun5.3": [71, true], "fun5.4": [77, true], "fun5.5": [79, true], "fun6.1": [53, true], "fun6.2": [60, true], "fun6.3": [56, true], "fun6.4": [59, true], "fun6.5": [63, true], "fun7.1": [9, false], "fun7.2": [8, false], "fun7.3": [10, false], "fun7.4": [9, false], "fun7.5": [11, false], "fun8.1": [34, true], "fun8.2": [34, true], "fun8.3": [35, true], "fun8.4": [39, true], "fun8.5": [43, true], "fun9.1": [33, true], "fun9.2": [34, true], "fun9.3": [37, true], "fun9.4": [39, true], "fun9.5": [40, true]}}}, {"label": "pure.rational.start.none", "spec": ["pure", "rational", "start", "none"], "APS": {"total": 21670, "solved": 56, "n": 154, "over": 0, "per": {"aps.01.00": [200, false], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [48, true], "aps.04.00": [200, false], "aps.04.01": [24, true], "aps.04.02": [200, false], "aps.04.03": [19, true], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [55, true], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [36, true], "aps.04.13": [200, false], "aps.05.00": [18, true], "aps.06.00": [21, true], "aps.06.01": [200, false], "aps.06.02": [34, true], "aps.06.03": [34, true], "aps.06.04": [35, true], "aps.06.05": [38, true], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [13, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [200, false], "aps.09.03": [10, true], "aps.09.04": [8, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [24, true], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [22, true], "aps.11.03": [27, true], "aps.12.00": [23, true], "aps.12.01": [33, true], "aps.12.02": [39, true], "aps.12.03": [46, true], "aps.12.04": [50, true], "aps.12.05": [55, true], "aps.12.06": [62, true], "aps.12.07": [68, true], "aps.12.08": [68, true], "aps.12.09": [59, true], "aps.12.10": [53, true], "aps.12.11": [46, true], "aps.12.12": [42, true], "aps.12.13": [38, true], "aps.12.14": [34, true], "aps.12.15": [30, true], "aps.12.16": [26, true], "aps.12.17": [24, true], "aps.12.18": [21, true], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [41, true], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [200, false], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [200, false], "aps.15.10": [200, false], "aps.15.11": [200, false], "aps.15.12": [200, false], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [200, false], "aps.15.17": [200, false], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [88, true], "aps.15.21": [200, false], "aps.15.22": [42, true], "aps.15.23": [200, false], "aps.15.24": [200, false], "aps.15.25": [200, false], "aps.15.26": [61, true], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 8048, "solved": 6, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [43, true], "fun2.3": [200, false], "fun2.4": [71, true], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [200, false], "fun8.2": [21, true], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [22, true], "fun9.2": [47, true], "fun9.3": [44, true], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.rational.start.both", "spec": ["pure", "rational", "start", "both"], "APS": {"total": 9800, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [63, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [88, true], "aps.03.01": [59, true], "aps.03.02": [48, true], "aps.04.00": [60, true], "aps.04.01": [63, true], "aps.04.02": [65, true], "aps.04.03": [64, true], "aps.04.04": [64, true], "aps.04.05": [61, true], "aps.04.06": [63, true], "aps.04.07": [62, true], "aps.04.08": [65, true], "aps.04.09": [64, true], "aps.04.10": [62, true], "aps.04.11": [62, true], "aps.04.12": [63, true], "aps.04.13": [63, true], "aps.05.00": [60, true], "aps.06.00": [61, true], "aps.06.01": [60, true], "aps.06.02": [62, true], "aps.06.03": [60, true], "aps.06.04": [63, true], "aps.06.05": [58, true], "aps.06.06": [58, true], "aps.06.07": [63, true], "aps.06.08": [58, true], "aps.06.09": [59, true], "aps.07.00": [58, true], "aps.07.01": [56, true], "aps.07.02": [55, true], "aps.08.00": [3, true], "aps.08.01": [59, true], "aps.08.02": [62, true], "aps.08.03": [60, true], "aps.08.04": [58, true], "aps.09.00": [59, true], "aps.09.01": [59, true], "aps.09.02": [54, true], "aps.09.03": [55, true], "aps.09.04": [56, true], "aps.09.05": [52, true], "aps.09.06": [49, true], "aps.10.00": [60, true], "aps.10.01": [61, true], "aps.10.02": [59, true], "aps.10.03": [57, true], "aps.10.04": [56, true], "aps.11.00": [53, true], "aps.11.01": [59, true], "aps.11.02": [55, true], "aps.11.03": [60, true], "aps.12.00": [63, true], "aps.12.01": [65, true], "aps.12.02": [65, true], "aps.12.03": [65, true], "aps.12.04": [69, true], "aps.12.05": [64, true], "aps.12.06": [67, true], "aps.12.07": [67, true], "aps.12.08": [69, true], "aps.12.09": [65, true], "aps.12.10": [66, true], "aps.12.11": [67, true], "aps.12.12": [69, true], "aps.12.13": [66, true], "aps.12.14": [68, true], "aps.12.15": [62, true], "aps.12.16": [69, true], "aps.12.17": [68, true], "aps.12.18": [67, true], "aps.13.00": [9, false], "aps.14.00": [68, true], "aps.14.01": [68, true], "aps.14.02": [68, true], "aps.14.03": [68, true], "aps.14.04": [68, true], "aps.14.05": [68, true], "aps.14.06": [68, true], "aps.14.07": [68, true], "aps.14.08": [68, true], "aps.14.09": [68, true], "aps.14.10": [68, true], "aps.14.11": [68, true], "aps.14.12": [68, true], "aps.14.13": [68, true], "aps.14.14": [68, true], "aps.14.15": [68, true], "aps.14.16": [68, true], "aps.14.17": [68, true], "aps.14.18": [68, true], "aps.14.19": [68, true], "aps.14.20": [68, true], "aps.14.21": [68, true], "aps.14.22": [68, true], "aps.14.23": [68, true], "aps.14.24": [68, true], "aps.14.25": [68, true], "aps.14.26": [68, true], "aps.14.27": [68, true], "aps.14.28": [68, true], "aps.14.29": [68, true], "aps.14.30": [68, true], "aps.14.31": [68, true], "aps.14.32": [68, true], "aps.14.33": [68, true], "aps.14.34": [68, true], "aps.14.35": [68, true], "aps.14.36": [68, true], "aps.14.37": [68, true], "aps.14.38": [68, true], "aps.14.39": [68, true], "aps.15.00": [72, true], "aps.15.01": [71, true], "aps.15.02": [68, true], "aps.15.03": [69, true], "aps.15.04": [67, true], "aps.15.05": [66, true], "aps.15.06": [64, true], "aps.15.07": [65, true], "aps.15.08": [63, true], "aps.15.09": [62, true], "aps.15.10": [63, true], "aps.15.11": [64, true], "aps.15.12": [64, true], "aps.15.13": [67, true], "aps.15.14": [66, true], "aps.15.15": [67, true], "aps.15.16": [70, true], "aps.15.17": [67, true], "aps.15.18": [69, true], "aps.15.19": [67, true], "aps.15.20": [70, true], "aps.15.21": [66, true], "aps.15.22": [68, true], "aps.15.23": [63, true], "aps.15.24": [63, true], "aps.15.25": [65, true], "aps.15.26": [66, true], "aps.15.27": [65, true], "aps.15.28": [65, true], "aps.15.29": [62, true], "aps.15.30": [61, true]}}, "CHA": {"total": 3569, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [65, true], "fun1.3": [73, true], "fun1.4": [73, true], "fun1.5": [93, true], "fun2.1": [49, true], "fun2.2": [71, true], "fun2.3": [79, true], "fun2.4": [93, true], "fun2.5": [94, true], "fun3.1": [55, true], "fun3.2": [57, true], "fun3.3": [72, true], "fun3.4": [79, true], "fun3.5": [93, true], "fun4.1": [51, true], "fun4.2": [52, true], "fun4.3": [67, true], "fun4.4": [73, true], "fun4.5": [87, true], "fun5.1": [49, true], "fun5.2": [49, true], "fun5.3": [53, true], "fun5.4": [54, true], "fun5.5": [55, true], "fun6.1": [47, true], "fun6.2": [47, true], "fun6.3": [50, true], "fun6.4": [52, true], "fun6.5": [53, true], "fun7.1": [9, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [13, false], "fun7.5": [15, false], "fun8.1": [56, true], "fun8.2": [60, true], "fun8.3": [61, true], "fun8.4": [59, true], "fun8.5": [67, true], "fun9.1": [60, true], "fun9.2": [59, true], "fun9.3": [64, true], "fun9.4": [69, true], "fun9.5": [71, true]}}}, {"label": "pure.rational.start.project", "spec": ["pure", "rational", "start", "project"], "APS": {"total": 11947, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [48, true], "aps.04.00": [88, true], "aps.04.01": [24, true], "aps.04.02": [88, true], "aps.04.03": [19, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [36, true], "aps.04.13": [88, true], "aps.05.00": [18, true], "aps.06.00": [21, true], "aps.06.01": [83, true], "aps.06.02": [34, true], "aps.06.03": [34, true], "aps.06.04": [35, true], "aps.06.05": [38, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [13, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [83, true], "aps.08.04": [83, true], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [83, true], "aps.09.03": [10, true], "aps.09.04": [8, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [24, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [82, true], "aps.10.04": [83, true], "aps.11.00": [82, true], "aps.11.01": [83, true], "aps.11.02": [22, true], "aps.11.03": [27, true], "aps.12.00": [23, true], "aps.12.01": [33, true], "aps.12.02": [39, true], "aps.12.03": [46, true], "aps.12.04": [50, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [96, true], "aps.12.11": [46, true], "aps.12.12": [42, true], "aps.12.13": [38, true], "aps.12.14": [34, true], "aps.12.15": [30, true], "aps.12.16": [26, true], "aps.12.17": [24, true], "aps.12.18": [21, true], "aps.13.00": [50, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [41, true], "aps.15.01": [103, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [103, true], "aps.15.05": [103, true], "aps.15.06": [103, true], "aps.15.07": [103, true], "aps.15.08": [102, true], "aps.15.09": [102, true], "aps.15.10": [103, true], "aps.15.11": [103, true], "aps.15.12": [102, true], "aps.15.13": [102, true], "aps.15.14": [102, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [102, true], "aps.15.21": [102, true], "aps.15.22": [42, true], "aps.15.23": [103, true], "aps.15.24": [103, true], "aps.15.25": [103, true], "aps.15.26": [61, true], "aps.15.27": [103, true], "aps.15.28": [103, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 4762, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [91, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [153, true], "fun2.1": [82, true], "fun2.2": [43, true], "fun2.3": [122, true], "fun2.4": [71, true], "fun2.5": [163, true], "fun3.1": [88, true], "fun3.2": [92, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [50, false], "fun7.2": [51, false], "fun7.3": [50, false], "fun7.4": [57, false], "fun7.5": [60, false], "fun8.1": [85, true], "fun8.2": [21, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [97, true], "fun9.1": [22, true], "fun9.2": [47, true], "fun9.3": [44, true], "fun9.4": [92, true], "fun9.5": [96, true]}}}, {"label": "pure.rational.start.credit", "spec": ["pure", "rational", "start", "credit"], "APS": {"total": 7509, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [48, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [10, true], "aps.09.04": [8, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [7, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [7, false], "fun7.2": [10, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.rational.start.bracket", "spec": ["pure", "rational", "start", "bracket"], "APS": {"total": 10561, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [66, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [88, true], "aps.03.01": [59, true], "aps.03.02": [48, true], "aps.04.00": [68, true], "aps.04.01": [70, true], "aps.04.02": [70, true], "aps.04.03": [70, true], "aps.04.04": [70, true], "aps.04.05": [69, true], "aps.04.06": [69, true], "aps.04.07": [69, true], "aps.04.08": [70, true], "aps.04.09": [68, true], "aps.04.10": [70, true], "aps.04.11": [68, true], "aps.04.12": [68, true], "aps.04.13": [67, true], "aps.05.00": [66, true], "aps.06.00": [67, true], "aps.06.01": [67, true], "aps.06.02": [68, true], "aps.06.03": [68, true], "aps.06.04": [67, true], "aps.06.05": [67, true], "aps.06.06": [66, true], "aps.06.07": [67, true], "aps.06.08": [66, true], "aps.06.09": [66, true], "aps.07.00": [64, true], "aps.07.01": [61, true], "aps.07.02": [60, true], "aps.08.00": [3, true], "aps.08.01": [68, true], "aps.08.02": [68, true], "aps.08.03": [68, true], "aps.08.04": [68, true], "aps.09.00": [67, true], "aps.09.01": [67, true], "aps.09.02": [63, true], "aps.09.03": [60, true], "aps.09.04": [58, true], "aps.09.05": [52, true], "aps.09.06": [48, true], "aps.10.00": [66, true], "aps.10.01": [66, true], "aps.10.02": [66, true], "aps.10.03": [64, true], "aps.10.04": [62, true], "aps.11.00": [60, true], "aps.11.01": [67, true], "aps.11.02": [67, true], "aps.11.03": [67, true], "aps.12.00": [70, true], "aps.12.01": [72, true], "aps.12.02": [73, true], "aps.12.03": [73, true], "aps.12.04": [73, true], "aps.12.05": [73, true], "aps.12.06": [74, true], "aps.12.07": [75, true], "aps.12.08": [75, true], "aps.12.09": [75, true], "aps.12.10": [75, true], "aps.12.11": [71, true], "aps.12.12": [74, true], "aps.12.13": [75, true], "aps.12.14": [74, true], "aps.12.15": [74, true], "aps.12.16": [74, true], "aps.12.17": [74, true], "aps.12.18": [74, true], "aps.13.00": [9, false], "aps.14.00": [71, true], "aps.14.01": [71, true], "aps.14.02": [71, true], "aps.14.03": [71, true], "aps.14.04": [71, true], "aps.14.05": [71, true], "aps.14.06": [71, true], "aps.14.07": [71, true], "aps.14.08": [71, true], "aps.14.09": [71, true], "aps.14.10": [71, true], "aps.14.11": [71, true], "aps.14.12": [71, true], "aps.14.13": [71, true], "aps.14.14": [71, true], "aps.14.15": [71, true], "aps.14.16": [71, true], "aps.14.17": [71, true], "aps.14.18": [71, true], "aps.14.19": [71, true], "aps.14.20": [71, true], "aps.14.21": [71, true], "aps.14.22": [71, true], "aps.14.23": [71, true], "aps.14.24": [71, true], "aps.14.25": [71, true], "aps.14.26": [71, true], "aps.14.27": [71, true], "aps.14.28": [71, true], "aps.14.29": [71, true], "aps.14.30": [71, true], "aps.14.31": [71, true], "aps.14.32": [71, true], "aps.14.33": [71, true], "aps.14.34": [71, true], "aps.14.35": [71, true], "aps.14.36": [71, true], "aps.14.37": [71, true], "aps.14.38": [71, true], "aps.14.39": [71, true], "aps.15.00": [76, true], "aps.15.01": [76, true], "aps.15.02": [75, true], "aps.15.03": [75, true], "aps.15.04": [75, true], "aps.15.05": [73, true], "aps.15.06": [73, true], "aps.15.07": [73, true], "aps.15.08": [71, true], "aps.15.09": [69, true], "aps.15.10": [67, true], "aps.15.11": [71, true], "aps.15.12": [73, true], "aps.15.13": [73, true], "aps.15.14": [73, true], "aps.15.15": [75, true], "aps.15.16": [75, true], "aps.15.17": [75, true], "aps.15.18": [75, true], "aps.15.19": [75, true], "aps.15.20": [75, true], "aps.15.21": [73, true], "aps.15.22": [73, true], "aps.15.23": [72, true], "aps.15.24": [66, true], "aps.15.25": [70, true], "aps.15.26": [71, true], "aps.15.27": [71, true], "aps.15.28": [70, true], "aps.15.29": [68, true], "aps.15.30": [66, true]}}, "CHA": {"total": 3718, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [64, true], "fun1.2": [70, true], "fun1.3": [77, true], "fun1.4": [77, true], "fun1.5": [93, true], "fun2.1": [57, true], "fun2.2": [79, true], "fun2.3": [85, true], "fun2.4": [99, true], "fun2.5": [104, true], "fun3.1": [58, true], "fun3.2": [61, true], "fun3.3": [71, true], "fun3.4": [79, true], "fun3.5": [93, true], "fun4.1": [53, true], "fun4.2": [56, true], "fun4.3": [67, true], "fun4.4": [73, true], "fun4.5": [87, true], "fun5.1": [51, true], "fun5.2": [51, true], "fun5.3": [54, true], "fun5.4": [56, true], "fun5.5": [57, true], "fun6.1": [48, true], "fun6.2": [47, true], "fun6.3": [50, true], "fun6.4": [52, true], "fun6.5": [53, true], "fun7.1": [9, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [13, false], "fun7.5": [15, false], "fun8.1": [64, true], "fun8.2": [68, true], "fun8.3": [68, true], "fun8.4": [65, true], "fun8.5": [73, true], "fun9.1": [66, true], "fun9.2": [68, true], "fun9.3": [72, true], "fun9.4": [75, true], "fun9.5": [77, true]}}}, {"label": "pure.rational.bracket.step", "spec": ["pure", "rational", "bracket", "step"], "APS": {"total": 6929, "solved": 153, "n": 154, "over": 14, "per": {"aps.01.00": [36, true], "aps.02.00": [57, true], "aps.02.01": [17, true], "aps.02.02": [18, true], "aps.02.03": [51, true], "aps.02.04": [53, true], "aps.02.05": [61, true], "aps.02.06": [59, true], "aps.02.07": [58, true], "aps.02.08": [57, true], "aps.02.09": [56, true], "aps.03.00": [72, true], "aps.03.01": [49, true], "aps.03.02": [31, true], "aps.04.00": [59, true], "aps.04.01": [30, true], "aps.04.02": [90, true], "aps.04.03": [51, true], "aps.04.04": [83, true], "aps.04.05": [39, true], "aps.04.06": [55, true], "aps.04.07": [27, true], "aps.04.08": [16, true], "aps.04.09": [25, true], "aps.04.10": [25, true], "aps.04.11": [29, true], "aps.04.12": [27, true], "aps.04.13": [26, true], "aps.05.00": [19, true], "aps.06.00": [21, true], "aps.06.01": [68, true], "aps.06.02": [34, true], "aps.06.03": [34, true], "aps.06.04": [35, true], "aps.06.05": [38, true], "aps.06.06": [73, true], "aps.06.07": [73, true], "aps.06.08": [73, true], "aps.06.09": [72, true], "aps.07.00": [53, true], "aps.07.01": [17, true], "aps.07.02": [16, true], "aps.08.00": [3, true], "aps.08.01": [86, true], "aps.08.02": [134, true], "aps.08.03": [72, true], "aps.08.04": [65, true], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [17, true], "aps.09.03": [16, true], "aps.09.04": [18, true], "aps.09.05": [20, true], "aps.09.06": [21, true], "aps.10.00": [24, true], "aps.10.01": [132, true], "aps.10.02": [22, true], "aps.10.03": [55, true], "aps.10.04": [55, true], "aps.11.00": [18, true], "aps.11.01": [22, true], "aps.11.02": [25, true], "aps.11.03": [26, true], "aps.12.00": [23, true], "aps.12.01": [32, true], "aps.12.02": [39, true], "aps.12.03": [45, true], "aps.12.04": [50, true], "aps.12.05": [55, true], "aps.12.06": [104, true], "aps.12.07": [68, true], "aps.12.08": [115, true], "aps.12.09": [120, true], "aps.12.10": [123, true], "aps.12.11": [128, true], "aps.12.12": [131, true], "aps.12.13": [131, true], "aps.12.14": [130, true], "aps.12.15": [137, true], "aps.12.16": [131, true], "aps.12.17": [127, true], "aps.12.18": [32, true], "aps.13.00": [11, false], "aps.14.00": [25, true], "aps.14.01": [25, true], "aps.14.02": [25, true], "aps.14.03": [25, true], "aps.14.04": [25, true], "aps.14.05": [25, true], "aps.14.06": [25, true], "aps.14.07": [25, true], "aps.14.08": [25, true], "aps.14.09": [25, true], "aps.14.10": [25, true], "aps.14.11": [25, true], "aps.14.12": [25, true], "aps.14.13": [25, true], "aps.14.14": [25, true], "aps.14.15": [25, true], "aps.14.16": [25, true], "aps.14.17": [25, true], "aps.14.18": [25, true], "aps.14.19": [25, true], "aps.14.20": [25, true], "aps.14.21": [25, true], "aps.14.22": [25, true], "aps.14.23": [25, true], "aps.14.24": [25, true], "aps.14.25": [25, true], "aps.14.26": [25, true], "aps.14.27": [25, true], "aps.14.28": [25, true], "aps.14.29": [25, true], "aps.14.30": [25, true], "aps.14.31": [25, true], "aps.14.32": [25, true], "aps.14.33": [25, true], "aps.14.34": [25, true], "aps.14.35": [25, true], "aps.14.36": [25, true], "aps.14.37": [25, true], "aps.14.38": [25, true], "aps.14.39": [25, true], "aps.15.00": [40, true], "aps.15.01": [32, true], "aps.15.02": [34, true], "aps.15.03": [35, true], "aps.15.04": [37, true], "aps.15.05": [37, true], "aps.15.06": [36, true], "aps.15.07": [37, true], "aps.15.08": [36, true], "aps.15.09": [35, true], "aps.15.10": [33, true], "aps.15.11": [36, true], "aps.15.12": [36, true], "aps.15.13": [38, true], "aps.15.14": [38, true], "aps.15.15": [39, true], "aps.15.16": [40, true], "aps.15.17": [41, true], "aps.15.18": [42, true], "aps.15.19": [43, true], "aps.15.20": [44, true], "aps.15.21": [38, true], "aps.15.22": [47, true], "aps.15.23": [44, true], "aps.15.24": [40, true], "aps.15.25": [43, true], "aps.15.26": [47, true], "aps.15.27": [53, true], "aps.15.28": [39, true], "aps.15.29": [41, true], "aps.15.30": [44, true]}}, "CHA": {"total": 3841, "solved": 40, "n": 45, "over": 3, "per": {"fun1.1": [76, true], "fun1.2": [58, true], "fun1.3": [73, true], "fun1.4": [78, true], "fun1.5": [92, true], "fun2.1": [89, true], "fun2.2": [63, true], "fun2.3": [79, true], "fun2.4": [58, true], "fun2.5": [62, true], "fun3.1": [98, true], "fun3.2": [100, true], "fun3.3": [113, true], "fun3.4": [115, true], "fun3.5": [132, true], "fun4.1": [89, true], "fun4.2": [93, true], "fun4.3": [92, true], "fun4.4": [115, true], "fun4.5": [118, true], "fun5.1": [84, true], "fun5.2": [89, true], "fun5.3": [70, true], "fun5.4": [72, true], "fun5.5": [73, true], "fun6.1": [80, true], "fun6.2": [82, true], "fun6.3": [64, true], "fun6.4": [66, true], "fun6.5": [67, true], "fun7.1": [11, false], "fun7.2": [12, false], "fun7.3": [12, false], "fun7.4": [11, false], "fun7.5": [13, false], "fun8.1": [20, true], "fun8.2": [41, true], "fun8.3": [29, true], "fun8.4": [42, true], "fun8.5": [40, true], "fun9.1": [21, true], "fun9.2": [24, true], "fun9.3": [26, true], "fun9.4": [23, true], "fun9.5": [35, true]}}}, {"label": "pure.rational.bracket.both", "spec": ["pure", "rational", "bracket", "both"], "APS": {"total": 6630, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [42, true], "aps.02.00": [47, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [46, true], "aps.02.05": [43, true], "aps.02.06": [49, true], "aps.02.07": [46, true], "aps.02.08": [46, true], "aps.02.09": [46, true], "aps.03.00": [50, true], "aps.03.01": [48, true], "aps.03.02": [51, true], "aps.04.00": [47, true], "aps.04.01": [45, true], "aps.04.02": [47, true], "aps.04.03": [41, true], "aps.04.04": [41, true], "aps.04.05": [37, true], "aps.04.06": [40, true], "aps.04.07": [47, true], "aps.04.08": [45, true], "aps.04.09": [46, true], "aps.04.10": [45, true], "aps.04.11": [41, true], "aps.04.12": [42, true], "aps.04.13": [42, true], "aps.05.00": [45, true], "aps.06.00": [32, true], "aps.06.01": [44, true], "aps.06.02": [37, true], "aps.06.03": [39, true], "aps.06.04": [37, true], "aps.06.05": [39, true], "aps.06.06": [42, true], "aps.06.07": [41, true], "aps.06.08": [42, true], "aps.06.09": [38, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [40, true], "aps.08.03": [45, true], "aps.08.04": [44, true], "aps.09.00": [41, true], "aps.09.01": [41, true], "aps.09.02": [44, true], "aps.09.03": [44, true], "aps.09.04": [32, true], "aps.09.05": [42, true], "aps.09.06": [42, true], "aps.10.00": [45, true], "aps.10.01": [44, true], "aps.10.02": [45, true], "aps.10.03": [44, true], "aps.10.04": [44, true], "aps.11.00": [4, true], "aps.11.01": [28, true], "aps.11.02": [48, true], "aps.11.03": [43, true], "aps.12.00": [22, true], "aps.12.01": [26, true], "aps.12.02": [39, true], "aps.12.03": [40, true], "aps.12.04": [31, true], "aps.12.05": [41, true], "aps.12.06": [39, true], "aps.12.07": [49, true], "aps.12.08": [35, true], "aps.12.09": [42, true], "aps.12.10": [50, true], "aps.12.11": [30, true], "aps.12.12": [37, true], "aps.12.13": [20, true], "aps.12.14": [49, true], "aps.12.15": [44, true], "aps.12.16": [34, true], "aps.12.17": [27, true], "aps.12.18": [22, true], "aps.13.00": [6, false], "aps.14.00": [39, true], "aps.14.01": [39, true], "aps.14.02": [39, true], "aps.14.03": [39, true], "aps.14.04": [39, true], "aps.14.05": [39, true], "aps.14.06": [39, true], "aps.14.07": [39, true], "aps.14.08": [39, true], "aps.14.09": [39, true], "aps.14.10": [39, true], "aps.14.11": [39, true], "aps.14.12": [39, true], "aps.14.13": [39, true], "aps.14.14": [39, true], "aps.14.15": [39, true], "aps.14.16": [39, true], "aps.14.17": [39, true], "aps.14.18": [39, true], "aps.14.19": [39, true], "aps.14.20": [39, true], "aps.14.21": [39, true], "aps.14.22": [39, true], "aps.14.23": [39, true], "aps.14.24": [39, true], "aps.14.25": [39, true], "aps.14.26": [39, true], "aps.14.27": [39, true], "aps.14.28": [39, true], "aps.14.29": [39, true], "aps.14.30": [39, true], "aps.14.31": [39, true], "aps.14.32": [39, true], "aps.14.33": [39, true], "aps.14.34": [39, true], "aps.14.35": [39, true], "aps.14.36": [39, true], "aps.14.37": [39, true], "aps.14.38": [39, true], "aps.14.39": [39, true], "aps.15.00": [49, true], "aps.15.01": [52, true], "aps.15.02": [49, true], "aps.15.03": [51, true], "aps.15.04": [50, true], "aps.15.05": [50, true], "aps.15.06": [51, true], "aps.15.07": [49, true], "aps.15.08": [43, true], "aps.15.09": [45, true], "aps.15.10": [47, true], "aps.15.11": [49, true], "aps.15.12": [50, true], "aps.15.13": [51, true], "aps.15.14": [51, true], "aps.15.15": [51, true], "aps.15.16": [50, true], "aps.15.17": [53, true], "aps.15.18": [49, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [51, true], "aps.15.22": [52, true], "aps.15.23": [54, true], "aps.15.24": [53, true], "aps.15.25": [47, true], "aps.15.26": [54, true], "aps.15.27": [53, true], "aps.15.28": [47, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3314, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [45, true], "fun1.2": [46, true], "fun1.3": [52, true], "fun1.4": [55, true], "fun1.5": [77, true], "fun2.1": [40, true], "fun2.2": [56, true], "fun2.3": [66, true], "fun2.4": [64, true], "fun2.5": [84, true], "fun3.1": [53, true], "fun3.2": [50, true], "fun3.3": [66, true], "fun3.4": [75, true], "fun3.5": [83, true], "fun4.1": [57, true], "fun4.2": [63, true], "fun4.3": [84, true], "fun4.4": [79, true], "fun4.5": [84, true], "fun5.1": [62, true], "fun5.2": [64, true], "fun5.3": [65, true], "fun5.4": [67, true], "fun5.5": [69, true], "fun6.1": [62, true], "fun6.2": [56, true], "fun6.3": [56, true], "fun6.4": [60, true], "fun6.5": [61, true], "fun7.1": [6, false], "fun7.2": [10, false], "fun7.3": [10, false], "fun7.4": [11, false], "fun7.5": [13, false], "fun8.1": [40, true], "fun8.2": [27, true], "fun8.3": [51, true], "fun8.4": [52, true], "fun8.5": [53, true], "fun9.1": [28, true], "fun9.2": [45, true], "fun9.3": [29, true], "fun9.4": [39, true], "fun9.5": [49, true]}}}, {"label": "pure.rational.bracket.none", "spec": ["pure", "rational", "bracket", "none"], "APS": {"total": 11019, "solved": 126, "n": 154, "over": 5, "per": {"aps.01.00": [36, true], "aps.02.00": [200, false], "aps.02.01": [17, true], "aps.02.02": [200, false], "aps.02.03": [86, true], "aps.02.04": [69, true], "aps.02.05": [62, true], "aps.02.06": [59, true], "aps.02.07": [58, true], "aps.02.08": [57, true], "aps.02.09": [56, true], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [19, true], "aps.06.00": [21, true], "aps.06.01": [68, true], "aps.06.02": [34, true], "aps.06.03": [34, true], "aps.06.04": [35, true], "aps.06.05": [38, true], "aps.06.06": [73, true], "aps.06.07": [73, true], "aps.06.08": [73, true], "aps.06.09": [72, true], "aps.07.00": [53, true], "aps.07.01": [17, true], "aps.07.02": [16, true], "aps.08.00": [3, true], "aps.08.01": [86, true], "aps.08.02": [134, true], "aps.08.03": [186, true], "aps.08.04": [200, false], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [17, true], "aps.09.03": [16, true], "aps.09.04": [18, true], "aps.09.05": [20, true], "aps.09.06": [21, true], "aps.10.00": [24, true], "aps.10.01": [134, true], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [23, true], "aps.12.01": [32, true], "aps.12.02": [39, true], "aps.12.03": [45, true], "aps.12.04": [50, true], "aps.12.05": [55, true], "aps.12.06": [62, true], "aps.12.07": [68, true], "aps.12.08": [72, true], "aps.12.09": [77, true], "aps.12.10": [80, true], "aps.12.11": [84, true], "aps.12.12": [87, true], "aps.12.13": [89, true], "aps.12.14": [91, true], "aps.12.15": [94, true], "aps.12.16": [95, true], "aps.12.17": [98, true], "aps.12.18": [99, true], "aps.13.00": [200, false], "aps.14.00": [25, true], "aps.14.01": [25, true], "aps.14.02": [25, true], "aps.14.03": [25, true], "aps.14.04": [25, true], "aps.14.05": [25, true], "aps.14.06": [25, true], "aps.14.07": [25, true], "aps.14.08": [25, true], "aps.14.09": [25, true], "aps.14.10": [25, true], "aps.14.11": [25, true], "aps.14.12": [25, true], "aps.14.13": [25, true], "aps.14.14": [25, true], "aps.14.15": [25, true], "aps.14.16": [25, true], "aps.14.17": [25, true], "aps.14.18": [25, true], "aps.14.19": [25, true], "aps.14.20": [25, true], "aps.14.21": [25, true], "aps.14.22": [25, true], "aps.14.23": [25, true], "aps.14.24": [25, true], "aps.14.25": [25, true], "aps.14.26": [25, true], "aps.14.27": [25, true], "aps.14.28": [25, true], "aps.14.29": [25, true], "aps.14.30": [25, true], "aps.14.31": [25, true], "aps.14.32": [25, true], "aps.14.33": [25, true], "aps.14.34": [25, true], "aps.14.35": [25, true], "aps.14.36": [25, true], "aps.14.37": [25, true], "aps.14.38": [25, true], "aps.14.39": [25, true], "aps.15.00": [40, true], "aps.15.01": [32, true], "aps.15.02": [34, true], "aps.15.03": [35, true], "aps.15.04": [37, true], "aps.15.05": [37, true], "aps.15.06": [36, true], "aps.15.07": [37, true], "aps.15.08": [36, true], "aps.15.09": [35, true], "aps.15.10": [33, true], "aps.15.11": [36, true], "aps.15.12": [36, true], "aps.15.13": [38, true], "aps.15.14": [38, true], "aps.15.15": [39, true], "aps.15.16": [40, true], "aps.15.17": [41, true], "aps.15.18": [42, true], "aps.15.19": [43, true], "aps.15.20": [44, true], "aps.15.21": [38, true], "aps.15.22": [47, true], "aps.15.23": [44, true], "aps.15.24": [40, true], "aps.15.25": [43, true], "aps.15.26": [47, true], "aps.15.27": [53, true], "aps.15.28": [39, true], "aps.15.29": [41, true], "aps.15.30": [44, true]}}, "CHA": {"total": 7988, "solved": 8, "n": 45, "over": 2, "per": {"fun1.1": [76, true], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [92, true], "fun2.1": [89, true], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [58, true], "fun2.5": [61, true], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [11, false], "fun7.5": [13, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [21, true], "fun9.2": [156, true], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [35, true]}}}, {"label": "pure.rational.bracket.project", "spec": ["pure", "rational", "bracket", "project"], "APS": {"total": 7685, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [36, true], "aps.02.00": [84, true], "aps.02.01": [17, true], "aps.02.02": [86, true], "aps.02.03": [86, true], "aps.02.04": [69, true], "aps.02.05": [62, true], "aps.02.06": [59, true], "aps.02.07": [58, true], "aps.02.08": [57, true], "aps.02.09": [56, true], "aps.03.00": [94, true], "aps.03.01": [86, true], "aps.03.02": [90, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [89, true], "aps.04.03": [88, true], "aps.04.04": [89, true], "aps.04.05": [88, true], "aps.04.06": [88, true], "aps.04.07": [88, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [19, true], "aps.06.00": [21, true], "aps.06.01": [68, true], "aps.06.02": [34, true], "aps.06.03": [34, true], "aps.06.04": [35, true], "aps.06.05": [38, true], "aps.06.06": [73, true], "aps.06.07": [73, true], "aps.06.08": [73, true], "aps.06.09": [72, true], "aps.07.00": [53, true], "aps.07.01": [17, true], "aps.07.02": [16, true], "aps.08.00": [3, true], "aps.08.01": [81, true], "aps.08.02": [82, true], "aps.08.03": [82, true], "aps.08.04": [56, true], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [17, true], "aps.09.03": [16, true], "aps.09.04": [18, true], "aps.09.05": [20, true], "aps.09.06": [21, true], "aps.10.00": [24, true], "aps.10.01": [80, true], "aps.10.02": [81, true], "aps.10.03": [79, true], "aps.10.04": [81, true], "aps.11.00": [82, true], "aps.11.01": [72, true], "aps.11.02": [82, true], "aps.11.03": [79, true], "aps.12.00": [23, true], "aps.12.01": [32, true], "aps.12.02": [39, true], "aps.12.03": [45, true], "aps.12.04": [50, true], "aps.12.05": [95, true], "aps.12.06": [96, true], "aps.12.07": [88, true], "aps.12.08": [86, true], "aps.12.09": [86, true], "aps.12.10": [83, true], "aps.12.11": [76, true], "aps.12.12": [77, true], "aps.12.13": [77, true], "aps.12.14": [77, true], "aps.12.15": [76, true], "aps.12.16": [76, true], "aps.12.17": [78, true], "aps.12.18": [75, true], "aps.13.00": [51, false], "aps.14.00": [25, true], "aps.14.01": [25, true], "aps.14.02": [25, true], "aps.14.03": [25, true], "aps.14.04": [25, true], "aps.14.05": [25, true], "aps.14.06": [25, true], "aps.14.07": [25, true], "aps.14.08": [25, true], "aps.14.09": [25, true], "aps.14.10": [25, true], "aps.14.11": [25, true], "aps.14.12": [25, true], "aps.14.13": [25, true], "aps.14.14": [25, true], "aps.14.15": [25, true], "aps.14.16": [25, true], "aps.14.17": [25, true], "aps.14.18": [25, true], "aps.14.19": [25, true], "aps.14.20": [25, true], "aps.14.21": [25, true], "aps.14.22": [25, true], "aps.14.23": [25, true], "aps.14.24": [25, true], "aps.14.25": [25, true], "aps.14.26": [25, true], "aps.14.27": [25, true], "aps.14.28": [25, true], "aps.14.29": [25, true], "aps.14.30": [25, true], "aps.14.31": [25, true], "aps.14.32": [25, true], "aps.14.33": [25, true], "aps.14.34": [25, true], "aps.14.35": [25, true], "aps.14.36": [25, true], "aps.14.37": [25, true], "aps.14.38": [25, true], "aps.14.39": [25, true], "aps.15.00": [40, true], "aps.15.01": [32, true], "aps.15.02": [34, true], "aps.15.03": [35, true], "aps.15.04": [37, true], "aps.15.05": [37, true], "aps.15.06": [36, true], "aps.15.07": [37, true], "aps.15.08": [36, true], "aps.15.09": [35, true], "aps.15.10": [33, true], "aps.15.11": [36, true], "aps.15.12": [36, true], "aps.15.13": [38, true], "aps.15.14": [38, true], "aps.15.15": [39, true], "aps.15.16": [40, true], "aps.15.17": [41, true], "aps.15.18": [42, true], "aps.15.19": [43, true], "aps.15.20": [44, true], "aps.15.21": [38, true], "aps.15.22": [47, true], "aps.15.23": [44, true], "aps.15.24": [40, true], "aps.15.25": [43, true], "aps.15.26": [47, true], "aps.15.27": [53, true], "aps.15.28": [39, true], "aps.15.29": [41, true], "aps.15.30": [44, true]}}, "CHA": {"total": 4676, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [76, true], "fun1.2": [90, true], "fun1.3": [92, true], "fun1.4": [109, true], "fun1.5": [92, true], "fun2.1": [70, true], "fun2.2": [102, true], "fun2.3": [122, true], "fun2.4": [58, true], "fun2.5": [61, true], "fun3.1": [89, true], "fun3.2": [92, true], "fun3.3": [113, true], "fun3.4": [124, true], "fun3.5": [152, true], "fun4.1": [88, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [51, false], "fun7.2": [50, false], "fun7.3": [49, false], "fun7.4": [11, false], "fun7.5": [13, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [21, true], "fun9.2": [62, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [35, true]}}}, {"label": "pure.rational.bracket.credit", "spec": ["pure", "rational", "bracket", "credit"], "APS": {"total": 5878, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [16, true], "aps.02.00": [45, true], "aps.02.01": [45, true], "aps.02.02": [46, true], "aps.02.03": [44, true], "aps.02.04": [45, true], "aps.02.05": [46, true], "aps.02.06": [14, true], "aps.02.07": [45, true], "aps.02.08": [47, true], "aps.02.09": [46, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [43, true], "aps.04.01": [44, true], "aps.04.02": [45, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [25, true], "aps.06.00": [42, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [23, true], "aps.06.04": [38, true], "aps.06.05": [40, true], "aps.06.06": [40, true], "aps.06.07": [43, true], "aps.06.08": [40, true], "aps.06.09": [43, true], "aps.07.00": [16, true], "aps.07.01": [18, true], "aps.07.02": [22, true], "aps.08.00": [3, true], "aps.08.01": [14, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [26, true], "aps.09.01": [27, true], "aps.09.02": [43, true], "aps.09.03": [27, true], "aps.09.04": [36, true], "aps.09.05": [42, true], "aps.09.06": [36, true], "aps.10.00": [20, true], "aps.10.01": [42, true], "aps.10.02": [43, true], "aps.10.03": [42, true], "aps.10.04": [41, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [24, true], "aps.12.01": [47, true], "aps.12.02": [33, true], "aps.12.03": [22, true], "aps.12.04": [23, true], "aps.12.05": [50, true], "aps.12.06": [24, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [22, true], "aps.14.01": [22, true], "aps.14.02": [22, true], "aps.14.03": [22, true], "aps.14.04": [22, true], "aps.14.05": [22, true], "aps.14.06": [22, true], "aps.14.07": [22, true], "aps.14.08": [22, true], "aps.14.09": [22, true], "aps.14.10": [22, true], "aps.14.11": [22, true], "aps.14.12": [22, true], "aps.14.13": [22, true], "aps.14.14": [22, true], "aps.14.15": [22, true], "aps.14.16": [22, true], "aps.14.17": [22, true], "aps.14.18": [22, true], "aps.14.19": [22, true], "aps.14.20": [22, true], "aps.14.21": [22, true], "aps.14.22": [22, true], "aps.14.23": [22, true], "aps.14.24": [22, true], "aps.14.25": [22, true], "aps.14.26": [22, true], "aps.14.27": [22, true], "aps.14.28": [22, true], "aps.14.29": [22, true], "aps.14.30": [22, true], "aps.14.31": [22, true], "aps.14.32": [22, true], "aps.14.33": [22, true], "aps.14.34": [22, true], "aps.14.35": [22, true], "aps.14.36": [22, true], "aps.14.37": [22, true], "aps.14.38": [22, true], "aps.14.39": [22, true], "aps.15.00": [46, true], "aps.15.01": [51, true], "aps.15.02": [52, true], "aps.15.03": [53, true], "aps.15.04": [51, true], "aps.15.05": [52, true], "aps.15.06": [52, true], "aps.15.07": [51, true], "aps.15.08": [53, true], "aps.15.09": [50, true], "aps.15.10": [33, true], "aps.15.11": [52, true], "aps.15.12": [52, true], "aps.15.13": [53, true], "aps.15.14": [45, true], "aps.15.15": [47, true], "aps.15.16": [52, true], "aps.15.17": [36, true], "aps.15.18": [39, true], "aps.15.19": [52, true], "aps.15.20": [50, true], "aps.15.21": [51, true], "aps.15.22": [51, true], "aps.15.23": [52, true], "aps.15.24": [49, true], "aps.15.25": [49, true], "aps.15.26": [53, true], "aps.15.27": [51, true], "aps.15.28": [53, true], "aps.15.29": [52, true], "aps.15.30": [49, true]}}, "CHA": {"total": 3040, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [38, true], "fun1.2": [44, true], "fun1.3": [48, true], "fun1.4": [58, true], "fun1.5": [73, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [64, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [46, false], "fun7.3": [7, false], "fun7.4": [11, false], "fun7.5": [13, false], "fun8.1": [36, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [11, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [34, true]}}}, {"label": "pure.ratio.derived.both", "spec": ["pure", "ratio", "derived", "both"], "APS": {"total": 4260, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [15, true], "aps.02.00": [28, true], "aps.02.01": [21, true], "aps.02.02": [20, true], "aps.02.03": [28, true], "aps.02.04": [26, true], "aps.02.05": [24, true], "aps.02.06": [25, true], "aps.02.07": [24, true], "aps.02.08": [34, true], "aps.02.09": [36, true], "aps.03.00": [24, true], "aps.03.01": [25, true], "aps.03.02": [32, true], "aps.04.00": [25, true], "aps.04.01": [30, true], "aps.04.02": [36, true], "aps.04.03": [24, true], "aps.04.04": [28, true], "aps.04.05": [21, true], "aps.04.06": [19, true], "aps.04.07": [26, true], "aps.04.08": [25, true], "aps.04.09": [26, true], "aps.04.10": [24, true], "aps.04.11": [21, true], "aps.04.12": [27, true], "aps.04.13": [27, true], "aps.05.00": [19, true], "aps.06.00": [16, true], "aps.06.01": [17, true], "aps.06.02": [18, true], "aps.06.03": [19, true], "aps.06.04": [17, true], "aps.06.05": [23, true], "aps.06.06": [20, true], "aps.06.07": [21, true], "aps.06.08": [21, true], "aps.06.09": [23, true], "aps.07.00": [23, true], "aps.07.01": [20, true], "aps.07.02": [19, true], "aps.08.00": [3, true], "aps.08.01": [19, true], "aps.08.02": [20, true], "aps.08.03": [19, true], "aps.08.04": [18, true], "aps.09.00": [16, true], "aps.09.01": [27, true], "aps.09.02": [12, true], "aps.09.03": [11, true], "aps.09.04": [10, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [20, true], "aps.10.01": [30, true], "aps.10.02": [17, true], "aps.10.03": [18, true], "aps.10.04": [36, true], "aps.11.00": [4, true], "aps.11.01": [23, true], "aps.11.02": [21, true], "aps.11.03": [27, true], "aps.12.00": [17, true], "aps.12.01": [19, true], "aps.12.02": [20, true], "aps.12.03": [21, true], "aps.12.04": [16, true], "aps.12.05": [20, true], "aps.12.06": [20, true], "aps.12.07": [19, true], "aps.12.08": [23, true], "aps.12.09": [17, true], "aps.12.10": [17, true], "aps.12.11": [15, true], "aps.12.12": [19, true], "aps.12.13": [19, true], "aps.12.14": [19, true], "aps.12.15": [18, true], "aps.12.16": [17, true], "aps.12.17": [20, true], "aps.12.18": [19, true], "aps.13.00": [7, false], "aps.14.00": [27, true], "aps.14.01": [27, true], "aps.14.02": [25, true], "aps.14.03": [27, true], "aps.14.04": [27, true], "aps.14.05": [25, true], "aps.14.06": [27, true], "aps.14.07": [27, true], "aps.14.08": [27, true], "aps.14.09": [27, true], "aps.14.10": [27, true], "aps.14.11": [25, true], "aps.14.12": [27, true], "aps.14.13": [27, true], "aps.14.14": [27, true], "aps.14.15": [27, true], "aps.14.16": [27, true], "aps.14.17": [27, true], "aps.14.18": [27, true], "aps.14.19": [27, true], "aps.14.20": [27, true], "aps.14.21": [27, true], "aps.14.22": [25, true], "aps.14.23": [25, true], "aps.14.24": [25, true], "aps.14.25": [27, true], "aps.14.26": [27, true], "aps.14.27": [27, true], "aps.14.28": [27, true], "aps.14.29": [27, true], "aps.14.30": [27, true], "aps.14.31": [27, true], "aps.14.32": [27, true], "aps.14.33": [27, true], "aps.14.34": [27, true], "aps.14.35": [27, true], "aps.14.36": [27, true], "aps.14.37": [27, true], "aps.14.38": [27, true], "aps.14.39": [27, true], "aps.15.00": [40, true], "aps.15.01": [42, true], "aps.15.02": [42, true], "aps.15.03": [42, true], "aps.15.04": [42, true], "aps.15.05": [44, true], "aps.15.06": [40, true], "aps.15.07": [42, true], "aps.15.08": [38, true], "aps.15.09": [39, true], "aps.15.10": [34, true], "aps.15.11": [35, true], "aps.15.12": [36, true], "aps.15.13": [36, true], "aps.15.14": [39, true], "aps.15.15": [41, true], "aps.15.16": [41, true], "aps.15.17": [42, true], "aps.15.18": [42, true], "aps.15.19": [44, true], "aps.15.20": [42, true], "aps.15.21": [45, true], "aps.15.22": [41, true], "aps.15.23": [47, true], "aps.15.24": [34, true], "aps.15.25": [38, true], "aps.15.26": [44, true], "aps.15.27": [45, true], "aps.15.28": [49, true], "aps.15.29": [47, true], "aps.15.30": [42, true]}}, "CHA": {"total": 3199, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [16, true], "fun1.2": [29, true], "fun1.3": [30, true], "fun1.4": [42, true], "fun1.5": [69, true], "fun2.1": [20, true], "fun2.2": [36, true], "fun2.3": [35, true], "fun2.4": [56, true], "fun2.5": [59, true], "fun3.1": [66, true], "fun3.2": [72, true], "fun3.3": [89, true], "fun3.4": [99, true], "fun3.5": [122, true], "fun4.1": [68, true], "fun4.2": [69, true], "fun4.3": [90, true], "fun4.4": [101, true], "fun4.5": [125, true], "fun5.1": [68, true], "fun5.2": [73, true], "fun5.3": [73, true], "fun5.4": [74, true], "fun5.5": [75, true], "fun6.1": [61, true], "fun6.2": [62, true], "fun6.3": [61, true], "fun6.4": [65, true], "fun6.5": [66, true], "fun7.1": [7, false], "fun7.2": [11, false], "fun7.3": [8, false], "fun7.4": [7, false], "fun7.5": [7, false], "fun8.1": [21, true], "fun8.2": [20, true], "fun8.3": [22, true], "fun8.4": [23, true], "fun8.5": [29, true], "fun9.1": [16, true], "fun9.2": [24, true], "fun9.3": [22, true], "fun9.4": [20, true], "fun9.5": [31, true]}}}, {"label": "pure.rational.derived.none", "spec": ["pure", "rational", "derived", "none"], "APS": {"total": 3596, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [14, true], "aps.02.01": [12, true], "aps.02.02": [44, true], "aps.02.03": [17, true], "aps.02.04": [14, true], "aps.02.05": [12, true], "aps.02.06": [44, true], "aps.02.07": [12, true], "aps.02.08": [12, true], "aps.02.09": [22, true], "aps.03.00": [22, true], "aps.03.01": [59, true], "aps.03.02": [60, true], "aps.04.00": [21, true], "aps.04.01": [17, true], "aps.04.02": [55, true], "aps.04.03": [18, true], "aps.04.04": [19, true], "aps.04.05": [18, true], "aps.04.06": [14, true], "aps.04.07": [15, true], "aps.04.08": [16, true], "aps.04.09": [17, true], "aps.04.10": [17, true], "aps.04.11": [19, true], "aps.04.12": [26, true], "aps.04.13": [30, true], "aps.05.00": [10, true], "aps.06.00": [9, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [14, true], "aps.06.06": [15, true], "aps.06.07": [16, true], "aps.06.08": [16, true], "aps.06.09": [17, true], "aps.07.00": [11, true], "aps.07.01": [14, true], "aps.07.02": [16, true], "aps.08.00": [8, true], "aps.08.01": [49, true], "aps.08.02": [11, true], "aps.08.03": [11, true], "aps.08.04": [12, true], "aps.09.00": [36, true], "aps.09.01": [44, true], "aps.09.02": [14, true], "aps.09.03": [15, true], "aps.09.04": [18, true], "aps.09.05": [22, true], "aps.09.06": [24, true], "aps.10.00": [9, true], "aps.10.01": [43, true], "aps.10.02": [45, true], "aps.10.03": [15, true], "aps.10.04": [49, true], "aps.11.00": [11, true], "aps.11.01": [14, true], "aps.11.02": [14, true], "aps.11.03": [15, true], "aps.12.00": [11, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [11, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [200, false], "aps.14.00": [20, true], "aps.14.01": [20, true], "aps.14.02": [20, true], "aps.14.03": [20, true], "aps.14.04": [20, true], "aps.14.05": [20, true], "aps.14.06": [20, true], "aps.14.07": [20, true], "aps.14.08": [20, true], "aps.14.09": [20, true], "aps.14.10": [20, true], "aps.14.11": [20, true], "aps.14.12": [20, true], "aps.14.13": [20, true], "aps.14.14": [20, true], "aps.14.15": [20, true], "aps.14.16": [20, true], "aps.14.17": [20, true], "aps.14.18": [20, true], "aps.14.19": [20, true], "aps.14.20": [20, true], "aps.14.21": [20, true], "aps.14.22": [20, true], "aps.14.23": [20, true], "aps.14.24": [20, true], "aps.14.25": [20, true], "aps.14.26": [20, true], "aps.14.27": [20, true], "aps.14.28": [20, true], "aps.14.29": [20, true], "aps.14.30": [20, true], "aps.14.31": [20, true], "aps.14.32": [20, true], "aps.14.33": [20, true], "aps.14.34": [20, true], "aps.14.35": [20, true], "aps.14.36": [20, true], "aps.14.37": [20, true], "aps.14.38": [20, true], "aps.14.39": [20, true], "aps.15.00": [33, true], "aps.15.01": [33, true], "aps.15.02": [34, true], "aps.15.03": [35, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [34, true], "aps.15.08": [34, true], "aps.15.09": [34, true], "aps.15.10": [34, true], "aps.15.11": [35, true], "aps.15.12": [34, true], "aps.15.13": [34, true], "aps.15.14": [35, true], "aps.15.15": [35, true], "aps.15.16": [35, true], "aps.15.17": [35, true], "aps.15.18": [35, true], "aps.15.19": [35, true], "aps.15.20": [35, true], "aps.15.21": [35, true], "aps.15.22": [36, true], "aps.15.23": [37, true], "aps.15.24": [37, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [36, true], "aps.15.28": [36, true], "aps.15.29": [35, true], "aps.15.30": [36, true]}}, "CHA": {"total": 5689, "solved": 20, "n": 45, "over": 0, "per": {"fun1.1": [37, true], "fun1.2": [18, true], "fun1.3": [19, true], "fun1.4": [40, true], "fun1.5": [94, true], "fun2.1": [11, true], "fun2.2": [47, true], "fun2.3": [58, true], "fun2.4": [78, true], "fun2.5": [85, true], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [200, false], "fun8.1": [11, true], "fun8.2": [13, true], "fun8.3": [13, true], "fun8.4": [14, true], "fun8.5": [14, true], "fun9.1": [8, true], "fun9.2": [11, true], "fun9.3": [27, true], "fun9.4": [47, true], "fun9.5": [44, true]}}}, {"label": "pure.rational.start.step", "spec": ["pure", "rational", "start", "step"], "APS": {"total": 11565, "solved": 153, "n": 154, "over": 24, "per": {"aps.01.00": [168, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [88, true], "aps.03.01": [60, true], "aps.03.02": [48, true], "aps.04.00": [80, true], "aps.04.01": [24, true], "aps.04.02": [63, true], "aps.04.03": [19, true], "aps.04.04": [107, true], "aps.04.05": [70, true], "aps.04.06": [73, true], "aps.04.07": [81, true], "aps.04.08": [166, true], "aps.04.09": [55, true], "aps.04.10": [37, true], "aps.04.11": [77, true], "aps.04.12": [53, true], "aps.04.13": [149, true], "aps.05.00": [18, true], "aps.06.00": [21, true], "aps.06.01": [113, true], "aps.06.02": [34, true], "aps.06.03": [34, true], "aps.06.04": [35, true], "aps.06.05": [38, true], "aps.06.06": [118, true], "aps.06.07": [120, true], "aps.06.08": [118, true], "aps.06.09": [120, true], "aps.07.00": [99, true], "aps.07.01": [13, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [131, true], "aps.08.02": [180, true], "aps.08.03": [81, true], "aps.08.04": [79, true], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [94, true], "aps.09.03": [10, true], "aps.09.04": [8, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [24, true], "aps.10.01": [180, true], "aps.10.02": [76, true], "aps.10.03": [70, true], "aps.10.04": [76, true], "aps.11.00": [70, true], "aps.11.01": [75, true], "aps.11.02": [22, true], "aps.11.03": [27, true], "aps.12.00": [23, true], "aps.12.01": [33, true], "aps.12.02": [39, true], "aps.12.03": [46, true], "aps.12.04": [50, true], "aps.12.05": [55, true], "aps.12.06": [152, true], "aps.12.07": [68, true], "aps.12.08": [68, true], "aps.12.09": [59, true], "aps.12.10": [144, true], "aps.12.11": [46, true], "aps.12.12": [42, true], "aps.12.13": [38, true], "aps.12.14": [34, true], "aps.12.15": [30, true], "aps.12.16": [26, true], "aps.12.17": [24, true], "aps.12.18": [21, true], "aps.13.00": [10, false], "aps.14.00": [82, true], "aps.14.01": [82, true], "aps.14.02": [82, true], "aps.14.03": [82, true], "aps.14.04": [82, true], "aps.14.05": [82, true], "aps.14.06": [82, true], "aps.14.07": [82, true], "aps.14.08": [82, true], "aps.14.09": [82, true], "aps.14.10": [82, true], "aps.14.11": [82, true], "aps.14.12": [82, true], "aps.14.13": [82, true], "aps.14.14": [82, true], "aps.14.15": [82, true], "aps.14.16": [82, true], "aps.14.17": [82, true], "aps.14.18": [82, true], "aps.14.19": [82, true], "aps.14.20": [82, true], "aps.14.21": [82, true], "aps.14.22": [82, true], "aps.14.23": [82, true], "aps.14.24": [82, true], "aps.14.25": [82, true], "aps.14.26": [82, true], "aps.14.27": [82, true], "aps.14.28": [82, true], "aps.14.29": [82, true], "aps.14.30": [82, true], "aps.14.31": [82, true], "aps.14.32": [82, true], "aps.14.33": [82, true], "aps.14.34": [82, true], "aps.14.35": [82, true], "aps.14.36": [82, true], "aps.14.37": [82, true], "aps.14.38": [82, true], "aps.14.39": [82, true], "aps.15.00": [41, true], "aps.15.01": [76, true], "aps.15.02": [168, true], "aps.15.03": [108, true], "aps.15.04": [89, true], "aps.15.05": [84, true], "aps.15.06": [84, true], "aps.15.07": [80, true], "aps.15.08": [87, true], "aps.15.09": [78, true], "aps.15.10": [77, true], "aps.15.11": [83, true], "aps.15.12": [80, true], "aps.15.13": [86, true], "aps.15.14": [84, true], "aps.15.15": [92, true], "aps.15.16": [89, true], "aps.15.17": [179, true], "aps.15.18": [166, true], "aps.15.19": [156, true], "aps.15.20": [150, true], "aps.15.21": [85, true], "aps.15.22": [42, true], "aps.15.23": [168, true], "aps.15.24": [75, true], "aps.15.25": [162, true], "aps.15.26": [61, true], "aps.15.27": [70, true], "aps.15.28": [80, true], "aps.15.29": [78, true], "aps.15.30": [72, true]}}, "CHA": {"total": 3901, "solved": 40, "n": 45, "over": 2, "per": {"fun1.1": [75, true], "fun1.2": [156, true], "fun1.3": [79, true], "fun1.4": [91, true], "fun1.5": [109, true], "fun2.1": [71, true], "fun2.2": [43, true], "fun2.3": [106, true], "fun2.4": [71, true], "fun2.5": [117, true], "fun3.1": [66, true], "fun3.2": [66, true], "fun3.3": [84, true], "fun3.4": [94, true], "fun3.5": [109, true], "fun4.1": [55, true], "fun4.2": [58, true], "fun4.3": [76, true], "fun4.4": [82, true], "fun4.5": [96, true], "fun5.1": [56, true], "fun5.2": [55, true], "fun5.3": [55, true], "fun5.4": [57, true], "fun5.5": [58, true], "fun6.1": [48, true], "fun6.2": [48, true], "fun6.3": [52, true], "fun6.4": [54, true], "fun6.5": [55, true], "fun7.1": [10, false], "fun7.2": [12, false], "fun7.3": [15, false], "fun7.4": [16, false], "fun7.5": [19, false], "fun8.1": [76, true], "fun8.2": [21, true], "fun8.3": [76, true], "fun8.4": [81, true], "fun8.5": [84, true], "fun9.1": [22, true], "fun9.2": [47, true], "fun9.3": [20, true], "fun9.4": [146, true], "fun9.5": [86, true]}}}, {"label": "pure.rational.bracket.safe", "spec": ["pure", "rational", "bracket", "safe"], "APS": {"total": 6449, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [36, true], "aps.02.00": [57, true], "aps.02.01": [17, true], "aps.02.02": [18, true], "aps.02.03": [51, true], "aps.02.04": [53, true], "aps.02.05": [61, true], "aps.02.06": [59, true], "aps.02.07": [58, true], "aps.02.08": [57, true], "aps.02.09": [56, true], "aps.03.00": [72, true], "aps.03.01": [49, true], "aps.03.02": [31, true], "aps.04.00": [59, true], "aps.04.01": [30, true], "aps.04.02": [80, true], "aps.04.03": [51, true], "aps.04.04": [83, true], "aps.04.05": [39, true], "aps.04.06": [88, true], "aps.04.07": [27, true], "aps.04.08": [16, true], "aps.04.09": [25, true], "aps.04.10": [25, true], "aps.04.11": [29, true], "aps.04.12": [27, true], "aps.04.13": [26, true], "aps.05.00": [19, true], "aps.06.00": [21, true], "aps.06.01": [68, true], "aps.06.02": [34, true], "aps.06.03": [34, true], "aps.06.04": [35, true], "aps.06.05": [73, true], "aps.06.06": [73, true], "aps.06.07": [73, true], "aps.06.08": [73, true], "aps.06.09": [72, true], "aps.07.00": [53, true], "aps.07.01": [17, true], "aps.07.02": [16, true], "aps.08.00": [3, true], "aps.08.01": [81, true], "aps.08.02": [82, true], "aps.08.03": [72, true], "aps.08.04": [65, true], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [17, true], "aps.09.03": [16, true], "aps.09.04": [18, true], "aps.09.05": [20, true], "aps.09.06": [21, true], "aps.10.00": [24, true], "aps.10.01": [80, true], "aps.10.02": [22, true], "aps.10.03": [55, true], "aps.10.04": [55, true], "aps.11.00": [18, true], "aps.11.01": [22, true], "aps.11.02": [25, true], "aps.11.03": [26, true], "aps.12.00": [23, true], "aps.12.01": [32, true], "aps.12.02": [39, true], "aps.12.03": [45, true], "aps.12.04": [50, true], "aps.12.05": [95, true], "aps.12.06": [96, true], "aps.12.07": [88, true], "aps.12.08": [86, true], "aps.12.09": [86, true], "aps.12.10": [83, true], "aps.12.11": [76, true], "aps.12.12": [77, true], "aps.12.13": [77, true], "aps.12.14": [77, true], "aps.12.15": [76, true], "aps.12.16": [76, true], "aps.12.17": [78, true], "aps.12.18": [32, true], "aps.13.00": [11, false], "aps.14.00": [25, true], "aps.14.01": [25, true], "aps.14.02": [25, true], "aps.14.03": [25, true], "aps.14.04": [25, true], "aps.14.05": [25, true], "aps.14.06": [25, true], "aps.14.07": [25, true], "aps.14.08": [25, true], "aps.14.09": [25, true], "aps.14.10": [25, true], "aps.14.11": [25, true], "aps.14.12": [25, true], "aps.14.13": [25, true], "aps.14.14": [25, true], "aps.14.15": [25, true], "aps.14.16": [25, true], "aps.14.17": [25, true], "aps.14.18": [25, true], "aps.14.19": [25, true], "aps.14.20": [25, true], "aps.14.21": [25, true], "aps.14.22": [25, true], "aps.14.23": [25, true], "aps.14.24": [25, true], "aps.14.25": [25, true], "aps.14.26": [25, true], "aps.14.27": [25, true], "aps.14.28": [25, true], "aps.14.29": [25, true], "aps.14.30": [25, true], "aps.14.31": [25, true], "aps.14.32": [25, true], "aps.14.33": [25, true], "aps.14.34": [25, true], "aps.14.35": [25, true], "aps.14.36": [25, true], "aps.14.37": [25, true], "aps.14.38": [25, true], "aps.14.39": [25, true], "aps.15.00": [40, true], "aps.15.01": [32, true], "aps.15.02": [34, true], "aps.15.03": [35, true], "aps.15.04": [37, true], "aps.15.05": [37, true], "aps.15.06": [36, true], "aps.15.07": [37, true], "aps.15.08": [36, true], "aps.15.09": [35, true], "aps.15.10": [33, true], "aps.15.11": [36, true], "aps.15.12": [36, true], "aps.15.13": [38, true], "aps.15.14": [38, true], "aps.15.15": [39, true], "aps.15.16": [40, true], "aps.15.17": [41, true], "aps.15.18": [42, true], "aps.15.19": [43, true], "aps.15.20": [44, true], "aps.15.21": [38, true], "aps.15.22": [47, true], "aps.15.23": [44, true], "aps.15.24": [40, true], "aps.15.25": [43, true], "aps.15.26": [47, true], "aps.15.27": [53, true], "aps.15.28": [39, true], "aps.15.29": [41, true], "aps.15.30": [44, true]}}, "CHA": {"total": 3835, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [76, true], "fun1.2": [58, true], "fun1.3": [73, true], "fun1.4": [78, true], "fun1.5": [92, true], "fun2.1": [70, true], "fun2.2": [63, true], "fun2.3": [79, true], "fun2.4": [58, true], "fun2.5": [62, true], "fun3.1": [88, true], "fun3.2": [91, true], "fun3.3": [112, true], "fun3.4": [115, true], "fun3.5": [132, true], "fun4.1": [86, true], "fun4.2": [91, true], "fun4.3": [92, true], "fun4.4": [115, true], "fun4.5": [118, true], "fun5.1": [84, true], "fun5.2": [88, true], "fun5.3": [70, true], "fun5.4": [72, true], "fun5.5": [73, true], "fun6.1": [80, true], "fun6.2": [82, true], "fun6.3": [64, true], "fun6.4": [66, true], "fun6.5": [67, true], "fun7.1": [11, false], "fun7.2": [12, false], "fun7.3": [12, false], "fun7.4": [11, false], "fun7.5": [13, false], "fun8.1": [20, true], "fun8.2": [41, true], "fun8.3": [29, true], "fun8.4": [42, true], "fun8.5": [40, true], "fun9.1": [21, true], "fun9.2": [24, true], "fun9.3": [26, true], "fun9.4": [23, true], "fun9.5": [74, true]}}}, {"label": "pure.rational.derived.bracket", "spec": ["pure", "rational", "derived", "bracket"], "APS": {"total": 8398, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [52, true], "aps.02.00": [51, true], "aps.02.01": [53, true], "aps.02.02": [53, true], "aps.02.03": [56, true], "aps.02.04": [57, true], "aps.02.05": [55, true], "aps.02.06": [56, true], "aps.02.07": [56, true], "aps.02.08": [57, true], "aps.02.09": [55, true], "aps.03.00": [53, true], "aps.03.01": [51, true], "aps.03.02": [56, true], "aps.04.00": [54, true], "aps.04.01": [55, true], "aps.04.02": [54, true], "aps.04.03": [53, true], "aps.04.04": [55, true], "aps.04.05": [50, true], "aps.04.06": [49, true], "aps.04.07": [52, true], "aps.04.08": [54, true], "aps.04.09": [54, true], "aps.04.10": [53, true], "aps.04.11": [54, true], "aps.04.12": [57, true], "aps.04.13": [51, true], "aps.05.00": [48, true], "aps.06.00": [51, true], "aps.06.01": [51, true], "aps.06.02": [50, true], "aps.06.03": [48, true], "aps.06.04": [48, true], "aps.06.05": [46, true], "aps.06.06": [49, true], "aps.06.07": [47, true], "aps.06.08": [50, true], "aps.06.09": [51, true], "aps.07.00": [50, true], "aps.07.01": [50, true], "aps.07.02": [48, true], "aps.08.00": [53, true], "aps.08.01": [50, true], "aps.08.02": [51, true], "aps.08.03": [47, true], "aps.08.04": [48, true], "aps.09.00": [51, true], "aps.09.01": [48, true], "aps.09.02": [49, true], "aps.09.03": [48, true], "aps.09.04": [47, true], "aps.09.05": [47, true], "aps.09.06": [47, true], "aps.10.00": [50, true], "aps.10.01": [50, true], "aps.10.02": [50, true], "aps.10.03": [45, true], "aps.10.04": [51, true], "aps.11.00": [38, true], "aps.11.01": [49, true], "aps.11.02": [48, true], "aps.11.03": [49, true], "aps.12.00": [53, true], "aps.12.01": [53, true], "aps.12.02": [57, true], "aps.12.03": [56, true], "aps.12.04": [46, true], "aps.12.05": [49, true], "aps.12.06": [54, true], "aps.12.07": [56, true], "aps.12.08": [55, true], "aps.12.09": [56, true], "aps.12.10": [55, true], "aps.12.11": [58, true], "aps.12.12": [51, true], "aps.12.13": [52, true], "aps.12.14": [53, true], "aps.12.15": [53, true], "aps.12.16": [54, true], "aps.12.17": [56, true], "aps.12.18": [57, true], "aps.13.00": [6, false], "aps.14.00": [55, true], "aps.14.01": [55, true], "aps.14.02": [55, true], "aps.14.03": [55, true], "aps.14.04": [55, true], "aps.14.05": [55, true], "aps.14.06": [55, true], "aps.14.07": [55, true], "aps.14.08": [55, true], "aps.14.09": [55, true], "aps.14.10": [55, true], "aps.14.11": [55, true], "aps.14.12": [55, true], "aps.14.13": [55, true], "aps.14.14": [55, true], "aps.14.15": [55, true], "aps.14.16": [55, true], "aps.14.17": [55, true], "aps.14.18": [55, true], "aps.14.19": [55, true], "aps.14.20": [55, true], "aps.14.21": [55, true], "aps.14.22": [55, true], "aps.14.23": [55, true], "aps.14.24": [55, true], "aps.14.25": [55, true], "aps.14.26": [55, true], "aps.14.27": [55, true], "aps.14.28": [55, true], "aps.14.29": [55, true], "aps.14.30": [55, true], "aps.14.31": [55, true], "aps.14.32": [55, true], "aps.14.33": [55, true], "aps.14.34": [55, true], "aps.14.35": [55, true], "aps.14.36": [55, true], "aps.14.37": [55, true], "aps.14.38": [55, true], "aps.14.39": [55, true], "aps.15.00": [58, true], "aps.15.01": [59, true], "aps.15.02": [59, true], "aps.15.03": [58, true], "aps.15.04": [58, true], "aps.15.05": [57, true], "aps.15.06": [58, true], "aps.15.07": [57, true], "aps.15.08": [58, true], "aps.15.09": [59, true], "aps.15.10": [58, true], "aps.15.11": [58, true], "aps.15.12": [59, true], "aps.15.13": [58, true], "aps.15.14": [58, true], "aps.15.15": [59, true], "aps.15.16": [58, true], "aps.15.17": [57, true], "aps.15.18": [59, true], "aps.15.19": [58, true], "aps.15.20": [58, true], "aps.15.21": [55, true], "aps.15.22": [58, true], "aps.15.23": [57, true], "aps.15.24": [57, true], "aps.15.25": [48, true], "aps.15.26": [51, true], "aps.15.27": [52, true], "aps.15.28": [55, true], "aps.15.29": [56, true], "aps.15.30": [55, true]}}, "CHA": {"total": 3766, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [50, true], "fun1.2": [54, true], "fun1.3": [61, true], "fun1.4": [68, true], "fun1.5": [94, true], "fun2.1": [50, true], "fun2.2": [76, true], "fun2.3": [89, true], "fun2.4": [110, true], "fun2.5": [116, true], "fun3.1": [56, true], "fun3.2": [59, true], "fun3.3": [71, true], "fun3.4": [79, true], "fun3.5": [96, true], "fun4.1": [82, true], "fun4.2": [86, true], "fun4.3": [96, true], "fun4.4": [102, true], "fun4.5": [114, true], "fun5.1": [64, true], "fun5.2": [68, true], "fun5.3": [68, true], "fun5.4": [74, true], "fun5.5": [75, true], "fun6.1": [43, true], "fun6.2": [55, true], "fun6.3": [57, true], "fun6.4": [58, true], "fun6.5": [58, true], "fun7.1": [6, false], "fun7.2": [9, false], "fun7.3": [8, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [50, true], "fun8.2": [55, true], "fun8.3": [49, true], "fun8.4": [52, true], "fun8.5": [52, true], "fun9.1": [49, true], "fun9.2": [53, true], "fun9.3": [57, true], "fun9.4": [58, true], "fun9.5": [62, true]}}}, {"label": "pure.rational.start.safe", "spec": ["pure", "rational", "start", "safe"], "APS": {"total": 10556, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [88, true], "aps.03.01": [60, true], "aps.03.02": [48, true], "aps.04.00": [80, true], "aps.04.01": [24, true], "aps.04.02": [63, true], "aps.04.03": [19, true], "aps.04.04": [88, true], "aps.04.05": [70, true], "aps.04.06": [73, true], "aps.04.07": [81, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [37, true], "aps.04.11": [77, true], "aps.04.12": [53, true], "aps.04.13": [88, true], "aps.05.00": [18, true], "aps.06.00": [21, true], "aps.06.01": [83, true], "aps.06.02": [34, true], "aps.06.03": [34, true], "aps.06.04": [35, true], "aps.06.05": [82, true], "aps.06.06": [82, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [13, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [83, true], "aps.08.02": [83, true], "aps.08.03": [81, true], "aps.08.04": [79, true], "aps.09.00": [34, true], "aps.09.01": [35, true], "aps.09.02": [83, true], "aps.09.03": [10, true], "aps.09.04": [8, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [24, true], "aps.10.01": [82, true], "aps.10.02": [76, true], "aps.10.03": [70, true], "aps.10.04": [76, true], "aps.11.00": [70, true], "aps.11.01": [75, true], "aps.11.02": [22, true], "aps.11.03": [27, true], "aps.12.00": [23, true], "aps.12.01": [33, true], "aps.12.02": [39, true], "aps.12.03": [46, true], "aps.12.04": [50, true], "aps.12.05": [97, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [96, true], "aps.12.11": [46, true], "aps.12.12": [42, true], "aps.12.13": [38, true], "aps.12.14": [34, true], "aps.12.15": [30, true], "aps.12.16": [26, true], "aps.12.17": [24, true], "aps.12.18": [21, true], "aps.13.00": [10, false], "aps.14.00": [82, true], "aps.14.01": [82, true], "aps.14.02": [82, true], "aps.14.03": [82, true], "aps.14.04": [82, true], "aps.14.05": [82, true], "aps.14.06": [82, true], "aps.14.07": [82, true], "aps.14.08": [82, true], "aps.14.09": [82, true], "aps.14.10": [82, true], "aps.14.11": [82, true], "aps.14.12": [82, true], "aps.14.13": [82, true], "aps.14.14": [82, true], "aps.14.15": [82, true], "aps.14.16": [82, true], "aps.14.17": [82, true], "aps.14.18": [82, true], "aps.14.19": [82, true], "aps.14.20": [82, true], "aps.14.21": [82, true], "aps.14.22": [82, true], "aps.14.23": [82, true], "aps.14.24": [82, true], "aps.14.25": [82, true], "aps.14.26": [82, true], "aps.14.27": [82, true], "aps.14.28": [82, true], "aps.14.29": [82, true], "aps.14.30": [82, true], "aps.14.31": [82, true], "aps.14.32": [82, true], "aps.14.33": [82, true], "aps.14.34": [82, true], "aps.14.35": [82, true], "aps.14.36": [82, true], "aps.14.37": [82, true], "aps.14.38": [82, true], "aps.14.39": [82, true], "aps.15.00": [41, true], "aps.15.01": [76, true], "aps.15.02": [103, true], "aps.15.03": [103, true], "aps.15.04": [89, true], "aps.15.05": [84, true], "aps.15.06": [84, true], "aps.15.07": [80, true], "aps.15.08": [87, true], "aps.15.09": [78, true], "aps.15.10": [77, true], "aps.15.11": [83, true], "aps.15.12": [80, true], "aps.15.13": [86, true], "aps.15.14": [84, true], "aps.15.15": [92, true], "aps.15.16": [89, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [103, true], "aps.15.20": [102, true], "aps.15.21": [85, true], "aps.15.22": [42, true], "aps.15.23": [103, true], "aps.15.24": [75, true], "aps.15.25": [103, true], "aps.15.26": [61, true], "aps.15.27": [70, true], "aps.15.28": [80, true], "aps.15.29": [78, true], "aps.15.30": [72, true]}}, "CHA": {"total": 3782, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [75, true], "fun1.2": [91, true], "fun1.3": [79, true], "fun1.4": [91, true], "fun1.5": [109, true], "fun2.1": [71, true], "fun2.2": [43, true], "fun2.3": [106, true], "fun2.4": [71, true], "fun2.5": [117, true], "fun3.1": [66, true], "fun3.2": [66, true], "fun3.3": [84, true], "fun3.4": [94, true], "fun3.5": [109, true], "fun4.1": [55, true], "fun4.2": [58, true], "fun4.3": [76, true], "fun4.4": [82, true], "fun4.5": [96, true], "fun5.1": [56, true], "fun5.2": [55, true], "fun5.3": [55, true], "fun5.4": [57, true], "fun5.5": [58, true], "fun6.1": [48, true], "fun6.2": [48, true], "fun6.3": [52, true], "fun6.4": [54, true], "fun6.5": [55, true], "fun7.1": [10, false], "fun7.2": [12, false], "fun7.3": [15, false], "fun7.4": [16, false], "fun7.5": [19, false], "fun8.1": [76, true], "fun8.2": [21, true], "fun8.3": [76, true], "fun8.4": [81, true], "fun8.5": [84, true], "fun9.1": [22, true], "fun9.2": [47, true], "fun9.3": [20, true], "fun9.4": [92, true], "fun9.5": [86, true]}}}, {"label": "pure.rational.derived.step", "spec": ["pure", "rational", "derived", "step"], "APS": {"total": 3649, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [16, true], "aps.02.01": [41, true], "aps.02.02": [43, true], "aps.02.03": [18, true], "aps.02.04": [21, true], "aps.02.05": [22, true], "aps.02.06": [52, true], "aps.02.07": [23, true], "aps.02.08": [23, true], "aps.02.09": [24, true], "aps.03.00": [15, true], "aps.03.01": [22, true], "aps.03.02": [51, true], "aps.04.00": [16, true], "aps.04.01": [42, true], "aps.04.02": [16, true], "aps.04.03": [17, true], "aps.04.04": [17, true], "aps.04.05": [16, true], "aps.04.06": [15, true], "aps.04.07": [16, true], "aps.04.08": [18, true], "aps.04.09": [18, true], "aps.04.10": [20, true], "aps.04.11": [19, true], "aps.04.12": [20, true], "aps.04.13": [20, true], "aps.05.00": [10, true], "aps.06.00": [9, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [15, true], "aps.06.08": [16, true], "aps.06.09": [16, true], "aps.07.00": [11, true], "aps.07.01": [14, true], "aps.07.02": [16, true], "aps.08.00": [8, true], "aps.08.01": [49, true], "aps.08.02": [11, true], "aps.08.03": [15, true], "aps.08.04": [50, true], "aps.09.00": [36, true], "aps.09.01": [44, true], "aps.09.02": [14, true], "aps.09.03": [15, true], "aps.09.04": [18, true], "aps.09.05": [22, true], "aps.09.06": [24, true], "aps.10.00": [9, true], "aps.10.01": [51, true], "aps.10.02": [51, true], "aps.10.03": [16, true], "aps.10.04": [53, true], "aps.11.00": [11, true], "aps.11.01": [14, true], "aps.11.02": [15, true], "aps.11.03": [15, true], "aps.12.00": [11, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [11, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [20, true], "aps.14.01": [20, true], "aps.14.02": [20, true], "aps.14.03": [20, true], "aps.14.04": [20, true], "aps.14.05": [20, true], "aps.14.06": [20, true], "aps.14.07": [20, true], "aps.14.08": [20, true], "aps.14.09": [20, true], "aps.14.10": [20, true], "aps.14.11": [20, true], "aps.14.12": [20, true], "aps.14.13": [20, true], "aps.14.14": [20, true], "aps.14.15": [20, true], "aps.14.16": [20, true], "aps.14.17": [20, true], "aps.14.18": [20, true], "aps.14.19": [20, true], "aps.14.20": [20, true], "aps.14.21": [20, true], "aps.14.22": [20, true], "aps.14.23": [20, true], "aps.14.24": [20, true], "aps.14.25": [20, true], "aps.14.26": [20, true], "aps.14.27": [20, true], "aps.14.28": [20, true], "aps.14.29": [20, true], "aps.14.30": [20, true], "aps.14.31": [20, true], "aps.14.32": [20, true], "aps.14.33": [20, true], "aps.14.34": [20, true], "aps.14.35": [20, true], "aps.14.36": [20, true], "aps.14.37": [20, true], "aps.14.38": [20, true], "aps.14.39": [20, true], "aps.15.00": [33, true], "aps.15.01": [33, true], "aps.15.02": [34, true], "aps.15.03": [35, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [34, true], "aps.15.08": [34, true], "aps.15.09": [34, true], "aps.15.10": [34, true], "aps.15.11": [35, true], "aps.15.12": [34, true], "aps.15.13": [34, true], "aps.15.14": [35, true], "aps.15.15": [35, true], "aps.15.16": [35, true], "aps.15.17": [35, true], "aps.15.18": [35, true], "aps.15.19": [35, true], "aps.15.20": [35, true], "aps.15.21": [35, true], "aps.15.22": [36, true], "aps.15.23": [37, true], "aps.15.24": [37, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [36, true], "aps.15.28": [36, true], "aps.15.29": [35, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3618, "solved": 40, "n": 45, "over": 10, "per": {"fun1.1": [37, true], "fun1.2": [15, true], "fun1.3": [45, true], "fun1.4": [35, true], "fun1.5": [76, true], "fun2.1": [11, true], "fun2.2": [32, true], "fun2.3": [45, true], "fun2.4": [66, true], "fun2.5": [72, true], "fun3.1": [89, true], "fun3.2": [90, true], "fun3.3": [112, true], "fun3.4": [127, true], "fun3.5": [151, true], "fun4.1": [90, true], "fun4.2": [96, true], "fun4.3": [118, true], "fun4.4": [130, true], "fun4.5": [159, true], "fun5.1": [95, true], "fun5.2": [97, true], "fun5.3": [94, true], "fun5.4": [101, true], "fun5.5": [104, true], "fun6.1": [62, true], "fun6.2": [63, true], "fun6.3": [68, true], "fun6.4": [73, true], "fun6.5": [73, true], "fun7.1": [10, false], "fun7.2": [12, false], "fun7.3": [13, false], "fun7.4": [16, false], "fun7.5": [18, false], "fun8.1": [15, true], "fun8.2": [11, true], "fun8.3": [15, true], "fun8.4": [15, true], "fun8.5": [17, true], "fun9.1": [8, true], "fun9.2": [11, true], "fun9.3": [18, true], "fun9.4": [61, true], "fun9.5": [21, true]}}}, {"label": "pure.rational.derived.safe", "spec": ["pure", "rational", "derived", "safe"], "APS": {"total": 3649, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [16, true], "aps.02.01": [41, true], "aps.02.02": [43, true], "aps.02.03": [18, true], "aps.02.04": [21, true], "aps.02.05": [22, true], "aps.02.06": [52, true], "aps.02.07": [23, true], "aps.02.08": [23, true], "aps.02.09": [24, true], "aps.03.00": [15, true], "aps.03.01": [22, true], "aps.03.02": [51, true], "aps.04.00": [16, true], "aps.04.01": [42, true], "aps.04.02": [16, true], "aps.04.03": [17, true], "aps.04.04": [17, true], "aps.04.05": [16, true], "aps.04.06": [15, true], "aps.04.07": [16, true], "aps.04.08": [18, true], "aps.04.09": [18, true], "aps.04.10": [20, true], "aps.04.11": [19, true], "aps.04.12": [20, true], "aps.04.13": [20, true], "aps.05.00": [10, true], "aps.06.00": [9, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [15, true], "aps.06.08": [16, true], "aps.06.09": [16, true], "aps.07.00": [11, true], "aps.07.01": [14, true], "aps.07.02": [16, true], "aps.08.00": [8, true], "aps.08.01": [49, true], "aps.08.02": [11, true], "aps.08.03": [15, true], "aps.08.04": [50, true], "aps.09.00": [36, true], "aps.09.01": [44, true], "aps.09.02": [14, true], "aps.09.03": [15, true], "aps.09.04": [18, true], "aps.09.05": [22, true], "aps.09.06": [24, true], "aps.10.00": [9, true], "aps.10.01": [51, true], "aps.10.02": [51, true], "aps.10.03": [16, true], "aps.10.04": [53, true], "aps.11.00": [11, true], "aps.11.01": [14, true], "aps.11.02": [15, true], "aps.11.03": [15, true], "aps.12.00": [11, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [11, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [20, true], "aps.14.01": [20, true], "aps.14.02": [20, true], "aps.14.03": [20, true], "aps.14.04": [20, true], "aps.14.05": [20, true], "aps.14.06": [20, true], "aps.14.07": [20, true], "aps.14.08": [20, true], "aps.14.09": [20, true], "aps.14.10": [20, true], "aps.14.11": [20, true], "aps.14.12": [20, true], "aps.14.13": [20, true], "aps.14.14": [20, true], "aps.14.15": [20, true], "aps.14.16": [20, true], "aps.14.17": [20, true], "aps.14.18": [20, true], "aps.14.19": [20, true], "aps.14.20": [20, true], "aps.14.21": [20, true], "aps.14.22": [20, true], "aps.14.23": [20, true], "aps.14.24": [20, true], "aps.14.25": [20, true], "aps.14.26": [20, true], "aps.14.27": [20, true], "aps.14.28": [20, true], "aps.14.29": [20, true], "aps.14.30": [20, true], "aps.14.31": [20, true], "aps.14.32": [20, true], "aps.14.33": [20, true], "aps.14.34": [20, true], "aps.14.35": [20, true], "aps.14.36": [20, true], "aps.14.37": [20, true], "aps.14.38": [20, true], "aps.14.39": [20, true], "aps.15.00": [33, true], "aps.15.01": [33, true], "aps.15.02": [34, true], "aps.15.03": [35, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [34, true], "aps.15.08": [34, true], "aps.15.09": [34, true], "aps.15.10": [34, true], "aps.15.11": [35, true], "aps.15.12": [34, true], "aps.15.13": [34, true], "aps.15.14": [35, true], "aps.15.15": [35, true], "aps.15.16": [35, true], "aps.15.17": [35, true], "aps.15.18": [35, true], "aps.15.19": [35, true], "aps.15.20": [35, true], "aps.15.21": [35, true], "aps.15.22": [36, true], "aps.15.23": [37, true], "aps.15.24": [37, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [36, true], "aps.15.28": [36, true], "aps.15.29": [35, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3557, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [37, true], "fun1.2": [15, true], "fun1.3": [45, true], "fun1.4": [35, true], "fun1.5": [76, true], "fun2.1": [11, true], "fun2.2": [32, true], "fun2.3": [45, true], "fun2.4": [66, true], "fun2.5": [72, true], "fun3.1": [87, true], "fun3.2": [90, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [151, true], "fun4.1": [89, true], "fun4.2": [93, true], "fun4.3": [112, true], "fun4.4": [124, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [62, true], "fun6.2": [63, true], "fun6.3": [68, true], "fun6.4": [73, true], "fun6.5": [73, true], "fun7.1": [10, false], "fun7.2": [12, false], "fun7.3": [13, false], "fun7.4": [16, false], "fun7.5": [18, false], "fun8.1": [15, true], "fun8.2": [11, true], "fun8.3": [15, true], "fun8.4": [15, true], "fun8.5": [17, true], "fun9.1": [8, true], "fun9.2": [11, true], "fun9.3": [18, true], "fun9.4": [61, true], "fun9.5": [21, true]}}}, {"label": "pure.rational.derived3.none", "spec": ["pure", "rational", "derived3", "none"], "APS": {"total": 3356, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [11, true], "aps.02.01": [37, true], "aps.02.02": [10, true], "aps.02.03": [19, true], "aps.02.04": [9, true], "aps.02.05": [12, true], "aps.02.06": [29, true], "aps.02.07": [12, true], "aps.02.08": [11, true], "aps.02.09": [10, true], "aps.03.00": [25, true], "aps.03.01": [54, true], "aps.03.02": [18, true], "aps.04.00": [46, true], "aps.04.01": [48, true], "aps.04.02": [17, true], "aps.04.03": [17, true], "aps.04.04": [21, true], "aps.04.05": [13, true], "aps.04.06": [14, true], "aps.04.07": [17, true], "aps.04.08": [15, true], "aps.04.09": [17, true], "aps.04.10": [18, true], "aps.04.11": [20, true], "aps.04.12": [16, true], "aps.04.13": [18, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [12, true], "aps.06.06": [13, true], "aps.06.07": [14, true], "aps.06.08": [14, true], "aps.06.09": [14, true], "aps.07.00": [12, true], "aps.07.01": [13, true], "aps.07.02": [15, true], "aps.08.00": [8, true], "aps.08.01": [9, true], "aps.08.02": [10, true], "aps.08.03": [42, true], "aps.08.04": [12, true], "aps.09.00": [27, true], "aps.09.01": [12, true], "aps.09.02": [14, true], "aps.09.03": [15, true], "aps.09.04": [19, true], "aps.09.05": [22, true], "aps.09.06": [24, true], "aps.10.00": [8, true], "aps.10.01": [45, true], "aps.10.02": [46, true], "aps.10.03": [48, true], "aps.10.04": [37, true], "aps.11.00": [10, true], "aps.11.01": [12, true], "aps.11.02": [13, true], "aps.11.03": [14, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [11, true], "aps.12.09": [10, true], "aps.12.10": [9, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [200, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [31, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [33, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [33, true], "aps.15.09": [33, true], "aps.15.10": [33, true], "aps.15.11": [33, true], "aps.15.12": [33, true], "aps.15.13": [33, true], "aps.15.14": [34, true], "aps.15.15": [33, true], "aps.15.16": [33, true], "aps.15.17": [34, true], "aps.15.18": [33, true], "aps.15.19": [32, true], "aps.15.20": [32, true], "aps.15.21": [34, true], "aps.15.22": [37, true], "aps.15.23": [39, true], "aps.15.24": [39, true], "aps.15.25": [39, true], "aps.15.26": [40, true], "aps.15.27": [41, true], "aps.15.28": [40, true], "aps.15.29": [40, true], "aps.15.30": [38, true]}}, "CHA": {"total": 4453, "solved": 35, "n": 45, "over": 10, "per": {"fun1.1": [7, true], "fun1.2": [21, true], "fun1.3": [28, true], "fun1.4": [30, true], "fun1.5": [59, true], "fun2.1": [9, true], "fun2.2": [33, true], "fun2.3": [46, true], "fun2.4": [66, true], "fun2.5": [72, true], "fun3.1": [54, true], "fun3.2": [79, true], "fun3.3": [89, true], "fun3.4": [105, true], "fun3.5": [115, true], "fun4.1": [139, true], "fun4.2": [148, true], "fun4.3": [158, true], "fun4.4": [180, true], "fun4.5": [200, true], "fun5.1": [112, true], "fun5.2": [130, true], "fun5.3": [129, true], "fun5.4": [133, true], "fun5.5": [141, true], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [71, false], "fun7.2": [31, false], "fun7.3": [128, false], "fun7.4": [59, false], "fun7.5": [34, false], "fun8.1": [10, true], "fun8.2": [12, true], "fun8.3": [13, true], "fun8.4": [14, true], "fun8.5": [15, true], "fun9.1": [8, true], "fun9.2": [10, true], "fun9.3": [22, true], "fun9.4": [38, true], "fun9.5": [28, true]}}}, {"label": "pure.rational.derived3.step", "spec": ["pure", "rational", "derived3", "step"], "APS": {"total": 3420, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [50, true], "aps.02.01": [12, true], "aps.02.02": [27, true], "aps.02.03": [51, true], "aps.02.04": [25, true], "aps.02.05": [22, true], "aps.02.06": [52, true], "aps.02.07": [19, true], "aps.02.08": [21, true], "aps.02.09": [23, true], "aps.03.00": [39, true], "aps.03.01": [56, true], "aps.03.02": [21, true], "aps.04.00": [14, true], "aps.04.01": [16, true], "aps.04.02": [48, true], "aps.04.03": [21, true], "aps.04.04": [21, true], "aps.04.05": [12, true], "aps.04.06": [15, true], "aps.04.07": [16, true], "aps.04.08": [17, true], "aps.04.09": [17, true], "aps.04.10": [16, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [16, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [12, true], "aps.06.06": [13, true], "aps.06.07": [14, true], "aps.06.08": [14, true], "aps.06.09": [14, true], "aps.07.00": [12, true], "aps.07.01": [13, true], "aps.07.02": [15, true], "aps.08.00": [8, true], "aps.08.01": [9, true], "aps.08.02": [10, true], "aps.08.03": [15, true], "aps.08.04": [12, true], "aps.09.00": [27, true], "aps.09.01": [12, true], "aps.09.02": [14, true], "aps.09.03": [15, true], "aps.09.04": [19, true], "aps.09.05": [22, true], "aps.09.06": [24, true], "aps.10.00": [8, true], "aps.10.01": [45, true], "aps.10.02": [14, true], "aps.10.03": [37, true], "aps.10.04": [52, true], "aps.11.00": [11, true], "aps.11.01": [12, true], "aps.11.02": [13, true], "aps.11.03": [14, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [9, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [31, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [33, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [33, true], "aps.15.09": [33, true], "aps.15.10": [33, true], "aps.15.11": [33, true], "aps.15.12": [33, true], "aps.15.13": [33, true], "aps.15.14": [34, true], "aps.15.15": [33, true], "aps.15.16": [33, true], "aps.15.17": [34, true], "aps.15.18": [33, true], "aps.15.19": [32, true], "aps.15.20": [32, true], "aps.15.21": [34, true], "aps.15.22": [36, true], "aps.15.23": [38, true], "aps.15.24": [38, true], "aps.15.25": [39, true], "aps.15.26": [38, true], "aps.15.27": [39, true], "aps.15.28": [39, true], "aps.15.29": [40, true], "aps.15.30": [38, true]}}, "CHA": {"total": 3618, "solved": 40, "n": 45, "over": 9, "per": {"fun1.1": [7, true], "fun1.2": [32, true], "fun1.3": [30, true], "fun1.4": [51, true], "fun1.5": [70, true], "fun2.1": [12, true], "fun2.2": [29, true], "fun2.3": [37, true], "fun2.4": [54, true], "fun2.5": [60, true], "fun3.1": [81, true], "fun3.2": [89, true], "fun3.3": [105, true], "fun3.4": [112, true], "fun3.5": [144, true], "fun4.1": [95, true], "fun4.2": [102, true], "fun4.3": [114, true], "fun4.4": [136, true], "fun4.5": [164, true], "fun5.1": [100, true], "fun5.2": [103, true], "fun5.3": [108, true], "fun5.4": [110, true], "fun5.5": [111, true], "fun6.1": [74, true], "fun6.2": [86, true], "fun6.3": [82, true], "fun6.4": [88, true], "fun6.5": [88, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [15, false], "fun7.5": [17, false], "fun8.1": [13, true], "fun8.2": [12, true], "fun8.3": [13, true], "fun8.4": [16, true], "fun8.5": [17, true], "fun9.1": [8, true], "fun9.2": [10, true], "fun9.3": [18, true], "fun9.4": [19, true], "fun9.5": [18, true]}}}, {"label": "pure.rational.derived.both", "spec": ["pure", "rational", "derived", "both"], "APS": {"total": 8367, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [51, true], "aps.02.00": [53, true], "aps.02.01": [54, true], "aps.02.02": [54, true], "aps.02.03": [31, true], "aps.02.04": [52, true], "aps.02.05": [55, true], "aps.02.06": [55, true], "aps.02.07": [56, true], "aps.02.08": [53, true], "aps.02.09": [57, true], "aps.03.00": [56, true], "aps.03.01": [55, true], "aps.03.02": [57, true], "aps.04.00": [56, true], "aps.04.01": [47, true], "aps.04.02": [55, true], "aps.04.03": [55, true], "aps.04.04": [52, true], "aps.04.05": [53, true], "aps.04.06": [54, true], "aps.04.07": [51, true], "aps.04.08": [55, true], "aps.04.09": [55, true], "aps.04.10": [54, true], "aps.04.11": [46, true], "aps.04.12": [55, true], "aps.04.13": [54, true], "aps.05.00": [46, true], "aps.06.00": [49, true], "aps.06.01": [50, true], "aps.06.02": [50, true], "aps.06.03": [50, true], "aps.06.04": [48, true], "aps.06.05": [45, true], "aps.06.06": [45, true], "aps.06.07": [46, true], "aps.06.08": [49, true], "aps.06.09": [50, true], "aps.07.00": [48, true], "aps.07.01": [49, true], "aps.07.02": [49, true], "aps.08.00": [53, true], "aps.08.01": [47, true], "aps.08.02": [50, true], "aps.08.03": [49, true], "aps.08.04": [48, true], "aps.09.00": [50, true], "aps.09.01": [47, true], "aps.09.02": [49, true], "aps.09.03": [50, true], "aps.09.04": [48, true], "aps.09.05": [48, true], "aps.09.06": [47, true], "aps.10.00": [47, true], "aps.10.01": [50, true], "aps.10.02": [42, true], "aps.10.03": [51, true], "aps.10.04": [50, true], "aps.11.00": [38, true], "aps.11.01": [50, true], "aps.11.02": [46, true], "aps.11.03": [51, true], "aps.12.00": [54, true], "aps.12.01": [55, true], "aps.12.02": [56, true], "aps.12.03": [54, true], "aps.12.04": [46, true], "aps.12.05": [52, true], "aps.12.06": [53, true], "aps.12.07": [55, true], "aps.12.08": [54, true], "aps.12.09": [57, true], "aps.12.10": [56, true], "aps.12.11": [51, true], "aps.12.12": [53, true], "aps.12.13": [56, true], "aps.12.14": [57, true], "aps.12.15": [57, true], "aps.12.16": [58, true], "aps.12.17": [59, true], "aps.12.18": [57, true], "aps.13.00": [7, false], "aps.14.00": [55, true], "aps.14.01": [55, true], "aps.14.02": [55, true], "aps.14.03": [55, true], "aps.14.04": [55, true], "aps.14.05": [55, true], "aps.14.06": [55, true], "aps.14.07": [55, true], "aps.14.08": [55, true], "aps.14.09": [55, true], "aps.14.10": [55, true], "aps.14.11": [55, true], "aps.14.12": [55, true], "aps.14.13": [55, true], "aps.14.14": [55, true], "aps.14.15": [55, true], "aps.14.16": [55, true], "aps.14.17": [55, true], "aps.14.18": [55, true], "aps.14.19": [55, true], "aps.14.20": [55, true], "aps.14.21": [55, true], "aps.14.22": [55, true], "aps.14.23": [55, true], "aps.14.24": [55, true], "aps.14.25": [55, true], "aps.14.26": [55, true], "aps.14.27": [55, true], "aps.14.28": [55, true], "aps.14.29": [55, true], "aps.14.30": [55, true], "aps.14.31": [55, true], "aps.14.32": [55, true], "aps.14.33": [55, true], "aps.14.34": [55, true], "aps.14.35": [55, true], "aps.14.36": [55, true], "aps.14.37": [55, true], "aps.14.38": [55, true], "aps.14.39": [55, true], "aps.15.00": [58, true], "aps.15.01": [59, true], "aps.15.02": [59, true], "aps.15.03": [58, true], "aps.15.04": [58, true], "aps.15.05": [58, true], "aps.15.06": [58, true], "aps.15.07": [58, true], "aps.15.08": [58, true], "aps.15.09": [57, true], "aps.15.10": [58, true], "aps.15.11": [58, true], "aps.15.12": [58, true], "aps.15.13": [58, true], "aps.15.14": [57, true], "aps.15.15": [58, true], "aps.15.16": [57, true], "aps.15.17": [58, true], "aps.15.18": [59, true], "aps.15.19": [57, true], "aps.15.20": [58, true], "aps.15.21": [54, true], "aps.15.22": [57, true], "aps.15.23": [57, true], "aps.15.24": [58, true], "aps.15.25": [48, true], "aps.15.26": [51, true], "aps.15.27": [52, true], "aps.15.28": [55, true], "aps.15.29": [56, true], "aps.15.30": [56, true]}}, "CHA": {"total": 3674, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [51, true], "fun1.2": [55, true], "fun1.3": [61, true], "fun1.4": [69, true], "fun1.5": [91, true], "fun2.1": [46, true], "fun2.2": [73, true], "fun2.3": [81, true], "fun2.4": [96, true], "fun2.5": [100, true], "fun3.1": [59, true], "fun3.2": [63, true], "fun3.3": [71, true], "fun3.4": [79, true], "fun3.5": [96, true], "fun4.1": [70, true], "fun4.2": [70, true], "fun4.3": [80, true], "fun4.4": [89, true], "fun4.5": [103, true], "fun5.1": [72, true], "fun5.2": [72, true], "fun5.3": [74, true], "fun5.4": [75, true], "fun5.5": [77, true], "fun6.1": [56, true], "fun6.2": [57, true], "fun6.3": [46, true], "fun6.4": [50, true], "fun6.5": [52, true], "fun7.1": [7, false], "fun7.2": [7, false], "fun7.3": [10, false], "fun7.4": [24, false], "fun7.5": [14, false], "fun8.1": [51, true], "fun8.2": [52, true], "fun8.3": [51, true], "fun8.4": [55, true], "fun8.5": [58, true], "fun9.1": [50, true], "fun9.2": [53, true], "fun9.3": [55, true], "fun9.4": [58, true], "fun9.5": [57, true]}}}, {"label": "pure.rational.derived3.both", "spec": ["pure", "rational", "derived3", "both"], "APS": {"total": 8623, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [51, true], "aps.02.00": [54, true], "aps.02.01": [54, true], "aps.02.02": [54, true], "aps.02.03": [54, true], "aps.02.04": [53, true], "aps.02.05": [55, true], "aps.02.06": [56, true], "aps.02.07": [55, true], "aps.02.08": [55, true], "aps.02.09": [56, true], "aps.03.00": [58, true], "aps.03.01": [58, true], "aps.03.02": [57, true], "aps.04.00": [52, true], "aps.04.01": [54, true], "aps.04.02": [55, true], "aps.04.03": [55, true], "aps.04.04": [56, true], "aps.04.05": [53, true], "aps.04.06": [54, true], "aps.04.07": [55, true], "aps.04.08": [52, true], "aps.04.09": [54, true], "aps.04.10": [54, true], "aps.04.11": [55, true], "aps.04.12": [53, true], "aps.04.13": [53, true], "aps.05.00": [51, true], "aps.06.00": [49, true], "aps.06.01": [50, true], "aps.06.02": [50, true], "aps.06.03": [50, true], "aps.06.04": [47, true], "aps.06.05": [49, true], "aps.06.06": [48, true], "aps.06.07": [48, true], "aps.06.08": [44, true], "aps.06.09": [44, true], "aps.07.00": [48, true], "aps.07.01": [49, true], "aps.07.02": [48, true], "aps.08.00": [53, true], "aps.08.01": [48, true], "aps.08.02": [50, true], "aps.08.03": [51, true], "aps.08.04": [51, true], "aps.09.00": [49, true], "aps.09.01": [49, true], "aps.09.02": [49, true], "aps.09.03": [48, true], "aps.09.04": [47, true], "aps.09.05": [47, true], "aps.09.06": [46, true], "aps.10.00": [50, true], "aps.10.01": [52, true], "aps.10.02": [50, true], "aps.10.03": [52, true], "aps.10.04": [51, true], "aps.11.00": [36, true], "aps.11.01": [49, true], "aps.11.02": [50, true], "aps.11.03": [50, true], "aps.12.00": [54, true], "aps.12.01": [56, true], "aps.12.02": [57, true], "aps.12.03": [57, true], "aps.12.04": [57, true], "aps.12.05": [57, true], "aps.12.06": [51, true], "aps.12.07": [53, true], "aps.12.08": [57, true], "aps.12.09": [54, true], "aps.12.10": [54, true], "aps.12.11": [51, true], "aps.12.12": [53, true], "aps.12.13": [57, true], "aps.12.14": [59, true], "aps.12.15": [58, true], "aps.12.16": [57, true], "aps.12.17": [45, true], "aps.12.18": [50, true], "aps.13.00": [7, false], "aps.14.00": [60, true], "aps.14.01": [60, true], "aps.14.02": [60, true], "aps.14.03": [60, true], "aps.14.04": [60, true], "aps.14.05": [60, true], "aps.14.06": [60, true], "aps.14.07": [60, true], "aps.14.08": [60, true], "aps.14.09": [60, true], "aps.14.10": [60, true], "aps.14.11": [60, true], "aps.14.12": [60, true], "aps.14.13": [60, true], "aps.14.14": [60, true], "aps.14.15": [60, true], "aps.14.16": [60, true], "aps.14.17": [60, true], "aps.14.18": [62, true], "aps.14.19": [60, true], "aps.14.20": [60, true], "aps.14.21": [60, true], "aps.14.22": [60, true], "aps.14.23": [60, true], "aps.14.24": [60, true], "aps.14.25": [60, true], "aps.14.26": [60, true], "aps.14.27": [60, true], "aps.14.28": [60, true], "aps.14.29": [60, true], "aps.14.30": [60, true], "aps.14.31": [60, true], "aps.14.32": [60, true], "aps.14.33": [60, true], "aps.14.34": [60, true], "aps.14.35": [60, true], "aps.14.36": [60, true], "aps.14.37": [62, true], "aps.14.38": [60, true], "aps.14.39": [60, true], "aps.15.00": [58, true], "aps.15.01": [58, true], "aps.15.02": [59, true], "aps.15.03": [58, true], "aps.15.04": [58, true], "aps.15.05": [59, true], "aps.15.06": [57, true], "aps.15.07": [58, true], "aps.15.08": [58, true], "aps.15.09": [56, true], "aps.15.10": [59, true], "aps.15.11": [58, true], "aps.15.12": [58, true], "aps.15.13": [58, true], "aps.15.14": [58, true], "aps.15.15": [56, true], "aps.15.16": [58, true], "aps.15.17": [58, true], "aps.15.18": [57, true], "aps.15.19": [56, true], "aps.15.20": [57, true], "aps.15.21": [57, true], "aps.15.22": [55, true], "aps.15.23": [53, true], "aps.15.24": [55, true], "aps.15.25": [56, true], "aps.15.26": [57, true], "aps.15.27": [57, true], "aps.15.28": [55, true], "aps.15.29": [53, true], "aps.15.30": [44, true]}}, "CHA": {"total": 3815, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [51, true], "fun1.2": [53, true], "fun1.3": [59, true], "fun1.4": [68, true], "fun1.5": [101, true], "fun2.1": [50, true], "fun2.2": [71, true], "fun2.3": [83, true], "fun2.4": [99, true], "fun2.5": [107, true], "fun3.1": [62, true], "fun3.2": [66, true], "fun3.3": [84, true], "fun3.4": [92, true], "fun3.5": [109, true], "fun4.1": [69, true], "fun4.2": [73, true], "fun4.3": [91, true], "fun4.4": [101, true], "fun4.5": [120, true], "fun5.1": [70, true], "fun5.2": [69, true], "fun5.3": [73, true], "fun5.4": [76, true], "fun5.5": [78, true], "fun6.1": [56, true], "fun6.2": [59, true], "fun6.3": [57, true], "fun6.4": [63, true], "fun6.5": [67, true], "fun7.1": [7, false], "fun7.2": [7, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [15, false], "fun8.1": [51, true], "fun8.2": [52, true], "fun8.3": [53, true], "fun8.4": [54, true], "fun8.5": [55, true], "fun9.1": [49, true], "fun9.2": [52, true], "fun9.3": [55, true], "fun9.4": [59, true], "fun9.5": [58, true]}}}, {"label": "pure.rational.derived3.bracket", "spec": ["pure", "rational", "derived3", "bracket"], "APS": {"total": 8619, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [52, true], "aps.02.00": [54, true], "aps.02.01": [52, true], "aps.02.02": [54, true], "aps.02.03": [54, true], "aps.02.04": [54, true], "aps.02.05": [55, true], "aps.02.06": [55, true], "aps.02.07": [55, true], "aps.02.08": [55, true], "aps.02.09": [56, true], "aps.03.00": [56, true], "aps.03.01": [56, true], "aps.03.02": [56, true], "aps.04.00": [55, true], "aps.04.01": [56, true], "aps.04.02": [53, true], "aps.04.03": [56, true], "aps.04.04": [54, true], "aps.04.05": [55, true], "aps.04.06": [54, true], "aps.04.07": [52, true], "aps.04.08": [54, true], "aps.04.09": [56, true], "aps.04.10": [53, true], "aps.04.11": [55, true], "aps.04.12": [54, true], "aps.04.13": [53, true], "aps.05.00": [51, true], "aps.06.00": [50, true], "aps.06.01": [50, true], "aps.06.02": [50, true], "aps.06.03": [50, true], "aps.06.04": [49, true], "aps.06.05": [50, true], "aps.06.06": [42, true], "aps.06.07": [47, true], "aps.06.08": [42, true], "aps.06.09": [43, true], "aps.07.00": [48, true], "aps.07.01": [49, true], "aps.07.02": [48, true], "aps.08.00": [53, true], "aps.08.01": [50, true], "aps.08.02": [50, true], "aps.08.03": [50, true], "aps.08.04": [47, true], "aps.09.00": [50, true], "aps.09.01": [50, true], "aps.09.02": [49, true], "aps.09.03": [48, true], "aps.09.04": [47, true], "aps.09.05": [45, true], "aps.09.06": [47, true], "aps.10.00": [49, true], "aps.10.01": [51, true], "aps.10.02": [51, true], "aps.10.03": [51, true], "aps.10.04": [52, true], "aps.11.00": [37, true], "aps.11.01": [52, true], "aps.11.02": [51, true], "aps.11.03": [49, true], "aps.12.00": [54, true], "aps.12.01": [56, true], "aps.12.02": [57, true], "aps.12.03": [57, true], "aps.12.04": [56, true], "aps.12.05": [57, true], "aps.12.06": [51, true], "aps.12.07": [54, true], "aps.12.08": [52, true], "aps.12.09": [58, true], "aps.12.10": [53, true], "aps.12.11": [49, true], "aps.12.12": [55, true], "aps.12.13": [58, true], "aps.12.14": [59, true], "aps.12.15": [52, true], "aps.12.16": [58, true], "aps.12.17": [48, true], "aps.12.18": [51, true], "aps.13.00": [11, false], "aps.14.00": [60, true], "aps.14.01": [60, true], "aps.14.02": [60, true], "aps.14.03": [60, true], "aps.14.04": [60, true], "aps.14.05": [60, true], "aps.14.06": [60, true], "aps.14.07": [60, true], "aps.14.08": [60, true], "aps.14.09": [60, true], "aps.14.10": [60, true], "aps.14.11": [60, true], "aps.14.12": [60, true], "aps.14.13": [60, true], "aps.14.14": [60, true], "aps.14.15": [60, true], "aps.14.16": [60, true], "aps.14.17": [60, true], "aps.14.18": [60, true], "aps.14.19": [60, true], "aps.14.20": [60, true], "aps.14.21": [60, true], "aps.14.22": [60, true], "aps.14.23": [60, true], "aps.14.24": [60, true], "aps.14.25": [60, true], "aps.14.26": [60, true], "aps.14.27": [60, true], "aps.14.28": [60, true], "aps.14.29": [60, true], "aps.14.30": [60, true], "aps.14.31": [60, true], "aps.14.32": [60, true], "aps.14.33": [60, true], "aps.14.34": [60, true], "aps.14.35": [60, true], "aps.14.36": [60, true], "aps.14.37": [60, true], "aps.14.38": [60, true], "aps.14.39": [60, true], "aps.15.00": [59, true], "aps.15.01": [57, true], "aps.15.02": [59, true], "aps.15.03": [58, true], "aps.15.04": [59, true], "aps.15.05": [59, true], "aps.15.06": [58, true], "aps.15.07": [57, true], "aps.15.08": [58, true], "aps.15.09": [58, true], "aps.15.10": [57, true], "aps.15.11": [57, true], "aps.15.12": [58, true], "aps.15.13": [58, true], "aps.15.14": [59, true], "aps.15.15": [59, true], "aps.15.16": [58, true], "aps.15.17": [58, true], "aps.15.18": [58, true], "aps.15.19": [57, true], "aps.15.20": [58, true], "aps.15.21": [57, true], "aps.15.22": [54, true], "aps.15.23": [53, true], "aps.15.24": [58, true], "aps.15.25": [57, true], "aps.15.26": [55, true], "aps.15.27": [57, true], "aps.15.28": [55, true], "aps.15.29": [53, true], "aps.15.30": [44, true]}}, "CHA": {"total": 3994, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [49, true], "fun1.2": [55, true], "fun1.3": [53, true], "fun1.4": [74, true], "fun1.5": [107, true], "fun2.1": [51, true], "fun2.2": [75, true], "fun2.3": [91, true], "fun2.4": [109, true], "fun2.5": [117, true], "fun3.1": [66, true], "fun3.2": [78, true], "fun3.3": [100, true], "fun3.4": [112, true], "fun3.5": [136, true], "fun4.1": [76, true], "fun4.2": [78, true], "fun4.3": [96, true], "fun4.4": [104, true], "fun4.5": [128, true], "fun5.1": [74, true], "fun5.2": [76, true], "fun5.3": [78, true], "fun5.4": [82, true], "fun5.5": [83, true], "fun6.1": [63, true], "fun6.2": [66, true], "fun6.3": [70, true], "fun6.4": [69, true], "fun6.5": [74, true], "fun7.1": [11, false], "fun7.2": [9, false], "fun7.3": [8, false], "fun7.4": [13, false], "fun7.5": [14, false], "fun8.1": [49, true], "fun8.2": [52, true], "fun8.3": [52, true], "fun8.4": [54, true], "fun8.5": [39, true], "fun9.1": [48, true], "fun9.2": [47, true], "fun9.3": [50, true], "fun9.4": [59, true], "fun9.5": [54, true]}}}, {"label": "pure.rational.bracket.bracket", "spec": ["pure", "rational", "bracket", "bracket"], "APS": {"total": 6605, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [42, true], "aps.02.00": [46, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [46, true], "aps.02.05": [43, true], "aps.02.06": [49, true], "aps.02.07": [46, true], "aps.02.08": [46, true], "aps.02.09": [46, true], "aps.03.00": [51, true], "aps.03.01": [42, true], "aps.03.02": [52, true], "aps.04.00": [47, true], "aps.04.01": [45, true], "aps.04.02": [47, true], "aps.04.03": [41, true], "aps.04.04": [41, true], "aps.04.05": [37, true], "aps.04.06": [40, true], "aps.04.07": [47, true], "aps.04.08": [45, true], "aps.04.09": [46, true], "aps.04.10": [45, true], "aps.04.11": [41, true], "aps.04.12": [42, true], "aps.04.13": [42, true], "aps.05.00": [45, true], "aps.06.00": [32, true], "aps.06.01": [44, true], "aps.06.02": [37, true], "aps.06.03": [39, true], "aps.06.04": [37, true], "aps.06.05": [39, true], "aps.06.06": [42, true], "aps.06.07": [41, true], "aps.06.08": [42, true], "aps.06.09": [38, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [40, true], "aps.08.03": [45, true], "aps.08.04": [44, true], "aps.09.00": [41, true], "aps.09.01": [41, true], "aps.09.02": [44, true], "aps.09.03": [44, true], "aps.09.04": [32, true], "aps.09.05": [42, true], "aps.09.06": [42, true], "aps.10.00": [45, true], "aps.10.01": [44, true], "aps.10.02": [45, true], "aps.10.03": [44, true], "aps.10.04": [44, true], "aps.11.00": [4, true], "aps.11.01": [28, true], "aps.11.02": [48, true], "aps.11.03": [46, true], "aps.12.00": [22, true], "aps.12.01": [26, true], "aps.12.02": [39, true], "aps.12.03": [40, true], "aps.12.04": [31, true], "aps.12.05": [41, true], "aps.12.06": [39, true], "aps.12.07": [49, true], "aps.12.08": [35, true], "aps.12.09": [34, true], "aps.12.10": [34, true], "aps.12.11": [31, true], "aps.12.12": [37, true], "aps.12.13": [20, true], "aps.12.14": [49, true], "aps.12.15": [44, true], "aps.12.16": [34, true], "aps.12.17": [27, true], "aps.12.18": [22, true], "aps.13.00": [6, false], "aps.14.00": [39, true], "aps.14.01": [39, true], "aps.14.02": [39, true], "aps.14.03": [39, true], "aps.14.04": [39, true], "aps.14.05": [39, true], "aps.14.06": [39, true], "aps.14.07": [39, true], "aps.14.08": [39, true], "aps.14.09": [39, true], "aps.14.10": [39, true], "aps.14.11": [39, true], "aps.14.12": [39, true], "aps.14.13": [39, true], "aps.14.14": [39, true], "aps.14.15": [39, true], "aps.14.16": [39, true], "aps.14.17": [39, true], "aps.14.18": [39, true], "aps.14.19": [39, true], "aps.14.20": [39, true], "aps.14.21": [39, true], "aps.14.22": [39, true], "aps.14.23": [39, true], "aps.14.24": [39, true], "aps.14.25": [39, true], "aps.14.26": [39, true], "aps.14.27": [39, true], "aps.14.28": [39, true], "aps.14.29": [39, true], "aps.14.30": [39, true], "aps.14.31": [39, true], "aps.14.32": [39, true], "aps.14.33": [39, true], "aps.14.34": [39, true], "aps.14.35": [39, true], "aps.14.36": [39, true], "aps.14.37": [39, true], "aps.14.38": [39, true], "aps.14.39": [39, true], "aps.15.00": [49, true], "aps.15.01": [52, true], "aps.15.02": [49, true], "aps.15.03": [51, true], "aps.15.04": [50, true], "aps.15.05": [50, true], "aps.15.06": [51, true], "aps.15.07": [49, true], "aps.15.08": [43, true], "aps.15.09": [45, true], "aps.15.10": [47, true], "aps.15.11": [49, true], "aps.15.12": [50, true], "aps.15.13": [51, true], "aps.15.14": [51, true], "aps.15.15": [51, true], "aps.15.16": [50, true], "aps.15.17": [53, true], "aps.15.18": [49, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [51, true], "aps.15.22": [52, true], "aps.15.23": [54, true], "aps.15.24": [53, true], "aps.15.25": [47, true], "aps.15.26": [54, true], "aps.15.27": [53, true], "aps.15.28": [47, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3433, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [45, true], "fun1.2": [46, true], "fun1.3": [52, true], "fun1.4": [55, true], "fun1.5": [77, true], "fun2.1": [30, true], "fun2.2": [56, true], "fun2.3": [68, true], "fun2.4": [64, true], "fun2.5": [83, true], "fun3.1": [53, true], "fun3.2": [54, true], "fun3.3": [66, true], "fun3.4": [75, true], "fun3.5": [83, true], "fun4.1": [82, true], "fun4.2": [86, true], "fun4.3": [83, true], "fun4.4": [100, true], "fun4.5": [106, true], "fun5.1": [61, true], "fun5.2": [66, true], "fun5.3": [67, true], "fun5.4": [68, true], "fun5.5": [69, true], "fun6.1": [62, true], "fun6.2": [66, true], "fun6.3": [56, true], "fun6.4": [60, true], "fun6.5": [60, true], "fun7.1": [6, false], "fun7.2": [10, false], "fun7.3": [10, false], "fun7.4": [11, false], "fun7.5": [13, false], "fun8.1": [41, true], "fun8.2": [27, true], "fun8.3": [51, true], "fun8.4": [53, true], "fun8.5": [53, true], "fun9.1": [28, true], "fun9.2": [45, true], "fun9.3": [48, true], "fun9.4": [39, true], "fun9.5": [49, true]}}}, {"label": "pure.rational.derived.credit", "spec": ["pure", "rational", "derived", "credit"], "APS": {"total": 7165, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [11, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [11, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [31, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [10, true], "aps.12.13": [31, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [6, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [51, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [36, true], "aps.15.28": [36, true], "aps.15.29": [35, true], "aps.15.30": [52, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [6, false], "fun7.2": [8, false], "fun7.3": [10, false], "fun7.4": [12, false], "fun7.5": [14, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.sqrt.start.bracket", "spec": ["pure", "sqrt", "start", "bracket"], "APS": {"total": 11206, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [68, true], "aps.02.00": [50, true], "aps.02.01": [49, true], "aps.02.02": [50, true], "aps.02.03": [49, true], "aps.02.04": [49, true], "aps.02.05": [49, true], "aps.02.06": [48, true], "aps.02.07": [48, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [72, true], "aps.04.01": [67, true], "aps.04.02": [71, true], "aps.04.03": [74, true], "aps.04.04": [66, true], "aps.04.05": [74, true], "aps.04.06": [74, true], "aps.04.07": [62, true], "aps.04.08": [73, true], "aps.04.09": [72, true], "aps.04.10": [70, true], "aps.04.11": [71, true], "aps.04.12": [71, true], "aps.04.13": [71, true], "aps.05.00": [66, true], "aps.06.00": [72, true], "aps.06.01": [73, true], "aps.06.02": [73, true], "aps.06.03": [66, true], "aps.06.04": [74, true], "aps.06.05": [77, true], "aps.06.06": [76, true], "aps.06.07": [77, true], "aps.06.08": [76, true], "aps.06.09": [74, true], "aps.07.00": [68, true], "aps.07.01": [69, true], "aps.07.02": [67, true], "aps.08.00": [3, true], "aps.08.01": [69, true], "aps.08.02": [73, true], "aps.08.03": [74, true], "aps.08.04": [74, true], "aps.09.00": [68, true], "aps.09.01": [68, true], "aps.09.02": [69, true], "aps.09.03": [60, true], "aps.09.04": [64, true], "aps.09.05": [60, true], "aps.09.06": [51, true], "aps.10.00": [69, true], "aps.10.01": [70, true], "aps.10.02": [75, true], "aps.10.03": [75, true], "aps.10.04": [73, true], "aps.11.00": [71, true], "aps.11.01": [70, true], "aps.11.02": [73, true], "aps.11.03": [62, true], "aps.12.00": [66, true], "aps.12.01": [78, true], "aps.12.02": [77, true], "aps.12.03": [81, true], "aps.12.04": [79, true], "aps.12.05": [81, true], "aps.12.06": [82, true], "aps.12.07": [70, true], "aps.12.08": [74, true], "aps.12.09": [81, true], "aps.12.10": [80, true], "aps.12.11": [81, true], "aps.12.12": [79, true], "aps.12.13": [80, true], "aps.12.14": [77, true], "aps.12.15": [76, true], "aps.12.16": [77, true], "aps.12.17": [80, true], "aps.12.18": [79, true], "aps.13.00": [10, false], "aps.14.00": [83, true], "aps.14.01": [83, true], "aps.14.02": [83, true], "aps.14.03": [83, true], "aps.14.04": [83, true], "aps.14.05": [83, true], "aps.14.06": [83, true], "aps.14.07": [83, true], "aps.14.08": [83, true], "aps.14.09": [83, true], "aps.14.10": [83, true], "aps.14.11": [83, true], "aps.14.12": [83, true], "aps.14.13": [83, true], "aps.14.14": [83, true], "aps.14.15": [83, true], "aps.14.16": [83, true], "aps.14.17": [83, true], "aps.14.18": [83, true], "aps.14.19": [83, true], "aps.14.20": [83, true], "aps.14.21": [83, true], "aps.14.22": [83, true], "aps.14.23": [83, true], "aps.14.24": [83, true], "aps.14.25": [83, true], "aps.14.26": [83, true], "aps.14.27": [83, true], "aps.14.28": [83, true], "aps.14.29": [83, true], "aps.14.30": [83, true], "aps.14.31": [83, true], "aps.14.32": [83, true], "aps.14.33": [83, true], "aps.14.34": [83, true], "aps.14.35": [83, true], "aps.14.36": [83, true], "aps.14.37": [83, true], "aps.14.38": [83, true], "aps.14.39": [83, true], "aps.15.00": [70, true], "aps.15.01": [72, true], "aps.15.02": [74, true], "aps.15.03": [74, true], "aps.15.04": [67, true], "aps.15.05": [75, true], "aps.15.06": [73, true], "aps.15.07": [73, true], "aps.15.08": [73, true], "aps.15.09": [71, true], "aps.15.10": [72, true], "aps.15.11": [66, true], "aps.15.12": [48, true], "aps.15.13": [71, true], "aps.15.14": [73, true], "aps.15.15": [73, true], "aps.15.16": [73, true], "aps.15.17": [73, true], "aps.15.18": [73, true], "aps.15.19": [73, true], "aps.15.20": [75, true], "aps.15.21": [71, true], "aps.15.22": [62, true], "aps.15.23": [63, true], "aps.15.24": [57, true], "aps.15.25": [68, true], "aps.15.26": [70, true], "aps.15.27": [67, true], "aps.15.28": [69, true], "aps.15.29": [57, true], "aps.15.30": [66, true]}}, "CHA": {"total": 4038, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [69, true], "fun1.2": [73, true], "fun1.3": [78, true], "fun1.4": [91, true], "fun1.5": [111, true], "fun2.1": [69, true], "fun2.2": [82, true], "fun2.3": [110, true], "fun2.4": [131, true], "fun2.5": [138, true], "fun3.1": [64, true], "fun3.2": [67, true], "fun3.3": [81, true], "fun3.4": [91, true], "fun3.5": [109, true], "fun4.1": [59, true], "fun4.2": [61, true], "fun4.3": [74, true], "fun4.4": [83, true], "fun4.5": [97, true], "fun5.1": [57, true], "fun5.2": [56, true], "fun5.3": [58, true], "fun5.4": [60, true], "fun5.5": [61, true], "fun6.1": [50, true], "fun6.2": [51, true], "fun6.3": [51, true], "fun6.4": [53, true], "fun6.5": [54, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [9, false], "fun7.4": [7, false], "fun7.5": [13, false], "fun8.1": [72, true], "fun8.2": [74, true], "fun8.3": [77, true], "fun8.4": [73, true], "fun8.5": [78, true], "fun9.1": [71, true], "fun9.2": [74, true], "fun9.3": [74, true], "fun9.4": [76, true], "fun9.5": [80, true]}}}, {"label": "pure.sqrt.start.step", "spec": ["pure", "sqrt", "start", "step"], "APS": {"total": 12282, "solved": 153, "n": 154, "over": 9, "per": {"aps.01.00": [88, true], "aps.02.00": [54, true], "aps.02.01": [51, true], "aps.02.02": [53, true], "aps.02.03": [50, true], "aps.02.04": [50, true], "aps.02.05": [50, true], "aps.02.06": [48, true], "aps.02.07": [48, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [85, true], "aps.04.01": [83, true], "aps.04.02": [78, true], "aps.04.03": [77, true], "aps.04.04": [81, true], "aps.04.05": [78, true], "aps.04.06": [82, true], "aps.04.07": [65, true], "aps.04.08": [82, true], "aps.04.09": [91, true], "aps.04.10": [77, true], "aps.04.11": [80, true], "aps.04.12": [82, true], "aps.04.13": [53, true], "aps.05.00": [69, true], "aps.06.00": [82, true], "aps.06.01": [82, true], "aps.06.02": [81, true], "aps.06.03": [81, true], "aps.06.04": [87, true], "aps.06.05": [79, true], "aps.06.06": [74, true], "aps.06.07": [86, true], "aps.06.08": [77, true], "aps.06.09": [80, true], "aps.07.00": [78, true], "aps.07.01": [72, true], "aps.07.02": [83, true], "aps.08.00": [3, true], "aps.08.01": [79, true], "aps.08.02": [69, true], "aps.08.03": [77, true], "aps.08.04": [76, true], "aps.09.00": [77, true], "aps.09.01": [77, true], "aps.09.02": [81, true], "aps.09.03": [82, true], "aps.09.04": [62, true], "aps.09.05": [57, true], "aps.09.06": [68, true], "aps.10.00": [87, true], "aps.10.01": [85, true], "aps.10.02": [74, true], "aps.10.03": [90, true], "aps.10.04": [86, true], "aps.11.00": [88, true], "aps.11.01": [81, true], "aps.11.02": [64, true], "aps.11.03": [78, true], "aps.12.00": [89, true], "aps.12.01": [86, true], "aps.12.02": [94, true], "aps.12.03": [87, true], "aps.12.04": [87, true], "aps.12.05": [76, true], "aps.12.06": [90, true], "aps.12.07": [79, true], "aps.12.08": [83, true], "aps.12.09": [91, true], "aps.12.10": [89, true], "aps.12.11": [90, true], "aps.12.12": [78, true], "aps.12.13": [77, true], "aps.12.14": [91, true], "aps.12.15": [86, true], "aps.12.16": [87, true], "aps.12.17": [93, true], "aps.12.18": [84, true], "aps.13.00": [10, false], "aps.14.00": [92, true], "aps.14.01": [92, true], "aps.14.02": [92, true], "aps.14.03": [92, true], "aps.14.04": [92, true], "aps.14.05": [92, true], "aps.14.06": [92, true], "aps.14.07": [92, true], "aps.14.08": [92, true], "aps.14.09": [92, true], "aps.14.10": [92, true], "aps.14.11": [92, true], "aps.14.12": [92, true], "aps.14.13": [92, true], "aps.14.14": [92, true], "aps.14.15": [92, true], "aps.14.16": [92, true], "aps.14.17": [92, true], "aps.14.18": [92, true], "aps.14.19": [92, true], "aps.14.20": [92, true], "aps.14.21": [92, true], "aps.14.22": [92, true], "aps.14.23": [92, true], "aps.14.24": [92, true], "aps.14.25": [92, true], "aps.14.26": [92, true], "aps.14.27": [92, true], "aps.14.28": [92, true], "aps.14.29": [92, true], "aps.14.30": [92, true], "aps.14.31": [92, true], "aps.14.32": [92, true], "aps.14.33": [92, true], "aps.14.34": [92, true], "aps.14.35": [92, true], "aps.14.36": [92, true], "aps.14.37": [92, true], "aps.14.38": [92, true], "aps.14.39": [92, true], "aps.15.00": [83, true], "aps.15.01": [82, true], "aps.15.02": [79, true], "aps.15.03": [78, true], "aps.15.04": [78, true], "aps.15.05": [79, true], "aps.15.06": [84, true], "aps.15.07": [58, true], "aps.15.08": [49, true], "aps.15.09": [79, true], "aps.15.10": [84, true], "aps.15.11": [75, true], "aps.15.12": [74, true], "aps.15.13": [77, true], "aps.15.14": [84, true], "aps.15.15": [78, true], "aps.15.16": [80, true], "aps.15.17": [77, true], "aps.15.18": [72, true], "aps.15.19": [62, true], "aps.15.20": [76, true], "aps.15.21": [73, true], "aps.15.22": [78, true], "aps.15.23": [71, true], "aps.15.24": [78, true], "aps.15.25": [68, true], "aps.15.26": [67, true], "aps.15.27": [63, true], "aps.15.28": [70, true], "aps.15.29": [66, true], "aps.15.30": [64, true]}}, "CHA": {"total": 4396, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [77, true], "fun1.2": [80, true], "fun1.3": [58, true], "fun1.4": [111, true], "fun1.5": [141, true], "fun2.1": [72, true], "fun2.2": [100, true], "fun2.3": [118, true], "fun2.4": [136, true], "fun2.5": [145, true], "fun3.1": [77, true], "fun3.2": [79, true], "fun3.3": [97, true], "fun3.4": [113, true], "fun3.5": [140, true], "fun4.1": [69, true], "fun4.2": [71, true], "fun4.3": [89, true], "fun4.4": [100, true], "fun4.5": [117, true], "fun5.1": [57, true], "fun5.2": [62, true], "fun5.3": [67, true], "fun5.4": [69, true], "fun5.5": [70, true], "fun6.1": [50, true], "fun6.2": [57, true], "fun6.3": [54, true], "fun6.4": [56, true], "fun6.5": [57, true], "fun7.1": [10, false], "fun7.2": [50, false], "fun7.3": [11, false], "fun7.4": [15, false], "fun7.5": [8, false], "fun8.1": [81, true], "fun8.2": [86, true], "fun8.3": [79, true], "fun8.4": [75, true], "fun8.5": [79, true], "fun9.1": [79, true], "fun9.2": [64, true], "fun9.3": [85, true], "fun9.4": [87, true], "fun9.5": [92, true]}}}, {"label": "pure.sqrt.start.both", "spec": ["pure", "sqrt", "start", "both"], "APS": {"total": 10050, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [61, true], "aps.02.00": [49, true], "aps.02.01": [47, true], "aps.02.02": [49, true], "aps.02.03": [48, true], "aps.02.04": [48, true], "aps.02.05": [48, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [62, true], "aps.04.01": [60, true], "aps.04.02": [63, true], "aps.04.03": [68, true], "aps.04.04": [57, true], "aps.04.05": [68, true], "aps.04.06": [63, true], "aps.04.07": [56, true], "aps.04.08": [68, true], "aps.04.09": [65, true], "aps.04.10": [65, true], "aps.04.11": [61, true], "aps.04.12": [65, true], "aps.04.13": [63, true], "aps.05.00": [58, true], "aps.06.00": [67, true], "aps.06.01": [66, true], "aps.06.02": [64, true], "aps.06.03": [60, true], "aps.06.04": [67, true], "aps.06.05": [70, true], "aps.06.06": [67, true], "aps.06.07": [69, true], "aps.06.08": [66, true], "aps.06.09": [63, true], "aps.07.00": [59, true], "aps.07.01": [63, true], "aps.07.02": [59, true], "aps.08.00": [3, true], "aps.08.01": [57, true], "aps.08.02": [63, true], "aps.08.03": [63, true], "aps.08.04": [65, true], "aps.09.00": [59, true], "aps.09.01": [59, true], "aps.09.02": [63, true], "aps.09.03": [53, true], "aps.09.04": [55, true], "aps.09.05": [56, true], "aps.09.06": [48, true], "aps.10.00": [61, true], "aps.10.01": [62, true], "aps.10.02": [64, true], "aps.10.03": [66, true], "aps.10.04": [62, true], "aps.11.00": [64, true], "aps.11.01": [60, true], "aps.11.02": [62, true], "aps.11.03": [53, true], "aps.12.00": [59, true], "aps.12.01": [71, true], "aps.12.02": [68, true], "aps.12.03": [73, true], "aps.12.04": [70, true], "aps.12.05": [75, true], "aps.12.06": [75, true], "aps.12.07": [65, true], "aps.12.08": [67, true], "aps.12.09": [72, true], "aps.12.10": [73, true], "aps.12.11": [72, true], "aps.12.12": [69, true], "aps.12.13": [72, true], "aps.12.14": [68, true], "aps.12.15": [68, true], "aps.12.16": [67, true], "aps.12.17": [69, true], "aps.12.18": [71, true], "aps.13.00": [9, false], "aps.14.00": [71, true], "aps.14.01": [71, true], "aps.14.02": [71, true], "aps.14.03": [71, true], "aps.14.04": [71, true], "aps.14.05": [71, true], "aps.14.06": [71, true], "aps.14.07": [71, true], "aps.14.08": [71, true], "aps.14.09": [71, true], "aps.14.10": [71, true], "aps.14.11": [71, true], "aps.14.12": [71, true], "aps.14.13": [71, true], "aps.14.14": [71, true], "aps.14.15": [71, true], "aps.14.16": [71, true], "aps.14.17": [71, true], "aps.14.18": [71, true], "aps.14.19": [71, true], "aps.14.20": [71, true], "aps.14.21": [71, true], "aps.14.22": [71, true], "aps.14.23": [71, true], "aps.14.24": [71, true], "aps.14.25": [71, true], "aps.14.26": [71, true], "aps.14.27": [71, true], "aps.14.28": [71, true], "aps.14.29": [71, true], "aps.14.30": [71, true], "aps.14.31": [71, true], "aps.14.32": [71, true], "aps.14.33": [71, true], "aps.14.34": [71, true], "aps.14.35": [71, true], "aps.14.36": [71, true], "aps.14.37": [71, true], "aps.14.38": [71, true], "aps.14.39": [71, true], "aps.15.00": [67, true], "aps.15.01": [68, true], "aps.15.02": [69, true], "aps.15.03": [69, true], "aps.15.04": [64, true], "aps.15.05": [68, true], "aps.15.06": [66, true], "aps.15.07": [68, true], "aps.15.08": [66, true], "aps.15.09": [66, true], "aps.15.10": [65, true], "aps.15.11": [60, true], "aps.15.12": [66, true], "aps.15.13": [67, true], "aps.15.14": [68, true], "aps.15.15": [69, true], "aps.15.16": [67, true], "aps.15.17": [67, true], "aps.15.18": [71, true], "aps.15.19": [69, true], "aps.15.20": [71, true], "aps.15.21": [67, true], "aps.15.22": [58, true], "aps.15.23": [61, true], "aps.15.24": [54, true], "aps.15.25": [63, true], "aps.15.26": [66, true], "aps.15.27": [65, true], "aps.15.28": [61, true], "aps.15.29": [55, true], "aps.15.30": [62, true]}}, "CHA": {"total": 3829, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [59, true], "fun1.2": [64, true], "fun1.3": [70, true], "fun1.4": [86, true], "fun1.5": [109, true], "fun2.1": [62, true], "fun2.2": [76, true], "fun2.3": [103, true], "fun2.4": [123, true], "fun2.5": [129, true], "fun3.1": [60, true], "fun3.2": [59, true], "fun3.3": [76, true], "fun3.4": [87, true], "fun3.5": [107, true], "fun4.1": [56, true], "fun4.2": [57, true], "fun4.3": [72, true], "fun4.4": [82, true], "fun4.5": [97, true], "fun5.1": [52, true], "fun5.2": [53, true], "fun5.3": [56, true], "fun5.4": [57, true], "fun5.5": [58, true], "fun6.1": [48, true], "fun6.2": [49, true], "fun6.3": [50, true], "fun6.4": [51, true], "fun6.5": [52, true], "fun7.1": [9, false], "fun7.2": [48, false], "fun7.3": [9, false], "fun7.4": [7, false], "fun7.5": [15, false], "fun8.1": [63, true], "fun8.2": [66, true], "fun8.3": [68, true], "fun8.4": [65, true], "fun8.5": [70, true], "fun9.1": [64, true], "fun9.2": [68, true], "fun9.3": [67, true], "fun9.4": [67, true], "fun9.5": [71, true]}}}, {"label": "pure.rational.derived3.credit", "spec": ["pure", "rational", "derived3", "credit"], "APS": {"total": 7530, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [4, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [23, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [11, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [10, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [11, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [6, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [52, true], "aps.15.04": [53, true], "aps.15.05": [52, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [52, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [52, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [42, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [6, false], "fun7.2": [8, false], "fun7.3": [10, false], "fun7.4": [12, false], "fun7.5": [14, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.rational.derived3.safe", "spec": ["pure", "rational", "derived3", "safe"], "APS": {"total": 3420, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [50, true], "aps.02.01": [12, true], "aps.02.02": [27, true], "aps.02.03": [51, true], "aps.02.04": [25, true], "aps.02.05": [22, true], "aps.02.06": [52, true], "aps.02.07": [19, true], "aps.02.08": [21, true], "aps.02.09": [23, true], "aps.03.00": [39, true], "aps.03.01": [56, true], "aps.03.02": [21, true], "aps.04.00": [14, true], "aps.04.01": [16, true], "aps.04.02": [48, true], "aps.04.03": [21, true], "aps.04.04": [21, true], "aps.04.05": [12, true], "aps.04.06": [15, true], "aps.04.07": [16, true], "aps.04.08": [17, true], "aps.04.09": [17, true], "aps.04.10": [16, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [16, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [12, true], "aps.06.06": [13, true], "aps.06.07": [14, true], "aps.06.08": [14, true], "aps.06.09": [14, true], "aps.07.00": [12, true], "aps.07.01": [13, true], "aps.07.02": [15, true], "aps.08.00": [8, true], "aps.08.01": [9, true], "aps.08.02": [10, true], "aps.08.03": [15, true], "aps.08.04": [12, true], "aps.09.00": [27, true], "aps.09.01": [12, true], "aps.09.02": [14, true], "aps.09.03": [15, true], "aps.09.04": [19, true], "aps.09.05": [22, true], "aps.09.06": [24, true], "aps.10.00": [8, true], "aps.10.01": [45, true], "aps.10.02": [14, true], "aps.10.03": [37, true], "aps.10.04": [52, true], "aps.11.00": [11, true], "aps.11.01": [12, true], "aps.11.02": [13, true], "aps.11.03": [14, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [9, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [31, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [33, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [33, true], "aps.15.09": [33, true], "aps.15.10": [33, true], "aps.15.11": [33, true], "aps.15.12": [33, true], "aps.15.13": [33, true], "aps.15.14": [34, true], "aps.15.15": [33, true], "aps.15.16": [33, true], "aps.15.17": [34, true], "aps.15.18": [33, true], "aps.15.19": [32, true], "aps.15.20": [32, true], "aps.15.21": [34, true], "aps.15.22": [36, true], "aps.15.23": [38, true], "aps.15.24": [38, true], "aps.15.25": [39, true], "aps.15.26": [38, true], "aps.15.27": [39, true], "aps.15.28": [39, true], "aps.15.29": [40, true], "aps.15.30": [38, true]}}, "CHA": {"total": 3505, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [7, true], "fun1.2": [32, true], "fun1.3": [30, true], "fun1.4": [51, true], "fun1.5": [70, true], "fun2.1": [12, true], "fun2.2": [29, true], "fun2.3": [37, true], "fun2.4": [54, true], "fun2.5": [60, true], "fun3.1": [81, true], "fun3.2": [89, true], "fun3.3": [105, true], "fun3.4": [112, true], "fun3.5": [144, true], "fun4.1": [89, true], "fun4.2": [93, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [74, true], "fun6.2": [88, true], "fun6.3": [82, true], "fun6.4": [88, true], "fun6.5": [88, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [12, false], "fun7.4": [15, false], "fun7.5": [17, false], "fun8.1": [13, true], "fun8.2": [12, true], "fun8.3": [13, true], "fun8.4": [16, true], "fun8.5": [17, true], "fun9.1": [8, true], "fun9.2": [10, true], "fun9.3": [18, true], "fun9.4": [19, true], "fun9.5": [18, true]}}}, {"label": "pure.sqrt.start.credit", "spec": ["pure", "sqrt", "start", "credit"], "APS": {"total": 7680, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [10, false], "fun7.3": [8, false], "fun7.4": [49, false], "fun7.5": [14, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.sqrt.start.safe", "spec": ["pure", "sqrt", "start", "safe"], "APS": {"total": 12236, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [85, true], "aps.02.00": [54, true], "aps.02.01": [51, true], "aps.02.02": [53, true], "aps.02.03": [50, true], "aps.02.04": [50, true], "aps.02.05": [50, true], "aps.02.06": [48, true], "aps.02.07": [48, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [83, true], "aps.04.01": [83, true], "aps.04.02": [78, true], "aps.04.03": [79, true], "aps.04.04": [81, true], "aps.04.05": [78, true], "aps.04.06": [82, true], "aps.04.07": [65, true], "aps.04.08": [82, true], "aps.04.09": [87, true], "aps.04.10": [79, true], "aps.04.11": [80, true], "aps.04.12": [82, true], "aps.04.13": [53, true], "aps.05.00": [69, true], "aps.06.00": [80, true], "aps.06.01": [83, true], "aps.06.02": [81, true], "aps.06.03": [81, true], "aps.06.04": [83, true], "aps.06.05": [77, true], "aps.06.06": [74, true], "aps.06.07": [83, true], "aps.06.08": [77, true], "aps.06.09": [80, true], "aps.07.00": [78, true], "aps.07.01": [72, true], "aps.07.02": [82, true], "aps.08.00": [3, true], "aps.08.01": [79, true], "aps.08.02": [69, true], "aps.08.03": [75, true], "aps.08.04": [76, true], "aps.09.00": [77, true], "aps.09.01": [77, true], "aps.09.02": [81, true], "aps.09.03": [82, true], "aps.09.04": [62, true], "aps.09.05": [57, true], "aps.09.06": [68, true], "aps.10.00": [79, true], "aps.10.01": [82, true], "aps.10.02": [74, true], "aps.10.03": [83, true], "aps.10.04": [82, true], "aps.11.00": [82, true], "aps.11.01": [81, true], "aps.11.02": [64, true], "aps.11.03": [78, true], "aps.12.00": [89, true], "aps.12.01": [86, true], "aps.12.02": [94, true], "aps.12.03": [87, true], "aps.12.04": [87, true], "aps.12.05": [76, true], "aps.12.06": [90, true], "aps.12.07": [79, true], "aps.12.08": [83, true], "aps.12.09": [91, true], "aps.12.10": [89, true], "aps.12.11": [90, true], "aps.12.12": [78, true], "aps.12.13": [77, true], "aps.12.14": [91, true], "aps.12.15": [86, true], "aps.12.16": [87, true], "aps.12.17": [93, true], "aps.12.18": [84, true], "aps.13.00": [10, false], "aps.14.00": [92, true], "aps.14.01": [92, true], "aps.14.02": [92, true], "aps.14.03": [92, true], "aps.14.04": [92, true], "aps.14.05": [92, true], "aps.14.06": [92, true], "aps.14.07": [92, true], "aps.14.08": [92, true], "aps.14.09": [92, true], "aps.14.10": [92, true], "aps.14.11": [92, true], "aps.14.12": [92, true], "aps.14.13": [92, true], "aps.14.14": [92, true], "aps.14.15": [92, true], "aps.14.16": [92, true], "aps.14.17": [92, true], "aps.14.18": [92, true], "aps.14.19": [92, true], "aps.14.20": [92, true], "aps.14.21": [92, true], "aps.14.22": [92, true], "aps.14.23": [92, true], "aps.14.24": [92, true], "aps.14.25": [92, true], "aps.14.26": [92, true], "aps.14.27": [92, true], "aps.14.28": [92, true], "aps.14.29": [92, true], "aps.14.30": [92, true], "aps.14.31": [92, true], "aps.14.32": [92, true], "aps.14.33": [92, true], "aps.14.34": [92, true], "aps.14.35": [92, true], "aps.14.36": [92, true], "aps.14.37": [92, true], "aps.14.38": [92, true], "aps.14.39": [92, true], "aps.15.00": [83, true], "aps.15.01": [82, true], "aps.15.02": [79, true], "aps.15.03": [78, true], "aps.15.04": [78, true], "aps.15.05": [79, true], "aps.15.06": [84, true], "aps.15.07": [58, true], "aps.15.08": [49, true], "aps.15.09": [79, true], "aps.15.10": [84, true], "aps.15.11": [75, true], "aps.15.12": [74, true], "aps.15.13": [77, true], "aps.15.14": [84, true], "aps.15.15": [78, true], "aps.15.16": [80, true], "aps.15.17": [77, true], "aps.15.18": [72, true], "aps.15.19": [62, true], "aps.15.20": [76, true], "aps.15.21": [73, true], "aps.15.22": [78, true], "aps.15.23": [71, true], "aps.15.24": [78, true], "aps.15.25": [68, true], "aps.15.26": [67, true], "aps.15.27": [63, true], "aps.15.28": [70, true], "aps.15.29": [66, true], "aps.15.30": [64, true]}}, "CHA": {"total": 4395, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [77, true], "fun1.2": [80, true], "fun1.3": [58, true], "fun1.4": [111, true], "fun1.5": [141, true], "fun2.1": [72, true], "fun2.2": [100, true], "fun2.3": [118, true], "fun2.4": [136, true], "fun2.5": [145, true], "fun3.1": [77, true], "fun3.2": [77, true], "fun3.3": [97, true], "fun3.4": [113, true], "fun3.5": [140, true], "fun4.1": [69, true], "fun4.2": [71, true], "fun4.3": [89, true], "fun4.4": [100, true], "fun4.5": [117, true], "fun5.1": [57, true], "fun5.2": [62, true], "fun5.3": [67, true], "fun5.4": [69, true], "fun5.5": [70, true], "fun6.1": [50, true], "fun6.2": [57, true], "fun6.3": [54, true], "fun6.4": [56, true], "fun6.5": [57, true], "fun7.1": [10, false], "fun7.2": [50, false], "fun7.3": [11, false], "fun7.4": [15, false], "fun7.5": [8, false], "fun8.1": [81, true], "fun8.2": [87, true], "fun8.3": [79, true], "fun8.4": [75, true], "fun8.5": [79, true], "fun9.1": [79, true], "fun9.2": [64, true], "fun9.3": [85, true], "fun9.4": [87, true], "fun9.5": [92, true]}}}, {"label": "pure.sqrt.bracket.step", "spec": ["pure", "sqrt", "bracket", "step"], "APS": {"total": 6480, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [33, true], "aps.02.00": [39, true], "aps.02.01": [41, true], "aps.02.02": [40, true], "aps.02.03": [46, true], "aps.02.04": [36, true], "aps.02.05": [36, true], "aps.02.06": [43, true], "aps.02.07": [41, true], "aps.02.08": [39, true], "aps.02.09": [39, true], "aps.03.00": [42, true], "aps.03.01": [42, true], "aps.03.02": [44, true], "aps.04.00": [43, true], "aps.04.01": [45, true], "aps.04.02": [46, true], "aps.04.03": [37, true], "aps.04.04": [41, true], "aps.04.05": [40, true], "aps.04.06": [40, true], "aps.04.07": [41, true], "aps.04.08": [40, true], "aps.04.09": [36, true], "aps.04.10": [44, true], "aps.04.11": [44, true], "aps.04.12": [41, true], "aps.04.13": [39, true], "aps.05.00": [36, true], "aps.06.00": [36, true], "aps.06.01": [36, true], "aps.06.02": [33, true], "aps.06.03": [35, true], "aps.06.04": [34, true], "aps.06.05": [40, true], "aps.06.06": [41, true], "aps.06.07": [39, true], "aps.06.08": [42, true], "aps.06.09": [46, true], "aps.07.00": [33, true], "aps.07.01": [36, true], "aps.07.02": [35, true], "aps.08.00": [3, true], "aps.08.01": [40, true], "aps.08.02": [31, true], "aps.08.03": [33, true], "aps.08.04": [31, true], "aps.09.00": [37, true], "aps.09.01": [38, true], "aps.09.02": [37, true], "aps.09.03": [35, true], "aps.09.04": [39, true], "aps.09.05": [37, true], "aps.09.06": [34, true], "aps.10.00": [34, true], "aps.10.01": [35, true], "aps.10.02": [37, true], "aps.10.03": [38, true], "aps.10.04": [39, true], "aps.11.00": [38, true], "aps.11.01": [44, true], "aps.11.02": [36, true], "aps.11.03": [32, true], "aps.12.00": [40, true], "aps.12.01": [45, true], "aps.12.02": [44, true], "aps.12.03": [41, true], "aps.12.04": [43, true], "aps.12.05": [45, true], "aps.12.06": [44, true], "aps.12.07": [38, true], "aps.12.08": [40, true], "aps.12.09": [39, true], "aps.12.10": [43, true], "aps.12.11": [36, true], "aps.12.12": [42, true], "aps.12.13": [39, true], "aps.12.14": [43, true], "aps.12.15": [39, true], "aps.12.16": [39, true], "aps.12.17": [39, true], "aps.12.18": [38, true], "aps.13.00": [11, false], "aps.14.00": [42, true], "aps.14.01": [42, true], "aps.14.02": [42, true], "aps.14.03": [42, true], "aps.14.04": [42, true], "aps.14.05": [42, true], "aps.14.06": [42, true], "aps.14.07": [42, true], "aps.14.08": [42, true], "aps.14.09": [42, true], "aps.14.10": [42, true], "aps.14.11": [42, true], "aps.14.12": [42, true], "aps.14.13": [42, true], "aps.14.14": [42, true], "aps.14.15": [42, true], "aps.14.16": [42, true], "aps.14.17": [42, true], "aps.14.18": [42, true], "aps.14.19": [42, true], "aps.14.20": [42, true], "aps.14.21": [42, true], "aps.14.22": [42, true], "aps.14.23": [42, true], "aps.14.24": [42, true], "aps.14.25": [42, true], "aps.14.26": [42, true], "aps.14.27": [42, true], "aps.14.28": [42, true], "aps.14.29": [42, true], "aps.14.30": [42, true], "aps.14.31": [42, true], "aps.14.32": [42, true], "aps.14.33": [42, true], "aps.14.34": [42, true], "aps.14.35": [42, true], "aps.14.36": [42, true], "aps.14.37": [42, true], "aps.14.38": [42, true], "aps.14.39": [42, true], "aps.15.00": [38, true], "aps.15.01": [42, true], "aps.15.02": [35, true], "aps.15.03": [38, true], "aps.15.04": [39, true], "aps.15.05": [39, true], "aps.15.06": [43, true], "aps.15.07": [47, true], "aps.15.08": [40, true], "aps.15.09": [50, true], "aps.15.10": [49, true], "aps.15.11": [48, true], "aps.15.12": [51, true], "aps.15.13": [48, true], "aps.15.14": [49, true], "aps.15.15": [47, true], "aps.15.16": [46, true], "aps.15.17": [48, true], "aps.15.18": [46, true], "aps.15.19": [47, true], "aps.15.20": [49, true], "aps.15.21": [47, true], "aps.15.22": [49, true], "aps.15.23": [49, true], "aps.15.24": [48, true], "aps.15.25": [48, true], "aps.15.26": [53, true], "aps.15.27": [50, true], "aps.15.28": [48, true], "aps.15.29": [53, true], "aps.15.30": [51, true]}}, "CHA": {"total": 4017, "solved": 40, "n": 45, "over": 1, "per": {"fun1.1": [35, true], "fun1.2": [37, true], "fun1.3": [38, true], "fun1.4": [59, true], "fun1.5": [98, true], "fun2.1": [37, true], "fun2.2": [77, true], "fun2.3": [97, true], "fun2.4": [138, true], "fun2.5": [159, true], "fun3.1": [84, true], "fun3.2": [86, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [143, true], "fun4.1": [74, true], "fun4.2": [78, true], "fun4.3": [94, true], "fun4.4": [105, true], "fun4.5": [108, true], "fun5.1": [82, true], "fun5.2": [90, true], "fun5.3": [94, true], "fun5.4": [94, true], "fun5.5": [97, true], "fun6.1": [69, true], "fun6.2": [65, true], "fun6.3": [68, true], "fun6.4": [69, true], "fun6.5": [69, true], "fun7.1": [11, false], "fun7.2": [25, false], "fun7.3": [8, false], "fun7.4": [7, false], "fun7.5": [16, false], "fun8.1": [38, true], "fun8.2": [42, true], "fun8.3": [48, true], "fun8.4": [55, true], "fun8.5": [58, true], "fun9.1": [33, true], "fun9.2": [35, true], "fun9.3": [41, true], "fun9.4": [44, true], "fun9.5": [42, true]}}}, {"label": "pure.sqrt.bracket.none", "spec": ["pure", "sqrt", "bracket", "none"], "APS": {"total": 10345, "solved": 132, "n": 154, "over": 2, "per": {"aps.01.00": [33, true], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [200, false], "aps.03.01": [200, false], "aps.03.02": [200, false], "aps.04.00": [39, true], "aps.04.01": [82, true], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [42, true], "aps.04.06": [63, true], "aps.04.07": [188, true], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [176, true], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [37, true], "aps.06.00": [36, true], "aps.06.01": [40, true], "aps.06.02": [40, true], "aps.06.03": [41, true], "aps.06.04": [36, true], "aps.06.05": [42, true], "aps.06.06": [44, true], "aps.06.07": [45, true], "aps.06.08": [44, true], "aps.06.09": [46, true], "aps.07.00": [33, true], "aps.07.01": [36, true], "aps.07.02": [35, true], "aps.08.00": [3, true], "aps.08.01": [40, true], "aps.08.02": [31, true], "aps.08.03": [33, true], "aps.08.04": [31, true], "aps.09.00": [39, true], "aps.09.01": [38, true], "aps.09.02": [37, true], "aps.09.03": [35, true], "aps.09.04": [39, true], "aps.09.05": [37, true], "aps.09.06": [34, true], "aps.10.00": [34, true], "aps.10.01": [35, true], "aps.10.02": [37, true], "aps.10.03": [40, true], "aps.10.04": [73, true], "aps.11.00": [39, true], "aps.11.01": [42, true], "aps.11.02": [36, true], "aps.11.03": [32, true], "aps.12.00": [40, true], "aps.12.01": [45, true], "aps.12.02": [44, true], "aps.12.03": [48, true], "aps.12.04": [45, true], "aps.12.05": [43, true], "aps.12.06": [46, true], "aps.12.07": [45, true], "aps.12.08": [44, true], "aps.12.09": [47, true], "aps.12.10": [41, true], "aps.12.11": [40, true], "aps.12.12": [41, true], "aps.12.13": [41, true], "aps.12.14": [47, true], "aps.12.15": [41, true], "aps.12.16": [39, true], "aps.12.17": [41, true], "aps.12.18": [39, true], "aps.13.00": [200, false], "aps.14.00": [45, true], "aps.14.01": [45, true], "aps.14.02": [45, true], "aps.14.03": [45, true], "aps.14.04": [45, true], "aps.14.05": [45, true], "aps.14.06": [45, true], "aps.14.07": [45, true], "aps.14.08": [45, true], "aps.14.09": [45, true], "aps.14.10": [45, true], "aps.14.11": [45, true], "aps.14.12": [45, true], "aps.14.13": [45, true], "aps.14.14": [45, true], "aps.14.15": [45, true], "aps.14.16": [45, true], "aps.14.17": [45, true], "aps.14.18": [45, true], "aps.14.19": [45, true], "aps.14.20": [45, true], "aps.14.21": [45, true], "aps.14.22": [45, true], "aps.14.23": [45, true], "aps.14.24": [45, true], "aps.14.25": [45, true], "aps.14.26": [45, true], "aps.14.27": [45, true], "aps.14.28": [45, true], "aps.14.29": [45, true], "aps.14.30": [45, true], "aps.14.31": [45, true], "aps.14.32": [45, true], "aps.14.33": [45, true], "aps.14.34": [45, true], "aps.14.35": [45, true], "aps.14.36": [45, true], "aps.14.37": [45, true], "aps.14.38": [45, true], "aps.14.39": [45, true], "aps.15.00": [39, true], "aps.15.01": [41, true], "aps.15.02": [37, true], "aps.15.03": [38, true], "aps.15.04": [40, true], "aps.15.05": [39, true], "aps.15.06": [34, true], "aps.15.07": [40, true], "aps.15.08": [40, true], "aps.15.09": [44, true], "aps.15.10": [40, true], "aps.15.11": [41, true], "aps.15.12": [41, true], "aps.15.13": [43, true], "aps.15.14": [43, true], "aps.15.15": [43, true], "aps.15.16": [44, true], "aps.15.17": [46, true], "aps.15.18": [46, true], "aps.15.19": [45, true], "aps.15.20": [44, true], "aps.15.21": [51, true], "aps.15.22": [49, true], "aps.15.23": [54, true], "aps.15.24": [53, true], "aps.15.25": [52, true], "aps.15.26": [51, true], "aps.15.27": [51, true], "aps.15.28": [52, true], "aps.15.29": [53, true], "aps.15.30": [51, true]}}, "CHA": {"total": 7310, "solved": 12, "n": 45, "over": 2, "per": {"fun1.1": [35, true], "fun1.2": [37, true], "fun1.3": [37, true], "fun1.4": [155, true], "fun1.5": [200, false], "fun2.1": [37, true], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [58, true], "fun7.3": [8, false], "fun7.4": [25, true], "fun7.5": [200, false], "fun8.1": [174, true], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [35, true], "fun9.2": [35, true], "fun9.3": [40, true], "fun9.4": [200, false], "fun9.5": [42, true]}}}, {"label": "pure.sqrt.bracket.bracket", "spec": ["pure", "sqrt", "bracket", "bracket"], "APS": {"total": 6536, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [39, true], "aps.02.00": [38, true], "aps.02.01": [40, true], "aps.02.02": [38, true], "aps.02.03": [41, true], "aps.02.04": [41, true], "aps.02.05": [34, true], "aps.02.06": [41, true], "aps.02.07": [39, true], "aps.02.08": [41, true], "aps.02.09": [43, true], "aps.03.00": [43, true], "aps.03.01": [44, true], "aps.03.02": [44, true], "aps.04.00": [40, true], "aps.04.01": [44, true], "aps.04.02": [40, true], "aps.04.03": [41, true], "aps.04.04": [39, true], "aps.04.05": [40, true], "aps.04.06": [40, true], "aps.04.07": [40, true], "aps.04.08": [44, true], "aps.04.09": [42, true], "aps.04.10": [38, true], "aps.04.11": [37, true], "aps.04.12": [41, true], "aps.04.13": [43, true], "aps.05.00": [35, true], "aps.06.00": [39, true], "aps.06.01": [33, true], "aps.06.02": [41, true], "aps.06.03": [35, true], "aps.06.04": [36, true], "aps.06.05": [40, true], "aps.06.06": [42, true], "aps.06.07": [39, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [34, true], "aps.07.01": [39, true], "aps.07.02": [39, true], "aps.08.00": [3, true], "aps.08.01": [39, true], "aps.08.02": [38, true], "aps.08.03": [34, true], "aps.08.04": [40, true], "aps.09.00": [33, true], "aps.09.01": [33, true], "aps.09.02": [37, true], "aps.09.03": [36, true], "aps.09.04": [40, true], "aps.09.05": [37, true], "aps.09.06": [35, true], "aps.10.00": [35, true], "aps.10.01": [33, true], "aps.10.02": [37, true], "aps.10.03": [40, true], "aps.10.04": [38, true], "aps.11.00": [38, true], "aps.11.01": [42, true], "aps.11.02": [40, true], "aps.11.03": [41, true], "aps.12.00": [37, true], "aps.12.01": [45, true], "aps.12.02": [40, true], "aps.12.03": [46, true], "aps.12.04": [45, true], "aps.12.05": [48, true], "aps.12.06": [45, true], "aps.12.07": [47, true], "aps.12.08": [47, true], "aps.12.09": [44, true], "aps.12.10": [42, true], "aps.12.11": [39, true], "aps.12.12": [41, true], "aps.12.13": [26, true], "aps.12.14": [45, true], "aps.12.15": [43, true], "aps.12.16": [41, true], "aps.12.17": [38, true], "aps.12.18": [43, true], "aps.13.00": [9, false], "aps.14.00": [43, true], "aps.14.01": [43, true], "aps.14.02": [44, true], "aps.14.03": [43, true], "aps.14.04": [44, true], "aps.14.05": [44, true], "aps.14.06": [44, true], "aps.14.07": [43, true], "aps.14.08": [44, true], "aps.14.09": [44, true], "aps.14.10": [43, true], "aps.14.11": [44, true], "aps.14.12": [44, true], "aps.14.13": [44, true], "aps.14.14": [44, true], "aps.14.15": [43, true], "aps.14.16": [44, true], "aps.14.17": [44, true], "aps.14.18": [44, true], "aps.14.19": [44, true], "aps.14.20": [44, true], "aps.14.21": [43, true], "aps.14.22": [44, true], "aps.14.23": [44, true], "aps.14.24": [44, true], "aps.14.25": [44, true], "aps.14.26": [43, true], "aps.14.27": [44, true], "aps.14.28": [44, true], "aps.14.29": [44, true], "aps.14.30": [44, true], "aps.14.31": [43, true], "aps.14.32": [44, true], "aps.14.33": [44, true], "aps.14.34": [44, true], "aps.14.35": [44, true], "aps.14.36": [44, true], "aps.14.37": [44, true], "aps.14.38": [44, true], "aps.14.39": [44, true], "aps.15.00": [38, true], "aps.15.01": [38, true], "aps.15.02": [40, true], "aps.15.03": [37, true], "aps.15.04": [38, true], "aps.15.05": [39, true], "aps.15.06": [38, true], "aps.15.07": [37, true], "aps.15.08": [40, true], "aps.15.09": [40, true], "aps.15.10": [43, true], "aps.15.11": [43, true], "aps.15.12": [40, true], "aps.15.13": [41, true], "aps.15.14": [43, true], "aps.15.15": [39, true], "aps.15.16": [41, true], "aps.15.17": [43, true], "aps.15.18": [43, true], "aps.15.19": [42, true], "aps.15.20": [41, true], "aps.15.21": [51, true], "aps.15.22": [49, true], "aps.15.23": [52, true], "aps.15.24": [53, true], "aps.15.25": [52, true], "aps.15.26": [53, true], "aps.15.27": [51, true], "aps.15.28": [52, true], "aps.15.29": [53, true], "aps.15.30": [51, true]}}, "CHA": {"total": 3387, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [38, true], "fun1.2": [42, true], "fun1.3": [42, true], "fun1.4": [54, true], "fun1.5": [75, true], "fun2.1": [37, true], "fun2.2": [64, true], "fun2.3": [78, true], "fun2.4": [105, true], "fun2.5": [120, true], "fun3.1": [53, true], "fun3.2": [54, true], "fun3.3": [69, true], "fun3.4": [73, true], "fun3.5": [86, true], "fun4.1": [54, true], "fun4.2": [63, true], "fun4.3": [71, true], "fun4.4": [81, true], "fun4.5": [92, true], "fun5.1": [63, true], "fun5.2": [64, true], "fun5.3": [66, true], "fun5.4": [71, true], "fun5.5": [72, true], "fun6.1": [63, true], "fun6.2": [56, true], "fun6.3": [55, true], "fun6.4": [57, true], "fun6.5": [61, true], "fun7.1": [8, false], "fun7.2": [4, false], "fun7.3": [8, false], "fun7.4": [6, false], "fun7.5": [14, false], "fun8.1": [34, true], "fun8.2": [40, true], "fun8.3": [46, true], "fun8.4": [48, true], "fun8.5": [48, true], "fun9.1": [33, true], "fun9.2": [35, true], "fun9.3": [40, true], "fun9.4": [42, true], "fun9.5": [42, true]}}}, {"label": "pure.rational.derived3.project", "spec": ["pure", "rational", "derived3", "project"], "APS": {"total": 3356, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [11, true], "aps.02.01": [37, true], "aps.02.02": [10, true], "aps.02.03": [19, true], "aps.02.04": [9, true], "aps.02.05": [12, true], "aps.02.06": [29, true], "aps.02.07": [12, true], "aps.02.08": [11, true], "aps.02.09": [10, true], "aps.03.00": [25, true], "aps.03.01": [54, true], "aps.03.02": [18, true], "aps.04.00": [46, true], "aps.04.01": [48, true], "aps.04.02": [17, true], "aps.04.03": [17, true], "aps.04.04": [21, true], "aps.04.05": [13, true], "aps.04.06": [14, true], "aps.04.07": [17, true], "aps.04.08": [15, true], "aps.04.09": [17, true], "aps.04.10": [18, true], "aps.04.11": [20, true], "aps.04.12": [16, true], "aps.04.13": [18, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [12, true], "aps.06.06": [13, true], "aps.06.07": [14, true], "aps.06.08": [14, true], "aps.06.09": [14, true], "aps.07.00": [12, true], "aps.07.01": [13, true], "aps.07.02": [15, true], "aps.08.00": [8, true], "aps.08.01": [9, true], "aps.08.02": [10, true], "aps.08.03": [42, true], "aps.08.04": [12, true], "aps.09.00": [27, true], "aps.09.01": [12, true], "aps.09.02": [14, true], "aps.09.03": [15, true], "aps.09.04": [19, true], "aps.09.05": [22, true], "aps.09.06": [24, true], "aps.10.00": [8, true], "aps.10.01": [45, true], "aps.10.02": [46, true], "aps.10.03": [48, true], "aps.10.04": [37, true], "aps.11.00": [10, true], "aps.11.01": [12, true], "aps.11.02": [13, true], "aps.11.03": [14, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [11, true], "aps.12.09": [10, true], "aps.12.10": [9, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [51, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [31, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [33, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [33, true], "aps.15.09": [33, true], "aps.15.10": [33, true], "aps.15.11": [33, true], "aps.15.12": [33, true], "aps.15.13": [33, true], "aps.15.14": [34, true], "aps.15.15": [33, true], "aps.15.16": [33, true], "aps.15.17": [34, true], "aps.15.18": [33, true], "aps.15.19": [32, true], "aps.15.20": [32, true], "aps.15.21": [34, true], "aps.15.22": [37, true], "aps.15.23": [39, true], "aps.15.24": [39, true], "aps.15.25": [39, true], "aps.15.26": [40, true], "aps.15.27": [41, true], "aps.15.28": [40, true], "aps.15.29": [40, true], "aps.15.30": [38, true]}}, "CHA": {"total": 3467, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [7, true], "fun1.2": [21, true], "fun1.3": [28, true], "fun1.4": [30, true], "fun1.5": [59, true], "fun2.1": [9, true], "fun2.2": [33, true], "fun2.3": [46, true], "fun2.4": [66, true], "fun2.5": [72, true], "fun3.1": [54, true], "fun3.2": [79, true], "fun3.3": [89, true], "fun3.4": [105, true], "fun3.5": [115, true], "fun4.1": [89, true], "fun4.2": [93, true], "fun4.3": [112, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [31, false], "fun7.3": [53, false], "fun7.4": [57, false], "fun7.5": [34, false], "fun8.1": [10, true], "fun8.2": [12, true], "fun8.3": [13, true], "fun8.4": [14, true], "fun8.5": [15, true], "fun9.1": [8, true], "fun9.2": [10, true], "fun9.3": [22, true], "fun9.4": [38, true], "fun9.5": [28, true]}}}, {"label": "pure.sqrt.bracket.both", "spec": ["pure", "sqrt", "bracket", "both"], "APS": {"total": 6466, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [39, true], "aps.02.00": [38, true], "aps.02.01": [40, true], "aps.02.02": [38, true], "aps.02.03": [40, true], "aps.02.04": [37, true], "aps.02.05": [41, true], "aps.02.06": [42, true], "aps.02.07": [43, true], "aps.02.08": [42, true], "aps.02.09": [43, true], "aps.03.00": [42, true], "aps.03.01": [40, true], "aps.03.02": [42, true], "aps.04.00": [40, true], "aps.04.01": [43, true], "aps.04.02": [40, true], "aps.04.03": [41, true], "aps.04.04": [39, true], "aps.04.05": [40, true], "aps.04.06": [40, true], "aps.04.07": [40, true], "aps.04.08": [42, true], "aps.04.09": [41, true], "aps.04.10": [40, true], "aps.04.11": [37, true], "aps.04.12": [41, true], "aps.04.13": [42, true], "aps.05.00": [37, true], "aps.06.00": [39, true], "aps.06.01": [33, true], "aps.06.02": [41, true], "aps.06.03": [35, true], "aps.06.04": [36, true], "aps.06.05": [40, true], "aps.06.06": [42, true], "aps.06.07": [39, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [34, true], "aps.07.01": [39, true], "aps.07.02": [39, true], "aps.08.00": [3, true], "aps.08.01": [39, true], "aps.08.02": [38, true], "aps.08.03": [34, true], "aps.08.04": [40, true], "aps.09.00": [33, true], "aps.09.01": [33, true], "aps.09.02": [37, true], "aps.09.03": [36, true], "aps.09.04": [40, true], "aps.09.05": [37, true], "aps.09.06": [35, true], "aps.10.00": [35, true], "aps.10.01": [33, true], "aps.10.02": [37, true], "aps.10.03": [40, true], "aps.10.04": [38, true], "aps.11.00": [40, true], "aps.11.01": [38, true], "aps.11.02": [40, true], "aps.11.03": [41, true], "aps.12.00": [37, true], "aps.12.01": [45, true], "aps.12.02": [40, true], "aps.12.03": [47, true], "aps.12.04": [43, true], "aps.12.05": [47, true], "aps.12.06": [44, true], "aps.12.07": [41, true], "aps.12.08": [45, true], "aps.12.09": [39, true], "aps.12.10": [42, true], "aps.12.11": [36, true], "aps.12.12": [41, true], "aps.12.13": [41, true], "aps.12.14": [44, true], "aps.12.15": [44, true], "aps.12.16": [43, true], "aps.12.17": [41, true], "aps.12.18": [42, true], "aps.13.00": [8, false], "aps.14.00": [42, true], "aps.14.01": [42, true], "aps.14.02": [39, true], "aps.14.03": [42, true], "aps.14.04": [39, true], "aps.14.05": [39, true], "aps.14.06": [39, true], "aps.14.07": [42, true], "aps.14.08": [39, true], "aps.14.09": [39, true], "aps.14.10": [42, true], "aps.14.11": [39, true], "aps.14.12": [42, true], "aps.14.13": [39, true], "aps.14.14": [39, true], "aps.14.15": [42, true], "aps.14.16": [39, true], "aps.14.17": [39, true], "aps.14.18": [39, true], "aps.14.19": [39, true], "aps.14.20": [42, true], "aps.14.21": [42, true], "aps.14.22": [39, true], "aps.14.23": [39, true], "aps.14.24": [39, true], "aps.14.25": [42, true], "aps.14.26": [42, true], "aps.14.27": [39, true], "aps.14.28": [39, true], "aps.14.29": [39, true], "aps.14.30": [39, true], "aps.14.31": [42, true], "aps.14.32": [39, true], "aps.14.33": [39, true], "aps.14.34": [39, true], "aps.14.35": [39, true], "aps.14.36": [42, true], "aps.14.37": [39, true], "aps.14.38": [42, true], "aps.14.39": [39, true], "aps.15.00": [39, true], "aps.15.01": [37, true], "aps.15.02": [39, true], "aps.15.03": [40, true], "aps.15.04": [39, true], "aps.15.05": [38, true], "aps.15.06": [41, true], "aps.15.07": [49, true], "aps.15.08": [44, true], "aps.15.09": [49, true], "aps.15.10": [48, true], "aps.15.11": [48, true], "aps.15.12": [46, true], "aps.15.13": [48, true], "aps.15.14": [48, true], "aps.15.15": [47, true], "aps.15.16": [48, true], "aps.15.17": [48, true], "aps.15.18": [46, true], "aps.15.19": [47, true], "aps.15.20": [49, true], "aps.15.21": [48, true], "aps.15.22": [49, true], "aps.15.23": [49, true], "aps.15.24": [48, true], "aps.15.25": [49, true], "aps.15.26": [52, true], "aps.15.27": [52, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [51, true]}}, "CHA": {"total": 3391, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [38, true], "fun1.2": [42, true], "fun1.3": [41, true], "fun1.4": [57, true], "fun1.5": [75, true], "fun2.1": [37, true], "fun2.2": [64, true], "fun2.3": [79, true], "fun2.4": [105, true], "fun2.5": [119, true], "fun3.1": [53, true], "fun3.2": [54, true], "fun3.3": [66, true], "fun3.4": [75, true], "fun3.5": [85, true], "fun4.1": [54, true], "fun4.2": [63, true], "fun4.3": [68, true], "fun4.4": [79, true], "fun4.5": [87, true], "fun5.1": [62, true], "fun5.2": [64, true], "fun5.3": [64, true], "fun5.4": [71, true], "fun5.5": [72, true], "fun6.1": [56, true], "fun6.2": [57, true], "fun6.3": [61, true], "fun6.4": [61, true], "fun6.5": [62, true], "fun7.1": [8, false], "fun7.2": [25, false], "fun7.3": [8, false], "fun7.4": [6, false], "fun7.5": [14, false], "fun8.1": [37, true], "fun8.2": [40, true], "fun8.3": [46, true], "fun8.4": [45, true], "fun8.5": [48, true], "fun9.1": [41, true], "fun9.2": [35, true], "fun9.3": [40, true], "fun9.4": [46, true], "fun9.5": [42, true]}}}, {"label": "pure.sqrt.bracket.safe", "spec": ["pure", "sqrt", "bracket", "safe"], "APS": {"total": 6480, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [33, true], "aps.02.00": [39, true], "aps.02.01": [41, true], "aps.02.02": [40, true], "aps.02.03": [46, true], "aps.02.04": [36, true], "aps.02.05": [36, true], "aps.02.06": [43, true], "aps.02.07": [41, true], "aps.02.08": [39, true], "aps.02.09": [39, true], "aps.03.00": [42, true], "aps.03.01": [42, true], "aps.03.02": [44, true], "aps.04.00": [43, true], "aps.04.01": [45, true], "aps.04.02": [46, true], "aps.04.03": [37, true], "aps.04.04": [41, true], "aps.04.05": [40, true], "aps.04.06": [40, true], "aps.04.07": [41, true], "aps.04.08": [40, true], "aps.04.09": [36, true], "aps.04.10": [44, true], "aps.04.11": [44, true], "aps.04.12": [41, true], "aps.04.13": [39, true], "aps.05.00": [36, true], "aps.06.00": [36, true], "aps.06.01": [36, true], "aps.06.02": [33, true], "aps.06.03": [35, true], "aps.06.04": [34, true], "aps.06.05": [40, true], "aps.06.06": [41, true], "aps.06.07": [39, true], "aps.06.08": [42, true], "aps.06.09": [46, true], "aps.07.00": [33, true], "aps.07.01": [36, true], "aps.07.02": [35, true], "aps.08.00": [3, true], "aps.08.01": [40, true], "aps.08.02": [31, true], "aps.08.03": [33, true], "aps.08.04": [31, true], "aps.09.00": [37, true], "aps.09.01": [38, true], "aps.09.02": [37, true], "aps.09.03": [35, true], "aps.09.04": [39, true], "aps.09.05": [37, true], "aps.09.06": [34, true], "aps.10.00": [34, true], "aps.10.01": [35, true], "aps.10.02": [37, true], "aps.10.03": [38, true], "aps.10.04": [39, true], "aps.11.00": [38, true], "aps.11.01": [44, true], "aps.11.02": [36, true], "aps.11.03": [32, true], "aps.12.00": [40, true], "aps.12.01": [45, true], "aps.12.02": [44, true], "aps.12.03": [41, true], "aps.12.04": [43, true], "aps.12.05": [45, true], "aps.12.06": [44, true], "aps.12.07": [38, true], "aps.12.08": [40, true], "aps.12.09": [39, true], "aps.12.10": [43, true], "aps.12.11": [36, true], "aps.12.12": [42, true], "aps.12.13": [39, true], "aps.12.14": [43, true], "aps.12.15": [39, true], "aps.12.16": [39, true], "aps.12.17": [39, true], "aps.12.18": [38, true], "aps.13.00": [11, false], "aps.14.00": [42, true], "aps.14.01": [42, true], "aps.14.02": [42, true], "aps.14.03": [42, true], "aps.14.04": [42, true], "aps.14.05": [42, true], "aps.14.06": [42, true], "aps.14.07": [42, true], "aps.14.08": [42, true], "aps.14.09": [42, true], "aps.14.10": [42, true], "aps.14.11": [42, true], "aps.14.12": [42, true], "aps.14.13": [42, true], "aps.14.14": [42, true], "aps.14.15": [42, true], "aps.14.16": [42, true], "aps.14.17": [42, true], "aps.14.18": [42, true], "aps.14.19": [42, true], "aps.14.20": [42, true], "aps.14.21": [42, true], "aps.14.22": [42, true], "aps.14.23": [42, true], "aps.14.24": [42, true], "aps.14.25": [42, true], "aps.14.26": [42, true], "aps.14.27": [42, true], "aps.14.28": [42, true], "aps.14.29": [42, true], "aps.14.30": [42, true], "aps.14.31": [42, true], "aps.14.32": [42, true], "aps.14.33": [42, true], "aps.14.34": [42, true], "aps.14.35": [42, true], "aps.14.36": [42, true], "aps.14.37": [42, true], "aps.14.38": [42, true], "aps.14.39": [42, true], "aps.15.00": [38, true], "aps.15.01": [42, true], "aps.15.02": [35, true], "aps.15.03": [38, true], "aps.15.04": [39, true], "aps.15.05": [39, true], "aps.15.06": [43, true], "aps.15.07": [47, true], "aps.15.08": [40, true], "aps.15.09": [50, true], "aps.15.10": [49, true], "aps.15.11": [48, true], "aps.15.12": [51, true], "aps.15.13": [48, true], "aps.15.14": [49, true], "aps.15.15": [47, true], "aps.15.16": [46, true], "aps.15.17": [48, true], "aps.15.18": [46, true], "aps.15.19": [47, true], "aps.15.20": [49, true], "aps.15.21": [47, true], "aps.15.22": [49, true], "aps.15.23": [49, true], "aps.15.24": [48, true], "aps.15.25": [48, true], "aps.15.26": [53, true], "aps.15.27": [50, true], "aps.15.28": [48, true], "aps.15.29": [53, true], "aps.15.30": [51, true]}}, "CHA": {"total": 3989, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [35, true], "fun1.2": [37, true], "fun1.3": [38, true], "fun1.4": [59, true], "fun1.5": [98, true], "fun2.1": [37, true], "fun2.2": [77, true], "fun2.3": [97, true], "fun2.4": [114, true], "fun2.5": [163, true], "fun3.1": [84, true], "fun3.2": [86, true], "fun3.3": [112, true], "fun3.4": [124, true], "fun3.5": [143, true], "fun4.1": [74, true], "fun4.2": [78, true], "fun4.3": [94, true], "fun4.4": [105, true], "fun4.5": [108, true], "fun5.1": [82, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [69, true], "fun6.2": [65, true], "fun6.3": [68, true], "fun6.4": [69, true], "fun6.5": [69, true], "fun7.1": [11, false], "fun7.2": [25, false], "fun7.3": [8, false], "fun7.4": [7, false], "fun7.5": [16, false], "fun8.1": [38, true], "fun8.2": [42, true], "fun8.3": [48, true], "fun8.4": [55, true], "fun8.5": [58, true], "fun9.1": [33, true], "fun9.2": [35, true], "fun9.3": [41, true], "fun9.4": [44, true], "fun9.5": [42, true]}}}, {"label": "pure.sqrt.bracket.project", "spec": ["pure", "sqrt", "bracket", "project"], "APS": {"total": 7796, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [33, true], "aps.02.00": [84, true], "aps.02.01": [82, true], "aps.02.02": [79, true], "aps.02.03": [90, true], "aps.02.04": [90, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [93, true], "aps.02.09": [93, true], "aps.03.00": [94, true], "aps.03.01": [94, true], "aps.03.02": [94, true], "aps.04.00": [39, true], "aps.04.01": [88, true], "aps.04.02": [89, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [42, true], "aps.04.06": [63, true], "aps.04.07": [74, true], "aps.04.08": [74, true], "aps.04.09": [74, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [88, true], "aps.04.13": [88, true], "aps.05.00": [37, true], "aps.06.00": [36, true], "aps.06.01": [40, true], "aps.06.02": [40, true], "aps.06.03": [41, true], "aps.06.04": [36, true], "aps.06.05": [42, true], "aps.06.06": [44, true], "aps.06.07": [45, true], "aps.06.08": [44, true], "aps.06.09": [46, true], "aps.07.00": [33, true], "aps.07.01": [36, true], "aps.07.02": [35, true], "aps.08.00": [3, true], "aps.08.01": [40, true], "aps.08.02": [31, true], "aps.08.03": [33, true], "aps.08.04": [31, true], "aps.09.00": [39, true], "aps.09.01": [38, true], "aps.09.02": [37, true], "aps.09.03": [35, true], "aps.09.04": [39, true], "aps.09.05": [37, true], "aps.09.06": [34, true], "aps.10.00": [34, true], "aps.10.01": [35, true], "aps.10.02": [37, true], "aps.10.03": [40, true], "aps.10.04": [78, true], "aps.11.00": [39, true], "aps.11.01": [42, true], "aps.11.02": [36, true], "aps.11.03": [32, true], "aps.12.00": [40, true], "aps.12.01": [45, true], "aps.12.02": [44, true], "aps.12.03": [48, true], "aps.12.04": [45, true], "aps.12.05": [43, true], "aps.12.06": [46, true], "aps.12.07": [45, true], "aps.12.08": [44, true], "aps.12.09": [47, true], "aps.12.10": [41, true], "aps.12.11": [40, true], "aps.12.12": [41, true], "aps.12.13": [41, true], "aps.12.14": [47, true], "aps.12.15": [41, true], "aps.12.16": [39, true], "aps.12.17": [41, true], "aps.12.18": [39, true], "aps.13.00": [52, false], "aps.14.00": [45, true], "aps.14.01": [45, true], "aps.14.02": [45, true], "aps.14.03": [45, true], "aps.14.04": [45, true], "aps.14.05": [45, true], "aps.14.06": [45, true], "aps.14.07": [45, true], "aps.14.08": [45, true], "aps.14.09": [45, true], "aps.14.10": [45, true], "aps.14.11": [45, true], "aps.14.12": [45, true], "aps.14.13": [45, true], "aps.14.14": [45, true], "aps.14.15": [45, true], "aps.14.16": [45, true], "aps.14.17": [45, true], "aps.14.18": [45, true], "aps.14.19": [45, true], "aps.14.20": [45, true], "aps.14.21": [45, true], "aps.14.22": [45, true], "aps.14.23": [45, true], "aps.14.24": [45, true], "aps.14.25": [45, true], "aps.14.26": [45, true], "aps.14.27": [45, true], "aps.14.28": [45, true], "aps.14.29": [45, true], "aps.14.30": [45, true], "aps.14.31": [45, true], "aps.14.32": [45, true], "aps.14.33": [45, true], "aps.14.34": [45, true], "aps.14.35": [45, true], "aps.14.36": [45, true], "aps.14.37": [45, true], "aps.14.38": [45, true], "aps.14.39": [45, true], "aps.15.00": [39, true], "aps.15.01": [41, true], "aps.15.02": [37, true], "aps.15.03": [38, true], "aps.15.04": [40, true], "aps.15.05": [39, true], "aps.15.06": [34, true], "aps.15.07": [40, true], "aps.15.08": [40, true], "aps.15.09": [44, true], "aps.15.10": [40, true], "aps.15.11": [41, true], "aps.15.12": [41, true], "aps.15.13": [43, true], "aps.15.14": [43, true], "aps.15.15": [43, true], "aps.15.16": [44, true], "aps.15.17": [46, true], "aps.15.18": [46, true], "aps.15.19": [45, true], "aps.15.20": [44, true], "aps.15.21": [51, true], "aps.15.22": [49, true], "aps.15.23": [54, true], "aps.15.24": [53, true], "aps.15.25": [52, true], "aps.15.26": [51, true], "aps.15.27": [51, true], "aps.15.28": [52, true], "aps.15.29": [53, true], "aps.15.30": [51, true]}}, "CHA": {"total": 4516, "solved": 41, "n": 45, "over": 0, "per": {"fun1.1": [35, true], "fun1.2": [37, true], "fun1.3": [37, true], "fun1.4": [104, true], "fun1.5": [152, true], "fun2.1": [37, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [151, true], "fun2.5": [163, true], "fun3.1": [88, true], "fun3.2": [92, true], "fun3.3": [112, true], "fun3.4": [125, true], "fun3.5": [152, true], "fun4.1": [88, true], "fun4.2": [93, true], "fun4.3": [113, true], "fun4.4": [124, true], "fun4.5": [152, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [52, false], "fun7.2": [52, false], "fun7.3": [8, false], "fun7.4": [25, true], "fun7.5": [60, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [92, true], "fun8.5": [96, true], "fun9.1": [35, true], "fun9.2": [35, true], "fun9.3": [40, true], "fun9.4": [92, true], "fun9.5": [42, true]}}}, {"label": "pure.sqrt.derived.none", "spec": ["pure", "sqrt", "derived", "none"], "APS": {"total": 9912, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [60, true], "aps.02.00": [58, true], "aps.02.01": [62, true], "aps.02.02": [58, true], "aps.02.03": [64, true], "aps.02.04": [65, true], "aps.02.05": [65, true], "aps.02.06": [65, true], "aps.02.07": [65, true], "aps.02.08": [66, true], "aps.02.09": [66, true], "aps.03.00": [76, true], "aps.03.01": [67, true], "aps.03.02": [69, true], "aps.04.00": [66, true], "aps.04.01": [62, true], "aps.04.02": [64, true], "aps.04.03": [62, true], "aps.04.04": [66, true], "aps.04.05": [61, true], "aps.04.06": [64, true], "aps.04.07": [66, true], "aps.04.08": [64, true], "aps.04.09": [63, true], "aps.04.10": [64, true], "aps.04.11": [66, true], "aps.04.12": [64, true], "aps.04.13": [69, true], "aps.05.00": [59, true], "aps.06.00": [60, true], "aps.06.01": [59, true], "aps.06.02": [56, true], "aps.06.03": [59, true], "aps.06.04": [58, true], "aps.06.05": [58, true], "aps.06.06": [58, true], "aps.06.07": [56, true], "aps.06.08": [58, true], "aps.06.09": [54, true], "aps.07.00": [57, true], "aps.07.01": [52, true], "aps.07.02": [49, true], "aps.08.00": [60, true], "aps.08.01": [59, true], "aps.08.02": [59, true], "aps.08.03": [59, true], "aps.08.04": [58, true], "aps.09.00": [57, true], "aps.09.01": [58, true], "aps.09.02": [54, true], "aps.09.03": [52, true], "aps.09.04": [48, true], "aps.09.05": [42, true], "aps.09.06": [40, true], "aps.10.00": [60, true], "aps.10.01": [59, true], "aps.10.02": [58, true], "aps.10.03": [56, true], "aps.10.04": [53, true], "aps.11.00": [62, true], "aps.11.01": [61, true], "aps.11.02": [60, true], "aps.11.03": [58, true], "aps.12.00": [62, true], "aps.12.01": [63, true], "aps.12.02": [61, true], "aps.12.03": [64, true], "aps.12.04": [65, true], "aps.12.05": [66, true], "aps.12.06": [66, true], "aps.12.07": [65, true], "aps.12.08": [67, true], "aps.12.09": [67, true], "aps.12.10": [66, true], "aps.12.11": [65, true], "aps.12.12": [64, true], "aps.12.13": [65, true], "aps.12.14": [68, true], "aps.12.15": [69, true], "aps.12.16": [69, true], "aps.12.17": [69, true], "aps.12.18": [69, true], "aps.13.00": [56, false], "aps.14.00": [69, true], "aps.14.01": [69, true], "aps.14.02": [69, true], "aps.14.03": [69, true], "aps.14.04": [69, true], "aps.14.05": [69, true], "aps.14.06": [69, true], "aps.14.07": [69, true], "aps.14.08": [69, true], "aps.14.09": [69, true], "aps.14.10": [69, true], "aps.14.11": [69, true], "aps.14.12": [69, true], "aps.14.13": [69, true], "aps.14.14": [69, true], "aps.14.15": [69, true], "aps.14.16": [69, true], "aps.14.17": [69, true], "aps.14.18": [69, true], "aps.14.19": [69, true], "aps.14.20": [69, true], "aps.14.21": [69, true], "aps.14.22": [69, true], "aps.14.23": [69, true], "aps.14.24": [69, true], "aps.14.25": [69, true], "aps.14.26": [69, true], "aps.14.27": [69, true], "aps.14.28": [69, true], "aps.14.29": [69, true], "aps.14.30": [69, true], "aps.14.31": [69, true], "aps.14.32": [69, true], "aps.14.33": [69, true], "aps.14.34": [69, true], "aps.14.35": [69, true], "aps.14.36": [69, true], "aps.14.37": [69, true], "aps.14.38": [69, true], "aps.14.39": [69, true], "aps.15.00": [62, true], "aps.15.01": [62, true], "aps.15.02": [63, true], "aps.15.03": [64, true], "aps.15.04": [64, true], "aps.15.05": [64, true], "aps.15.06": [63, true], "aps.15.07": [63, true], "aps.15.08": [63, true], "aps.15.09": [63, true], "aps.15.10": [62, true], "aps.15.11": [62, true], "aps.15.12": [62, true], "aps.15.13": [62, true], "aps.15.14": [61, true], "aps.15.15": [61, true], "aps.15.16": [61, true], "aps.15.17": [60, true], "aps.15.18": [60, true], "aps.15.19": [58, true], "aps.15.20": [54, true], "aps.15.21": [60, true], "aps.15.22": [61, true], "aps.15.23": [63, true], "aps.15.24": [61, true], "aps.15.25": [64, true], "aps.15.26": [64, true], "aps.15.27": [65, true], "aps.15.28": [65, true], "aps.15.29": [66, true], "aps.15.30": [66, true]}}, "CHA": {"total": 3511, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [63, true], "fun1.3": [66, true], "fun1.4": [76, true], "fun1.5": [84, true], "fun2.1": [60, true], "fun2.2": [78, true], "fun2.3": [80, true], "fun2.4": [89, true], "fun2.5": [100, true], "fun3.1": [33, true], "fun3.2": [33, true], "fun3.3": [40, true], "fun3.4": [48, true], "fun3.5": [53, true], "fun4.1": [39, true], "fun4.2": [39, true], "fun4.3": [54, true], "fun4.4": [63, true], "fun4.5": [78, true], "fun5.1": [48, true], "fun5.2": [62, true], "fun5.3": [56, true], "fun5.4": [56, true], "fun5.5": [56, true], "fun6.1": [64, true], "fun6.2": [65, true], "fun6.3": [79, true], "fun6.4": [81, true], "fun6.5": [82, true], "fun7.1": [56, false], "fun7.2": [83, false], "fun7.3": [18, false], "fun7.4": [62, false], "fun7.5": [9, false], "fun8.1": [58, true], "fun8.2": [61, true], "fun8.3": [65, true], "fun8.4": [67, true], "fun8.5": [68, true], "fun9.1": [60, true], "fun9.2": [57, true], "fun9.3": [62, true], "fun9.4": [59, true], "fun9.5": [71, true]}}}, {"label": "pure.rational.derived.project", "spec": ["pure", "rational", "derived", "project"], "APS": {"total": 3596, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [14, true], "aps.02.01": [12, true], "aps.02.02": [44, true], "aps.02.03": [17, true], "aps.02.04": [14, true], "aps.02.05": [12, true], "aps.02.06": [44, true], "aps.02.07": [12, true], "aps.02.08": [12, true], "aps.02.09": [22, true], "aps.03.00": [22, true], "aps.03.01": [59, true], "aps.03.02": [60, true], "aps.04.00": [21, true], "aps.04.01": [17, true], "aps.04.02": [55, true], "aps.04.03": [18, true], "aps.04.04": [19, true], "aps.04.05": [18, true], "aps.04.06": [14, true], "aps.04.07": [15, true], "aps.04.08": [16, true], "aps.04.09": [17, true], "aps.04.10": [17, true], "aps.04.11": [19, true], "aps.04.12": [26, true], "aps.04.13": [30, true], "aps.05.00": [10, true], "aps.06.00": [9, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [14, true], "aps.06.06": [15, true], "aps.06.07": [16, true], "aps.06.08": [16, true], "aps.06.09": [17, true], "aps.07.00": [11, true], "aps.07.01": [14, true], "aps.07.02": [16, true], "aps.08.00": [8, true], "aps.08.01": [49, true], "aps.08.02": [11, true], "aps.08.03": [11, true], "aps.08.04": [12, true], "aps.09.00": [36, true], "aps.09.01": [44, true], "aps.09.02": [14, true], "aps.09.03": [15, true], "aps.09.04": [18, true], "aps.09.05": [22, true], "aps.09.06": [24, true], "aps.10.00": [9, true], "aps.10.01": [43, true], "aps.10.02": [45, true], "aps.10.03": [15, true], "aps.10.04": [49, true], "aps.11.00": [11, true], "aps.11.01": [14, true], "aps.11.02": [14, true], "aps.11.03": [15, true], "aps.12.00": [11, true], "aps.12.01": [11, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [11, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [10, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [51, false], "aps.14.00": [20, true], "aps.14.01": [20, true], "aps.14.02": [20, true], "aps.14.03": [20, true], "aps.14.04": [20, true], "aps.14.05": [20, true], "aps.14.06": [20, true], "aps.14.07": [20, true], "aps.14.08": [20, true], "aps.14.09": [20, true], "aps.14.10": [20, true], "aps.14.11": [20, true], "aps.14.12": [20, true], "aps.14.13": [20, true], "aps.14.14": [20, true], "aps.14.15": [20, true], "aps.14.16": [20, true], "aps.14.17": [20, true], "aps.14.18": [20, true], "aps.14.19": [20, true], "aps.14.20": [20, true], "aps.14.21": [20, true], "aps.14.22": [20, true], "aps.14.23": [20, true], "aps.14.24": [20, true], "aps.14.25": [20, true], "aps.14.26": [20, true], "aps.14.27": [20, true], "aps.14.28": [20, true], "aps.14.29": [20, true], "aps.14.30": [20, true], "aps.14.31": [20, true], "aps.14.32": [20, true], "aps.14.33": [20, true], "aps.14.34": [20, true], "aps.14.35": [20, true], "aps.14.36": [20, true], "aps.14.37": [20, true], "aps.14.38": [20, true], "aps.14.39": [20, true], "aps.15.00": [33, true], "aps.15.01": [33, true], "aps.15.02": [34, true], "aps.15.03": [35, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [34, true], "aps.15.08": [34, true], "aps.15.09": [34, true], "aps.15.10": [34, true], "aps.15.11": [35, true], "aps.15.12": [34, true], "aps.15.13": [34, true], "aps.15.14": [35, true], "aps.15.15": [35, true], "aps.15.16": [35, true], "aps.15.17": [35, true], "aps.15.18": [35, true], "aps.15.19": [35, true], "aps.15.20": [35, true], "aps.15.21": [35, true], "aps.15.22": [36, true], "aps.15.23": [37, true], "aps.15.24": [37, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [36, true], "aps.15.28": [36, true], "aps.15.29": [35, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3805, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [37, true], "fun1.2": [18, true], "fun1.3": [19, true], "fun1.4": [40, true], "fun1.5": [153, true], "fun2.1": [11, true], "fun2.2": [47, true], "fun2.3": [58, true], "fun2.4": [78, true], "fun2.5": [85, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [125, true], "fun3.5": [153, true], "fun4.1": [89, true], "fun4.2": [92, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [88, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [51, false], "fun7.2": [52, false], "fun7.3": [54, false], "fun7.4": [57, false], "fun7.5": [59, false], "fun8.1": [11, true], "fun8.2": [13, true], "fun8.3": [13, true], "fun8.4": [14, true], "fun8.5": [14, true], "fun9.1": [8, true], "fun9.2": [11, true], "fun9.3": [27, true], "fun9.4": [47, true], "fun9.5": [44, true]}}}, {"label": "pure.sqrt.start.none", "spec": ["pure", "sqrt", "start", "none"], "APS": {"total": 29492, "solved": 14, "n": 154, "over": 8, "per": {"aps.01.00": [200, false], "aps.02.00": [200, false], "aps.02.01": [200, false], "aps.02.02": [200, false], "aps.02.03": [200, false], "aps.02.04": [200, false], "aps.02.05": [200, false], "aps.02.06": [200, false], "aps.02.07": [200, false], "aps.02.08": [200, false], "aps.02.09": [200, false], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [200, false], "aps.04.01": [200, false], "aps.04.02": [200, false], "aps.04.03": [200, false], "aps.04.04": [200, false], "aps.04.05": [200, false], "aps.04.06": [200, false], "aps.04.07": [200, false], "aps.04.08": [200, false], "aps.04.09": [200, false], "aps.04.10": [200, false], "aps.04.11": [200, false], "aps.04.12": [200, false], "aps.04.13": [200, false], "aps.05.00": [200, false], "aps.06.00": [200, false], "aps.06.01": [200, false], "aps.06.02": [200, false], "aps.06.03": [200, false], "aps.06.04": [200, false], "aps.06.05": [200, false], "aps.06.06": [200, false], "aps.06.07": [200, false], "aps.06.08": [200, false], "aps.06.09": [200, false], "aps.07.00": [200, false], "aps.07.01": [200, false], "aps.07.02": [200, false], "aps.08.00": [3, true], "aps.08.01": [200, false], "aps.08.02": [200, false], "aps.08.03": [200, false], "aps.08.04": [200, false], "aps.09.00": [200, false], "aps.09.01": [200, false], "aps.09.02": [200, false], "aps.09.03": [193, true], "aps.09.04": [200, false], "aps.09.05": [200, false], "aps.09.06": [200, false], "aps.10.00": [200, false], "aps.10.01": [200, false], "aps.10.02": [200, false], "aps.10.03": [200, false], "aps.10.04": [200, false], "aps.11.00": [200, false], "aps.11.01": [200, false], "aps.11.02": [200, false], "aps.11.03": [200, false], "aps.12.00": [200, false], "aps.12.01": [200, false], "aps.12.02": [200, false], "aps.12.03": [200, false], "aps.12.04": [200, false], "aps.12.05": [148, true], "aps.12.06": [200, false], "aps.12.07": [200, false], "aps.12.08": [200, false], "aps.12.09": [200, false], "aps.12.10": [200, false], "aps.12.11": [200, false], "aps.12.12": [200, false], "aps.12.13": [200, false], "aps.12.14": [200, false], "aps.12.15": [200, false], "aps.12.16": [200, false], "aps.12.17": [200, false], "aps.12.18": [200, false], "aps.13.00": [200, false], "aps.14.00": [200, false], "aps.14.01": [200, false], "aps.14.02": [200, false], "aps.14.03": [200, false], "aps.14.04": [200, false], "aps.14.05": [200, false], "aps.14.06": [200, false], "aps.14.07": [200, false], "aps.14.08": [200, false], "aps.14.09": [200, false], "aps.14.10": [200, false], "aps.14.11": [200, false], "aps.14.12": [200, false], "aps.14.13": [200, false], "aps.14.14": [200, false], "aps.14.15": [200, false], "aps.14.16": [200, false], "aps.14.17": [200, false], "aps.14.18": [200, false], "aps.14.19": [200, false], "aps.14.20": [200, false], "aps.14.21": [200, false], "aps.14.22": [200, false], "aps.14.23": [200, false], "aps.14.24": [200, false], "aps.14.25": [200, false], "aps.14.26": [200, false], "aps.14.27": [200, false], "aps.14.28": [200, false], "aps.14.29": [200, false], "aps.14.30": [200, false], "aps.14.31": [200, false], "aps.14.32": [200, false], "aps.14.33": [200, false], "aps.14.34": [200, false], "aps.14.35": [200, false], "aps.14.36": [200, false], "aps.14.37": [200, false], "aps.14.38": [200, false], "aps.14.39": [200, false], "aps.15.00": [200, false], "aps.15.01": [200, false], "aps.15.02": [200, false], "aps.15.03": [200, false], "aps.15.04": [200, false], "aps.15.05": [200, false], "aps.15.06": [111, true], "aps.15.07": [200, false], "aps.15.08": [200, false], "aps.15.09": [143, true], "aps.15.10": [121, true], "aps.15.11": [200, false], "aps.15.12": [83, true], "aps.15.13": [200, false], "aps.15.14": [200, false], "aps.15.15": [200, false], "aps.15.16": [120, true], "aps.15.17": [165, true], "aps.15.18": [200, false], "aps.15.19": [200, false], "aps.15.20": [200, false], "aps.15.21": [174, true], "aps.15.22": [200, false], "aps.15.23": [200, false], "aps.15.24": [86, true], "aps.15.25": [200, false], "aps.15.26": [200, false], "aps.15.27": [200, false], "aps.15.28": [200, false], "aps.15.29": [200, false], "aps.15.30": [200, false]}}, "CHA": {"total": 9000, "solved": 0, "n": 45, "over": 0, "per": {"fun1.1": [200, false], "fun1.2": [200, false], "fun1.3": [200, false], "fun1.4": [200, false], "fun1.5": [200, false], "fun2.1": [200, false], "fun2.2": [200, false], "fun2.3": [200, false], "fun2.4": [200, false], "fun2.5": [200, false], "fun3.1": [200, false], "fun3.2": [200, false], "fun3.3": [200, false], "fun3.4": [200, false], "fun3.5": [200, false], "fun4.1": [200, false], "fun4.2": [200, false], "fun4.3": [200, false], "fun4.4": [200, false], "fun4.5": [200, false], "fun5.1": [200, false], "fun5.2": [200, false], "fun5.3": [200, false], "fun5.4": [200, false], "fun5.5": [200, false], "fun6.1": [200, false], "fun6.2": [200, false], "fun6.3": [200, false], "fun6.4": [200, false], "fun6.5": [200, false], "fun7.1": [200, false], "fun7.2": [200, false], "fun7.3": [200, false], "fun7.4": [200, false], "fun7.5": [8, false], "fun8.1": [200, false], "fun8.2": [200, false], "fun8.3": [200, false], "fun8.4": [200, false], "fun8.5": [200, false], "fun9.1": [200, false], "fun9.2": [200, false], "fun9.3": [200, false], "fun9.4": [200, false], "fun9.5": [200, false]}}}, {"label": "pure.sqrt.derived.both", "spec": ["pure", "sqrt", "derived", "both"], "APS": {"total": 9940, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [51, true], "aps.02.00": [72, true], "aps.02.01": [56, true], "aps.02.02": [52, true], "aps.02.03": [56, true], "aps.02.04": [57, true], "aps.02.05": [59, true], "aps.02.06": [72, true], "aps.02.07": [70, true], "aps.02.08": [56, true], "aps.02.09": [60, true], "aps.03.00": [59, true], "aps.03.01": [68, true], "aps.03.02": [68, true], "aps.04.00": [49, true], "aps.04.01": [55, true], "aps.04.02": [55, true], "aps.04.03": [64, true], "aps.04.04": [57, true], "aps.04.05": [54, true], "aps.04.06": [72, true], "aps.04.07": [64, true], "aps.04.08": [57, true], "aps.04.09": [54, true], "aps.04.10": [59, true], "aps.04.11": [82, true], "aps.04.12": [55, true], "aps.04.13": [58, true], "aps.05.00": [51, true], "aps.06.00": [53, true], "aps.06.01": [63, true], "aps.06.02": [61, true], "aps.06.03": [69, true], "aps.06.04": [53, true], "aps.06.05": [52, true], "aps.06.06": [52, true], "aps.06.07": [49, true], "aps.06.08": [52, true], "aps.06.09": [48, true], "aps.07.00": [81, true], "aps.07.01": [81, true], "aps.07.02": [81, true], "aps.08.00": [3, true], "aps.08.01": [56, true], "aps.08.02": [55, true], "aps.08.03": [53, true], "aps.08.04": [54, true], "aps.09.00": [52, true], "aps.09.01": [55, true], "aps.09.02": [81, true], "aps.09.03": [81, true], "aps.09.04": [81, true], "aps.09.05": [81, true], "aps.09.06": [81, true], "aps.10.00": [63, true], "aps.10.01": [49, true], "aps.10.02": [53, true], "aps.10.03": [51, true], "aps.10.04": [49, true], "aps.11.00": [52, true], "aps.11.01": [59, true], "aps.11.02": [62, true], "aps.11.03": [53, true], "aps.12.00": [53, true], "aps.12.01": [56, true], "aps.12.02": [67, true], "aps.12.03": [63, true], "aps.12.04": [61, true], "aps.12.05": [80, true], "aps.12.06": [61, true], "aps.12.07": [65, true], "aps.12.08": [63, true], "aps.12.09": [68, true], "aps.12.10": [59, true], "aps.12.11": [53, true], "aps.12.12": [61, true], "aps.12.13": [60, true], "aps.12.14": [65, true], "aps.12.15": [74, true], "aps.12.16": [64, true], "aps.12.17": [63, true], "aps.12.18": [58, true], "aps.13.00": [8, false], "aps.14.00": [70, true], "aps.14.01": [70, true], "aps.14.02": [70, true], "aps.14.03": [70, true], "aps.14.04": [70, true], "aps.14.05": [70, true], "aps.14.06": [70, true], "aps.14.07": [70, true], "aps.14.08": [70, true], "aps.14.09": [70, true], "aps.14.10": [70, true], "aps.14.11": [70, true], "aps.14.12": [70, true], "aps.14.13": [70, true], "aps.14.14": [70, true], "aps.14.15": [70, true], "aps.14.16": [70, true], "aps.14.17": [70, true], "aps.14.18": [70, true], "aps.14.19": [70, true], "aps.14.20": [70, true], "aps.14.21": [70, true], "aps.14.22": [70, true], "aps.14.23": [70, true], "aps.14.24": [70, true], "aps.14.25": [70, true], "aps.14.26": [70, true], "aps.14.27": [70, true], "aps.14.28": [70, true], "aps.14.29": [70, true], "aps.14.30": [70, true], "aps.14.31": [70, true], "aps.14.32": [70, true], "aps.14.33": [70, true], "aps.14.34": [70, true], "aps.14.35": [70, true], "aps.14.36": [70, true], "aps.14.37": [70, true], "aps.14.38": [70, true], "aps.14.39": [70, true], "aps.15.00": [58, true], "aps.15.01": [59, true], "aps.15.02": [58, true], "aps.15.03": [58, true], "aps.15.04": [58, true], "aps.15.05": [60, true], "aps.15.06": [60, true], "aps.15.07": [61, true], "aps.15.08": [64, true], "aps.15.09": [69, true], "aps.15.10": [77, true], "aps.15.11": [77, true], "aps.15.12": [75, true], "aps.15.13": [73, true], "aps.15.14": [71, true], "aps.15.15": [70, true], "aps.15.16": [67, true], "aps.15.17": [65, true], "aps.15.18": [64, true], "aps.15.19": [62, true], "aps.15.20": [61, true], "aps.15.21": [65, true], "aps.15.22": [76, true], "aps.15.23": [60, true], "aps.15.24": [58, true], "aps.15.25": [59, true], "aps.15.26": [59, true], "aps.15.27": [59, true], "aps.15.28": [57, true], "aps.15.29": [62, true], "aps.15.30": [63, true]}}, "CHA": {"total": 3870, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [52, true], "fun1.2": [55, true], "fun1.3": [59, true], "fun1.4": [70, true], "fun1.5": [93, true], "fun2.1": [55, true], "fun2.2": [68, true], "fun2.3": [100, true], "fun2.4": [89, true], "fun2.5": [120, true], "fun3.1": [58, true], "fun3.2": [61, true], "fun3.3": [74, true], "fun3.4": [82, true], "fun3.5": [100, true], "fun4.1": [63, true], "fun4.2": [65, true], "fun4.3": [81, true], "fun4.4": [96, true], "fun4.5": [115, true], "fun5.1": [69, true], "fun5.2": [69, true], "fun5.3": [73, true], "fun5.4": [75, true], "fun5.5": [77, true], "fun6.1": [62, true], "fun6.2": [58, true], "fun6.3": [65, true], "fun6.4": [68, true], "fun6.5": [69, true], "fun7.1": [8, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [16, false], "fun8.1": [83, true], "fun8.2": [74, true], "fun8.3": [61, true], "fun8.4": [59, true], "fun8.5": [68, true], "fun9.1": [51, true], "fun9.2": [54, true], "fun9.3": [59, true], "fun9.4": [58, true], "fun9.5": [62, true]}}}, {"label": "pure.sqrt.bracket.credit", "spec": ["pure", "sqrt", "bracket", "credit"], "APS": {"total": 6963, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [33, true], "aps.02.00": [37, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [43, true], "aps.08.02": [31, true], "aps.08.03": [33, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [35, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [40, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [44, true], "aps.12.04": [43, true], "aps.12.05": [50, true], "aps.12.06": [39, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [40, true], "aps.12.12": [41, true], "aps.12.13": [41, true], "aps.12.14": [47, true], "aps.12.15": [41, true], "aps.12.16": [39, true], "aps.12.17": [41, true], "aps.12.18": [39, true], "aps.13.00": [8, false], "aps.14.00": [45, true], "aps.14.01": [45, true], "aps.14.02": [45, true], "aps.14.03": [45, true], "aps.14.04": [45, true], "aps.14.05": [45, true], "aps.14.06": [45, true], "aps.14.07": [45, true], "aps.14.08": [45, true], "aps.14.09": [45, true], "aps.14.10": [45, true], "aps.14.11": [45, true], "aps.14.12": [45, true], "aps.14.13": [45, true], "aps.14.14": [45, true], "aps.14.15": [45, true], "aps.14.16": [45, true], "aps.14.17": [45, true], "aps.14.18": [45, true], "aps.14.19": [45, true], "aps.14.20": [45, true], "aps.14.21": [45, true], "aps.14.22": [45, true], "aps.14.23": [45, true], "aps.14.24": [45, true], "aps.14.25": [45, true], "aps.14.26": [45, true], "aps.14.27": [45, true], "aps.14.28": [45, true], "aps.14.29": [45, true], "aps.14.30": [45, true], "aps.14.31": [45, true], "aps.14.32": [45, true], "aps.14.33": [45, true], "aps.14.34": [45, true], "aps.14.35": [45, true], "aps.14.36": [45, true], "aps.14.37": [45, true], "aps.14.38": [45, true], "aps.14.39": [45, true], "aps.15.00": [39, true], "aps.15.01": [41, true], "aps.15.02": [37, true], "aps.15.03": [38, true], "aps.15.04": [40, true], "aps.15.05": [39, true], "aps.15.06": [34, true], "aps.15.07": [40, true], "aps.15.08": [40, true], "aps.15.09": [44, true], "aps.15.10": [40, true], "aps.15.11": [41, true], "aps.15.12": [41, true], "aps.15.13": [43, true], "aps.15.14": [43, true], "aps.15.15": [43, true], "aps.15.16": [44, true], "aps.15.17": [46, true], "aps.15.18": [46, true], "aps.15.19": [45, true], "aps.15.20": [44, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3094, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [35, true], "fun1.2": [35, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [37, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [8, false], "fun7.2": [8, false], "fun7.3": [8, false], "fun7.4": [13, false], "fun7.5": [13, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [35, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.sqrt.derived.step", "spec": ["pure", "sqrt", "derived", "step"], "APS": {"total": 9588, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [60, true], "aps.02.00": [60, true], "aps.02.01": [61, true], "aps.02.02": [60, true], "aps.02.03": [62, true], "aps.02.04": [63, true], "aps.02.05": [63, true], "aps.02.06": [63, true], "aps.02.07": [64, true], "aps.02.08": [65, true], "aps.02.09": [65, true], "aps.03.00": [66, true], "aps.03.01": [65, true], "aps.03.02": [61, true], "aps.04.00": [59, true], "aps.04.01": [59, true], "aps.04.02": [64, true], "aps.04.03": [61, true], "aps.04.04": [64, true], "aps.04.05": [61, true], "aps.04.06": [59, true], "aps.04.07": [64, true], "aps.04.08": [63, true], "aps.04.09": [62, true], "aps.04.10": [62, true], "aps.04.11": [60, true], "aps.04.12": [60, true], "aps.04.13": [58, true], "aps.05.00": [60, true], "aps.06.00": [58, true], "aps.06.01": [59, true], "aps.06.02": [58, true], "aps.06.03": [52, true], "aps.06.04": [58, true], "aps.06.05": [55, true], "aps.06.06": [54, true], "aps.06.07": [57, true], "aps.06.08": [54, true], "aps.06.09": [56, true], "aps.07.00": [54, true], "aps.07.01": [49, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [58, true], "aps.08.02": [58, true], "aps.08.03": [56, true], "aps.08.04": [58, true], "aps.09.00": [58, true], "aps.09.01": [56, true], "aps.09.02": [55, true], "aps.09.03": [53, true], "aps.09.04": [49, true], "aps.09.05": [43, true], "aps.09.06": [41, true], "aps.10.00": [59, true], "aps.10.01": [56, true], "aps.10.02": [54, true], "aps.10.03": [54, true], "aps.10.04": [53, true], "aps.11.00": [58, true], "aps.11.01": [57, true], "aps.11.02": [58, true], "aps.11.03": [58, true], "aps.12.00": [62, true], "aps.12.01": [63, true], "aps.12.02": [61, true], "aps.12.03": [64, true], "aps.12.04": [64, true], "aps.12.05": [58, true], "aps.12.06": [65, true], "aps.12.07": [68, true], "aps.12.08": [66, true], "aps.12.09": [69, true], "aps.12.10": [69, true], "aps.12.11": [69, true], "aps.12.12": [68, true], "aps.12.13": [68, true], "aps.12.14": [65, true], "aps.12.15": [62, true], "aps.12.16": [65, true], "aps.12.17": [66, true], "aps.12.18": [67, true], "aps.13.00": [12, false], "aps.14.00": [66, true], "aps.14.01": [66, true], "aps.14.02": [66, true], "aps.14.03": [66, true], "aps.14.04": [66, true], "aps.14.05": [66, true], "aps.14.06": [66, true], "aps.14.07": [66, true], "aps.14.08": [66, true], "aps.14.09": [66, true], "aps.14.10": [66, true], "aps.14.11": [66, true], "aps.14.12": [66, true], "aps.14.13": [66, true], "aps.14.14": [66, true], "aps.14.15": [66, true], "aps.14.16": [66, true], "aps.14.17": [66, true], "aps.14.18": [66, true], "aps.14.19": [66, true], "aps.14.20": [66, true], "aps.14.21": [66, true], "aps.14.22": [66, true], "aps.14.23": [66, true], "aps.14.24": [66, true], "aps.14.25": [66, true], "aps.14.26": [66, true], "aps.14.27": [66, true], "aps.14.28": [66, true], "aps.14.29": [66, true], "aps.14.30": [66, true], "aps.14.31": [66, true], "aps.14.32": [66, true], "aps.14.33": [66, true], "aps.14.34": [66, true], "aps.14.35": [66, true], "aps.14.36": [66, true], "aps.14.37": [66, true], "aps.14.38": [66, true], "aps.14.39": [66, true], "aps.15.00": [64, true], "aps.15.01": [64, true], "aps.15.02": [64, true], "aps.15.03": [64, true], "aps.15.04": [63, true], "aps.15.05": [63, true], "aps.15.06": [62, true], "aps.15.07": [62, true], "aps.15.08": [61, true], "aps.15.09": [59, true], "aps.15.10": [57, true], "aps.15.11": [60, true], "aps.15.12": [61, true], "aps.15.13": [61, true], "aps.15.14": [62, true], "aps.15.15": [62, true], "aps.15.16": [62, true], "aps.15.17": [62, true], "aps.15.18": [62, true], "aps.15.19": [63, true], "aps.15.20": [63, true], "aps.15.21": [65, true], "aps.15.22": [61, true], "aps.15.23": [62, true], "aps.15.24": [61, true], "aps.15.25": [59, true], "aps.15.26": [58, true], "aps.15.27": [61, true], "aps.15.28": [61, true], "aps.15.29": [62, true], "aps.15.30": [62, true]}}, "CHA": {"total": 3493, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [62, true], "fun1.3": [64, true], "fun1.4": [68, true], "fun1.5": [83, true], "fun2.1": [58, true], "fun2.2": [76, true], "fun2.3": [79, true], "fun2.4": [89, true], "fun2.5": [100, true], "fun3.1": [31, true], "fun3.2": [32, true], "fun3.3": [42, true], "fun3.4": [45, true], "fun3.5": [52, true], "fun4.1": [41, true], "fun4.2": [43, true], "fun4.3": [53, true], "fun4.4": [56, true], "fun4.5": [98, true], "fun5.1": [48, true], "fun5.2": [61, true], "fun5.3": [46, true], "fun5.4": [50, true], "fun5.5": [53, true], "fun6.1": [52, true], "fun6.2": [81, true], "fun6.3": [79, true], "fun6.4": [85, true], "fun6.5": [88, true], "fun7.1": [12, false], "fun7.2": [14, false], "fun7.3": [10, false], "fun7.4": [15, false], "fun7.5": [9, false], "fun8.1": [58, true], "fun8.2": [61, true], "fun8.3": [63, true], "fun8.4": [66, true], "fun8.5": [69, true], "fun9.1": [59, true], "fun9.2": [57, true], "fun9.3": [60, true], "fun9.4": [61, true], "fun9.5": [66, true]}}}, {"label": "pure.sqrt.derived.bracket", "spec": ["pure", "sqrt", "derived", "bracket"], "APS": {"total": 9692, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [51, true], "aps.02.00": [84, true], "aps.02.01": [57, true], "aps.02.02": [86, true], "aps.02.03": [57, true], "aps.02.04": [59, true], "aps.02.05": [56, true], "aps.02.06": [57, true], "aps.02.07": [57, true], "aps.02.08": [59, true], "aps.02.09": [59, true], "aps.03.00": [66, true], "aps.03.01": [68, true], "aps.03.02": [68, true], "aps.04.00": [65, true], "aps.04.01": [58, true], "aps.04.02": [69, true], "aps.04.03": [62, true], "aps.04.04": [65, true], "aps.04.05": [58, true], "aps.04.06": [82, true], "aps.04.07": [58, true], "aps.04.08": [56, true], "aps.04.09": [71, true], "aps.04.10": [58, true], "aps.04.11": [58, true], "aps.04.12": [65, true], "aps.04.13": [64, true], "aps.05.00": [63, true], "aps.06.00": [56, true], "aps.06.01": [53, true], "aps.06.02": [51, true], "aps.06.03": [58, true], "aps.06.04": [51, true], "aps.06.05": [53, true], "aps.06.06": [52, true], "aps.06.07": [56, true], "aps.06.08": [52, true], "aps.06.09": [51, true], "aps.07.00": [55, true], "aps.07.01": [54, true], "aps.07.02": [60, true], "aps.08.00": [52, true], "aps.08.01": [58, true], "aps.08.02": [49, true], "aps.08.03": [53, true], "aps.08.04": [76, true], "aps.09.00": [54, true], "aps.09.01": [53, true], "aps.09.02": [58, true], "aps.09.03": [74, true], "aps.09.04": [77, true], "aps.09.05": [79, true], "aps.09.06": [78, true], "aps.10.00": [60, true], "aps.10.01": [51, true], "aps.10.02": [55, true], "aps.10.03": [60, true], "aps.10.04": [66, true], "aps.11.00": [64, true], "aps.11.01": [49, true], "aps.11.02": [64, true], "aps.11.03": [55, true], "aps.12.00": [53, true], "aps.12.01": [56, true], "aps.12.02": [67, true], "aps.12.03": [63, true], "aps.12.04": [58, true], "aps.12.05": [58, true], "aps.12.06": [61, true], "aps.12.07": [65, true], "aps.12.08": [57, true], "aps.12.09": [60, true], "aps.12.10": [65, true], "aps.12.11": [64, true], "aps.12.12": [72, true], "aps.12.13": [61, true], "aps.12.14": [60, true], "aps.12.15": [63, true], "aps.12.16": [63, true], "aps.12.17": [71, true], "aps.12.18": [60, true], "aps.13.00": [9, false], "aps.14.00": [64, true], "aps.14.01": [64, true], "aps.14.02": [64, true], "aps.14.03": [64, true], "aps.14.04": [64, true], "aps.14.05": [64, true], "aps.14.06": [64, true], "aps.14.07": [64, true], "aps.14.08": [64, true], "aps.14.09": [64, true], "aps.14.10": [64, true], "aps.14.11": [64, true], "aps.14.12": [64, true], "aps.14.13": [64, true], "aps.14.14": [64, true], "aps.14.15": [64, true], "aps.14.16": [64, true], "aps.14.17": [64, true], "aps.14.18": [64, true], "aps.14.19": [64, true], "aps.14.20": [64, true], "aps.14.21": [64, true], "aps.14.22": [64, true], "aps.14.23": [64, true], "aps.14.24": [64, true], "aps.14.25": [64, true], "aps.14.26": [64, true], "aps.14.27": [64, true], "aps.14.28": [64, true], "aps.14.29": [64, true], "aps.14.30": [64, true], "aps.14.31": [64, true], "aps.14.32": [64, true], "aps.14.33": [64, true], "aps.14.34": [64, true], "aps.14.35": [64, true], "aps.14.36": [64, true], "aps.14.37": [64, true], "aps.14.38": [64, true], "aps.14.39": [64, true], "aps.15.00": [59, true], "aps.15.01": [59, true], "aps.15.02": [58, true], "aps.15.03": [68, true], "aps.15.04": [68, true], "aps.15.05": [64, true], "aps.15.06": [61, true], "aps.15.07": [60, true], "aps.15.08": [60, true], "aps.15.09": [61, true], "aps.15.10": [57, true], "aps.15.11": [58, true], "aps.15.12": [56, true], "aps.15.13": [56, true], "aps.15.14": [64, true], "aps.15.15": [65, true], "aps.15.16": [65, true], "aps.15.17": [67, true], "aps.15.18": [69, true], "aps.15.19": [71, true], "aps.15.20": [70, true], "aps.15.21": [57, true], "aps.15.22": [76, true], "aps.15.23": [58, true], "aps.15.24": [57, true], "aps.15.25": [59, true], "aps.15.26": [59, true], "aps.15.27": [59, true], "aps.15.28": [58, true], "aps.15.29": [60, true], "aps.15.30": [73, true]}}, "CHA": {"total": 4102, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [52, true], "fun1.2": [58, true], "fun1.3": [68, true], "fun1.4": [75, true], "fun1.5": [104, true], "fun2.1": [55, true], "fun2.2": [68, true], "fun2.3": [100, true], "fun2.4": [89, true], "fun2.5": [120, true], "fun3.1": [64, true], "fun3.2": [65, true], "fun3.3": [82, true], "fun3.4": [93, true], "fun3.5": [109, true], "fun4.1": [78, true], "fun4.2": [82, true], "fun4.3": [98, true], "fun4.4": [110, true], "fun4.5": [134, true], "fun5.1": [75, true], "fun5.2": [75, true], "fun5.3": [76, true], "fun5.4": [81, true], "fun5.5": [83, true], "fun6.1": [64, true], "fun6.2": [61, true], "fun6.3": [73, true], "fun6.4": [77, true], "fun6.5": [80, true], "fun7.1": [9, false], "fun7.2": [11, false], "fun7.3": [10, false], "fun7.4": [13, false], "fun7.5": [16, false], "fun8.1": [77, true], "fun8.2": [74, true], "fun8.3": [60, true], "fun8.4": [59, true], "fun8.5": [64, true], "fun9.1": [52, true], "fun9.2": [83, true], "fun9.3": [61, true], "fun9.4": [63, true], "fun9.5": [60, true]}}}, {"label": "pure.sqrt.derived.credit", "spec": ["pure", "sqrt", "derived", "credit"], "APS": {"total": 7722, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [43, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [43, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [50, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [9, false], "fun7.3": [10, false], "fun7.4": [12, false], "fun7.5": [14, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}, {"label": "pure.sqrt.derived3.bracket", "spec": ["pure", "sqrt", "derived3", "bracket"], "APS": {"total": 9148, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [52, true], "aps.02.00": [54, true], "aps.02.01": [65, true], "aps.02.02": [58, true], "aps.02.03": [56, true], "aps.02.04": [55, true], "aps.02.05": [52, true], "aps.02.06": [63, true], "aps.02.07": [61, true], "aps.02.08": [57, true], "aps.02.09": [64, true], "aps.03.00": [59, true], "aps.03.01": [59, true], "aps.03.02": [61, true], "aps.04.00": [48, true], "aps.04.01": [81, true], "aps.04.02": [56, true], "aps.04.03": [56, true], "aps.04.04": [64, true], "aps.04.05": [72, true], "aps.04.06": [58, true], "aps.04.07": [55, true], "aps.04.08": [61, true], "aps.04.09": [57, true], "aps.04.10": [56, true], "aps.04.11": [51, true], "aps.04.12": [66, true], "aps.04.13": [55, true], "aps.05.00": [52, true], "aps.06.00": [58, true], "aps.06.01": [52, true], "aps.06.02": [53, true], "aps.06.03": [52, true], "aps.06.04": [53, true], "aps.06.05": [54, true], "aps.06.06": [55, true], "aps.06.07": [65, true], "aps.06.08": [56, true], "aps.06.09": [62, true], "aps.07.00": [54, true], "aps.07.01": [55, true], "aps.07.02": [63, true], "aps.08.00": [52, true], "aps.08.01": [60, true], "aps.08.02": [50, true], "aps.08.03": [55, true], "aps.08.04": [52, true], "aps.09.00": [64, true], "aps.09.01": [55, true], "aps.09.02": [75, true], "aps.09.03": [49, true], "aps.09.04": [72, true], "aps.09.05": [45, true], "aps.09.06": [59, true], "aps.10.00": [62, true], "aps.10.01": [78, true], "aps.10.02": [55, true], "aps.10.03": [49, true], "aps.10.04": [51, true], "aps.11.00": [54, true], "aps.11.01": [48, true], "aps.11.02": [68, true], "aps.11.03": [50, true], "aps.12.00": [60, true], "aps.12.01": [66, true], "aps.12.02": [63, true], "aps.12.03": [61, true], "aps.12.04": [61, true], "aps.12.05": [64, true], "aps.12.06": [63, true], "aps.12.07": [61, true], "aps.12.08": [59, true], "aps.12.09": [63, true], "aps.12.10": [61, true], "aps.12.11": [56, true], "aps.12.12": [61, true], "aps.12.13": [61, true], "aps.12.14": [59, true], "aps.12.15": [62, true], "aps.12.16": [58, true], "aps.12.17": [62, true], "aps.12.18": [61, true], "aps.13.00": [7, false], "aps.14.00": [59, true], "aps.14.01": [59, true], "aps.14.02": [59, true], "aps.14.03": [59, true], "aps.14.04": [59, true], "aps.14.05": [59, true], "aps.14.06": [59, true], "aps.14.07": [59, true], "aps.14.08": [59, true], "aps.14.09": [59, true], "aps.14.10": [59, true], "aps.14.11": [59, true], "aps.14.12": [59, true], "aps.14.13": [59, true], "aps.14.14": [59, true], "aps.14.15": [59, true], "aps.14.16": [59, true], "aps.14.17": [59, true], "aps.14.18": [59, true], "aps.14.19": [59, true], "aps.14.20": [59, true], "aps.14.21": [59, true], "aps.14.22": [59, true], "aps.14.23": [59, true], "aps.14.24": [59, true], "aps.14.25": [59, true], "aps.14.26": [59, true], "aps.14.27": [59, true], "aps.14.28": [59, true], "aps.14.29": [59, true], "aps.14.30": [59, true], "aps.14.31": [59, true], "aps.14.32": [59, true], "aps.14.33": [59, true], "aps.14.34": [59, true], "aps.14.35": [59, true], "aps.14.36": [59, true], "aps.14.37": [59, true], "aps.14.38": [59, true], "aps.14.39": [59, true], "aps.15.00": [58, true], "aps.15.01": [67, true], "aps.15.02": [58, true], "aps.15.03": [55, true], "aps.15.04": [55, true], "aps.15.05": [57, true], "aps.15.06": [60, true], "aps.15.07": [56, true], "aps.15.08": [55, true], "aps.15.09": [55, true], "aps.15.10": [55, true], "aps.15.11": [57, true], "aps.15.12": [57, true], "aps.15.13": [54, true], "aps.15.14": [56, true], "aps.15.15": [55, true], "aps.15.16": [56, true], "aps.15.17": [58, true], "aps.15.18": [60, true], "aps.15.19": [56, true], "aps.15.20": [56, true], "aps.15.21": [53, true], "aps.15.22": [59, true], "aps.15.23": [68, true], "aps.15.24": [59, true], "aps.15.25": [58, true], "aps.15.26": [58, true], "aps.15.27": [65, true], "aps.15.28": [56, true], "aps.15.29": [56, true], "aps.15.30": [59, true]}}, "CHA": {"total": 3859, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [54, true], "fun1.2": [56, true], "fun1.3": [61, true], "fun1.4": [79, true], "fun1.5": [115, true], "fun2.1": [61, true], "fun2.2": [69, true], "fun2.3": [78, true], "fun2.4": [85, true], "fun2.5": [96, true], "fun3.1": [56, true], "fun3.2": [59, true], "fun3.3": [73, true], "fun3.4": [79, true], "fun3.5": [104, true], "fun4.1": [75, true], "fun4.2": [78, true], "fun4.3": [94, true], "fun4.4": [95, true], "fun4.5": [126, true], "fun5.1": [73, true], "fun5.2": [72, true], "fun5.3": [71, true], "fun5.4": [75, true], "fun5.5": [77, true], "fun6.1": [68, true], "fun6.2": [68, true], "fun6.3": [63, true], "fun6.4": [65, true], "fun6.5": [64, true], "fun7.1": [7, false], "fun7.2": [7, false], "fun7.3": [10, false], "fun7.4": [11, false], "fun7.5": [15, false], "fun8.1": [53, true], "fun8.2": [57, true], "fun8.3": [55, true], "fun8.4": [60, true], "fun8.5": [70, true], "fun9.1": [53, true], "fun9.2": [49, true], "fun9.3": [57, true], "fun9.4": [51, true], "fun9.5": [65, true]}}}, {"label": "pure.sqrt.derived3.step", "spec": ["pure", "sqrt", "derived3", "step"], "APS": {"total": 9292, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [60, true], "aps.02.00": [62, true], "aps.02.01": [63, true], "aps.02.02": [63, true], "aps.02.03": [65, true], "aps.02.04": [63, true], "aps.02.05": [64, true], "aps.02.06": [65, true], "aps.02.07": [64, true], "aps.02.08": [64, true], "aps.02.09": [65, true], "aps.03.00": [70, true], "aps.03.01": [68, true], "aps.03.02": [68, true], "aps.04.00": [61, true], "aps.04.01": [63, true], "aps.04.02": [64, true], "aps.04.03": [62, true], "aps.04.04": [63, true], "aps.04.05": [62, true], "aps.04.06": [60, true], "aps.04.07": [65, true], "aps.04.08": [66, true], "aps.04.09": [57, true], "aps.04.10": [62, true], "aps.04.11": [63, true], "aps.04.12": [64, true], "aps.04.13": [64, true], "aps.05.00": [60, true], "aps.06.00": [58, true], "aps.06.01": [59, true], "aps.06.02": [59, true], "aps.06.03": [59, true], "aps.06.04": [59, true], "aps.06.05": [57, true], "aps.06.06": [54, true], "aps.06.07": [55, true], "aps.06.08": [60, true], "aps.06.09": [60, true], "aps.07.00": [59, true], "aps.07.01": [58, true], "aps.07.02": [56, true], "aps.08.00": [3, true], "aps.08.01": [58, true], "aps.08.02": [54, true], "aps.08.03": [57, true], "aps.08.04": [55, true], "aps.09.00": [59, true], "aps.09.01": [59, true], "aps.09.02": [57, true], "aps.09.03": [55, true], "aps.09.04": [50, true], "aps.09.05": [45, true], "aps.09.06": [42, true], "aps.10.00": [59, true], "aps.10.01": [56, true], "aps.10.02": [54, true], "aps.10.03": [56, true], "aps.10.04": [58, true], "aps.11.00": [59, true], "aps.11.01": [58, true], "aps.11.02": [55, true], "aps.11.03": [57, true], "aps.12.00": [67, true], "aps.12.01": [68, true], "aps.12.02": [68, true], "aps.12.03": [69, true], "aps.12.04": [66, true], "aps.12.05": [67, true], "aps.12.06": [67, true], "aps.12.07": [67, true], "aps.12.08": [68, true], "aps.12.09": [67, true], "aps.12.10": [67, true], "aps.12.11": [67, true], "aps.12.12": [67, true], "aps.12.13": [67, true], "aps.12.14": [68, true], "aps.12.15": [68, true], "aps.12.16": [68, true], "aps.12.17": [68, true], "aps.12.18": [68, true], "aps.13.00": [11, false], "aps.14.00": [64, true], "aps.14.01": [64, true], "aps.14.02": [64, true], "aps.14.03": [64, true], "aps.14.04": [64, true], "aps.14.05": [64, true], "aps.14.06": [64, true], "aps.14.07": [64, true], "aps.14.08": [64, true], "aps.14.09": [64, true], "aps.14.10": [64, true], "aps.14.11": [64, true], "aps.14.12": [64, true], "aps.14.13": [64, true], "aps.14.14": [64, true], "aps.14.15": [64, true], "aps.14.16": [64, true], "aps.14.17": [64, true], "aps.14.18": [64, true], "aps.14.19": [64, true], "aps.14.20": [64, true], "aps.14.21": [64, true], "aps.14.22": [64, true], "aps.14.23": [64, true], "aps.14.24": [64, true], "aps.14.25": [64, true], "aps.14.26": [64, true], "aps.14.27": [64, true], "aps.14.28": [64, true], "aps.14.29": [64, true], "aps.14.30": [64, true], "aps.14.31": [64, true], "aps.14.32": [64, true], "aps.14.33": [64, true], "aps.14.34": [64, true], "aps.14.35": [64, true], "aps.14.36": [64, true], "aps.14.37": [64, true], "aps.14.38": [64, true], "aps.14.39": [64, true], "aps.15.00": [47, true], "aps.15.01": [49, true], "aps.15.02": [50, true], "aps.15.03": [50, true], "aps.15.04": [51, true], "aps.15.05": [51, true], "aps.15.06": [51, true], "aps.15.07": [51, true], "aps.15.08": [51, true], "aps.15.09": [51, true], "aps.15.10": [51, true], "aps.15.11": [50, true], "aps.15.12": [50, true], "aps.15.13": [50, true], "aps.15.14": [50, true], "aps.15.15": [50, true], "aps.15.16": [50, true], "aps.15.17": [50, true], "aps.15.18": [50, true], "aps.15.19": [50, true], "aps.15.20": [50, true], "aps.15.21": [52, true], "aps.15.22": [48, true], "aps.15.23": [50, true], "aps.15.24": [51, true], "aps.15.25": [49, true], "aps.15.26": [45, true], "aps.15.27": [49, true], "aps.15.28": [51, true], "aps.15.29": [52, true], "aps.15.30": [51, true]}}, "CHA": {"total": 3924, "solved": 40, "n": 45, "over": 5, "per": {"fun1.1": [58, true], "fun1.2": [62, true], "fun1.3": [63, true], "fun1.4": [62, true], "fun1.5": [71, true], "fun2.1": [59, true], "fun2.2": [75, true], "fun2.3": [83, true], "fun2.4": [98, true], "fun2.5": [105, true], "fun3.1": [32, true], "fun3.2": [32, true], "fun3.3": [37, true], "fun3.4": [37, true], "fun3.5": [43, true], "fun4.1": [65, true], "fun4.2": [69, true], "fun4.3": [95, true], "fun4.4": [106, true], "fun4.5": [122, true], "fun5.1": [92, true], "fun5.2": [94, true], "fun5.3": [96, true], "fun5.4": [103, true], "fun5.5": [104, true], "fun6.1": [84, true], "fun6.2": [80, true], "fun6.3": [82, true], "fun6.4": [85, true], "fun6.5": [88, true], "fun7.1": [11, false], "fun7.2": [13, false], "fun7.3": [10, false], "fun7.4": [7, false], "fun7.5": [18, false], "fun8.1": [63, true], "fun8.2": [63, true], "fun8.3": [63, true], "fun8.4": [69, true], "fun8.5": [72, true], "fun9.1": [60, true], "fun9.2": [55, true], "fun9.3": [63, true], "fun9.4": [63, true], "fun9.5": [71, true]}}}, {"label": "pure.sqrt.derived3.none", "spec": ["pure", "sqrt", "derived3", "none"], "APS": {"total": 9739, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [60, true], "aps.02.00": [60, true], "aps.02.01": [59, true], "aps.02.02": [61, true], "aps.02.03": [65, true], "aps.02.04": [66, true], "aps.02.05": [64, true], "aps.02.06": [66, true], "aps.02.07": [66, true], "aps.02.08": [66, true], "aps.02.09": [66, true], "aps.03.00": [61, true], "aps.03.01": [67, true], "aps.03.02": [69, true], "aps.04.00": [61, true], "aps.04.01": [61, true], "aps.04.02": [58, true], "aps.04.03": [58, true], "aps.04.04": [64, true], "aps.04.05": [62, true], "aps.04.06": [60, true], "aps.04.07": [61, true], "aps.04.08": [62, true], "aps.04.09": [63, true], "aps.04.10": [59, true], "aps.04.11": [65, true], "aps.04.12": [61, true], "aps.04.13": [66, true], "aps.05.00": [60, true], "aps.06.00": [60, true], "aps.06.01": [60, true], "aps.06.02": [60, true], "aps.06.03": [60, true], "aps.06.04": [60, true], "aps.06.05": [61, true], "aps.06.06": [61, true], "aps.06.07": [61, true], "aps.06.08": [61, true], "aps.06.09": [61, true], "aps.07.00": [58, true], "aps.07.01": [56, true], "aps.07.02": [55, true], "aps.08.00": [60, true], "aps.08.01": [59, true], "aps.08.02": [57, true], "aps.08.03": [56, true], "aps.08.04": [57, true], "aps.09.00": [60, true], "aps.09.01": [60, true], "aps.09.02": [56, true], "aps.09.03": [55, true], "aps.09.04": [49, true], "aps.09.05": [45, true], "aps.09.06": [43, true], "aps.10.00": [60, true], "aps.10.01": [57, true], "aps.10.02": [57, true], "aps.10.03": [57, true], "aps.10.04": [55, true], "aps.11.00": [59, true], "aps.11.01": [58, true], "aps.11.02": [56, true], "aps.11.03": [57, true], "aps.12.00": [67, true], "aps.12.01": [68, true], "aps.12.02": [68, true], "aps.12.03": [69, true], "aps.12.04": [69, true], "aps.12.05": [69, true], "aps.12.06": [69, true], "aps.12.07": [68, true], "aps.12.08": [64, true], "aps.12.09": [65, true], "aps.12.10": [66, true], "aps.12.11": [66, true], "aps.12.12": [67, true], "aps.12.13": [67, true], "aps.12.14": [67, true], "aps.12.15": [67, true], "aps.12.16": [68, true], "aps.12.17": [68, true], "aps.12.18": [68, true], "aps.13.00": [50, false], "aps.14.00": [66, true], "aps.14.01": [66, true], "aps.14.02": [66, true], "aps.14.03": [66, true], "aps.14.04": [66, true], "aps.14.05": [66, true], "aps.14.06": [66, true], "aps.14.07": [66, true], "aps.14.08": [66, true], "aps.14.09": [66, true], "aps.14.10": [66, true], "aps.14.11": [66, true], "aps.14.12": [66, true], "aps.14.13": [66, true], "aps.14.14": [66, true], "aps.14.15": [66, true], "aps.14.16": [66, true], "aps.14.17": [66, true], "aps.14.18": [66, true], "aps.14.19": [66, true], "aps.14.20": [66, true], "aps.14.21": [66, true], "aps.14.22": [66, true], "aps.14.23": [66, true], "aps.14.24": [66, true], "aps.14.25": [66, true], "aps.14.26": [66, true], "aps.14.27": [66, true], "aps.14.28": [66, true], "aps.14.29": [66, true], "aps.14.30": [66, true], "aps.14.31": [66, true], "aps.14.32": [66, true], "aps.14.33": [66, true], "aps.14.34": [66, true], "aps.14.35": [66, true], "aps.14.36": [66, true], "aps.14.37": [66, true], "aps.14.38": [66, true], "aps.14.39": [66, true], "aps.15.00": [59, true], "aps.15.01": [56, true], "aps.15.02": [58, true], "aps.15.03": [59, true], "aps.15.04": [60, true], "aps.15.05": [60, true], "aps.15.06": [61, true], "aps.15.07": [61, true], "aps.15.08": [61, true], "aps.15.09": [61, true], "aps.15.10": [61, true], "aps.15.11": [61, true], "aps.15.12": [61, true], "aps.15.13": [61, true], "aps.15.14": [61, true], "aps.15.15": [61, true], "aps.15.16": [61, true], "aps.15.17": [61, true], "aps.15.18": [61, true], "aps.15.19": [61, true], "aps.15.20": [61, true], "aps.15.21": [57, true], "aps.15.22": [61, true], "aps.15.23": [57, true], "aps.15.24": [59, true], "aps.15.25": [61, true], "aps.15.26": [62, true], "aps.15.27": [62, true], "aps.15.28": [61, true], "aps.15.29": [60, true], "aps.15.30": [48, true]}}, "CHA": {"total": 3852, "solved": 40, "n": 45, "over": 4, "per": {"fun1.1": [58, true], "fun1.2": [56, true], "fun1.3": [63, true], "fun1.4": [70, true], "fun1.5": [86, true], "fun2.1": [59, true], "fun2.2": [76, true], "fun2.3": [80, true], "fun2.4": [98, true], "fun2.5": [105, true], "fun3.1": [32, true], "fun3.2": [32, true], "fun3.3": [39, true], "fun3.4": [47, true], "fun3.5": [54, true], "fun4.1": [41, true], "fun4.2": [41, true], "fun4.3": [48, true], "fun4.4": [57, true], "fun4.5": [66, true], "fun5.1": [55, true], "fun5.2": [77, true], "fun5.3": [74, true], "fun5.4": [74, true], "fun5.5": [74, true], "fun6.1": [75, true], "fun6.2": [134, true], "fun6.3": [143, true], "fun6.4": [150, true], "fun6.5": [151, true], "fun7.1": [50, false], "fun7.2": [163, false], "fun7.3": [47, false], "fun7.4": [7, false], "fun7.5": [43, false], "fun8.1": [62, true], "fun8.2": [54, true], "fun8.3": [63, true], "fun8.4": [66, true], "fun8.5": [67, true], "fun9.1": [60, true], "fun9.2": [55, true], "fun9.3": [63, true], "fun9.4": [65, true], "fun9.5": [82, true]}}}, {"label": "pure.sqrt.derived3.project", "spec": ["pure", "sqrt", "derived3", "project"], "APS": {"total": 9739, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [60, true], "aps.02.00": [60, true], "aps.02.01": [59, true], "aps.02.02": [61, true], "aps.02.03": [65, true], "aps.02.04": [66, true], "aps.02.05": [64, true], "aps.02.06": [66, true], "aps.02.07": [66, true], "aps.02.08": [66, true], "aps.02.09": [66, true], "aps.03.00": [61, true], "aps.03.01": [67, true], "aps.03.02": [69, true], "aps.04.00": [61, true], "aps.04.01": [61, true], "aps.04.02": [58, true], "aps.04.03": [58, true], "aps.04.04": [64, true], "aps.04.05": [62, true], "aps.04.06": [60, true], "aps.04.07": [61, true], "aps.04.08": [62, true], "aps.04.09": [63, true], "aps.04.10": [59, true], "aps.04.11": [65, true], "aps.04.12": [61, true], "aps.04.13": [66, true], "aps.05.00": [60, true], "aps.06.00": [60, true], "aps.06.01": [60, true], "aps.06.02": [60, true], "aps.06.03": [60, true], "aps.06.04": [60, true], "aps.06.05": [61, true], "aps.06.06": [61, true], "aps.06.07": [61, true], "aps.06.08": [61, true], "aps.06.09": [61, true], "aps.07.00": [58, true], "aps.07.01": [56, true], "aps.07.02": [55, true], "aps.08.00": [60, true], "aps.08.01": [59, true], "aps.08.02": [57, true], "aps.08.03": [56, true], "aps.08.04": [57, true], "aps.09.00": [60, true], "aps.09.01": [60, true], "aps.09.02": [56, true], "aps.09.03": [55, true], "aps.09.04": [49, true], "aps.09.05": [45, true], "aps.09.06": [43, true], "aps.10.00": [60, true], "aps.10.01": [57, true], "aps.10.02": [57, true], "aps.10.03": [57, true], "aps.10.04": [55, true], "aps.11.00": [59, true], "aps.11.01": [58, true], "aps.11.02": [56, true], "aps.11.03": [57, true], "aps.12.00": [67, true], "aps.12.01": [68, true], "aps.12.02": [68, true], "aps.12.03": [69, true], "aps.12.04": [69, true], "aps.12.05": [69, true], "aps.12.06": [69, true], "aps.12.07": [68, true], "aps.12.08": [64, true], "aps.12.09": [65, true], "aps.12.10": [66, true], "aps.12.11": [66, true], "aps.12.12": [67, true], "aps.12.13": [67, true], "aps.12.14": [67, true], "aps.12.15": [67, true], "aps.12.16": [68, true], "aps.12.17": [68, true], "aps.12.18": [68, true], "aps.13.00": [50, false], "aps.14.00": [66, true], "aps.14.01": [66, true], "aps.14.02": [66, true], "aps.14.03": [66, true], "aps.14.04": [66, true], "aps.14.05": [66, true], "aps.14.06": [66, true], "aps.14.07": [66, true], "aps.14.08": [66, true], "aps.14.09": [66, true], "aps.14.10": [66, true], "aps.14.11": [66, true], "aps.14.12": [66, true], "aps.14.13": [66, true], "aps.14.14": [66, true], "aps.14.15": [66, true], "aps.14.16": [66, true], "aps.14.17": [66, true], "aps.14.18": [66, true], "aps.14.19": [66, true], "aps.14.20": [66, true], "aps.14.21": [66, true], "aps.14.22": [66, true], "aps.14.23": [66, true], "aps.14.24": [66, true], "aps.14.25": [66, true], "aps.14.26": [66, true], "aps.14.27": [66, true], "aps.14.28": [66, true], "aps.14.29": [66, true], "aps.14.30": [66, true], "aps.14.31": [66, true], "aps.14.32": [66, true], "aps.14.33": [66, true], "aps.14.34": [66, true], "aps.14.35": [66, true], "aps.14.36": [66, true], "aps.14.37": [66, true], "aps.14.38": [66, true], "aps.14.39": [66, true], "aps.15.00": [59, true], "aps.15.01": [56, true], "aps.15.02": [58, true], "aps.15.03": [59, true], "aps.15.04": [60, true], "aps.15.05": [60, true], "aps.15.06": [61, true], "aps.15.07": [61, true], "aps.15.08": [61, true], "aps.15.09": [61, true], "aps.15.10": [61, true], "aps.15.11": [61, true], "aps.15.12": [61, true], "aps.15.13": [61, true], "aps.15.14": [61, true], "aps.15.15": [61, true], "aps.15.16": [61, true], "aps.15.17": [61, true], "aps.15.18": [61, true], "aps.15.19": [61, true], "aps.15.20": [61, true], "aps.15.21": [57, true], "aps.15.22": [61, true], "aps.15.23": [57, true], "aps.15.24": [59, true], "aps.15.25": [61, true], "aps.15.26": [62, true], "aps.15.27": [62, true], "aps.15.28": [61, true], "aps.15.29": [60, true], "aps.15.30": [48, true]}}, "CHA": {"total": 3642, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [56, true], "fun1.3": [63, true], "fun1.4": [70, true], "fun1.5": [86, true], "fun2.1": [59, true], "fun2.2": [76, true], "fun2.3": [80, true], "fun2.4": [98, true], "fun2.5": [105, true], "fun3.1": [32, true], "fun3.2": [32, true], "fun3.3": [39, true], "fun3.4": [47, true], "fun3.5": [54, true], "fun4.1": [41, true], "fun4.2": [41, true], "fun4.3": [48, true], "fun4.4": [57, true], "fun4.5": [66, true], "fun5.1": [55, true], "fun5.2": [77, true], "fun5.3": [74, true], "fun5.4": [74, true], "fun5.5": [74, true], "fun6.1": [75, true], "fun6.2": [88, true], "fun6.3": [90, true], "fun6.4": [94, true], "fun6.5": [96, true], "fun7.1": [50, false], "fun7.2": [50, false], "fun7.3": [47, false], "fun7.4": [7, false], "fun7.5": [43, false], "fun8.1": [62, true], "fun8.2": [54, true], "fun8.3": [63, true], "fun8.4": [66, true], "fun8.5": [67, true], "fun9.1": [60, true], "fun9.2": [55, true], "fun9.3": [63, true], "fun9.4": [65, true], "fun9.5": [82, true]}}}, {"label": "pure.sqrt.derived3.both", "spec": ["pure", "sqrt", "derived3", "both"], "APS": {"total": 8646, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [52, true], "aps.02.00": [54, true], "aps.02.01": [74, true], "aps.02.02": [58, true], "aps.02.03": [72, true], "aps.02.04": [64, true], "aps.02.05": [60, true], "aps.02.06": [61, true], "aps.02.07": [58, true], "aps.02.08": [56, true], "aps.02.09": [60, true], "aps.03.00": [58, true], "aps.03.01": [64, true], "aps.03.02": [58, true], "aps.04.00": [56, true], "aps.04.01": [55, true], "aps.04.02": [54, true], "aps.04.03": [53, true], "aps.04.04": [59, true], "aps.04.05": [53, true], "aps.04.06": [56, true], "aps.04.07": [56, true], "aps.04.08": [61, true], "aps.04.09": [53, true], "aps.04.10": [59, true], "aps.04.11": [55, true], "aps.04.12": [54, true], "aps.04.13": [54, true], "aps.05.00": [70, true], "aps.06.00": [54, true], "aps.06.01": [53, true], "aps.06.02": [68, true], "aps.06.03": [52, true], "aps.06.04": [68, true], "aps.06.05": [64, true], "aps.06.06": [64, true], "aps.06.07": [56, true], "aps.06.08": [64, true], "aps.06.09": [55, true], "aps.07.00": [55, true], "aps.07.01": [54, true], "aps.07.02": [62, true], "aps.08.00": [3, true], "aps.08.01": [50, true], "aps.08.02": [47, true], "aps.08.03": [52, true], "aps.08.04": [53, true], "aps.09.00": [52, true], "aps.09.01": [51, true], "aps.09.02": [58, true], "aps.09.03": [75, true], "aps.09.04": [52, true], "aps.09.05": [70, true], "aps.09.06": [42, true], "aps.10.00": [63, true], "aps.10.01": [53, true], "aps.10.02": [55, true], "aps.10.03": [72, true], "aps.10.04": [52, true], "aps.11.00": [58, true], "aps.11.01": [55, true], "aps.11.02": [50, true], "aps.11.03": [49, true], "aps.12.00": [60, true], "aps.12.01": [66, true], "aps.12.02": [63, true], "aps.12.03": [61, true], "aps.12.04": [62, true], "aps.12.05": [61, true], "aps.12.06": [79, true], "aps.12.07": [62, true], "aps.12.08": [61, true], "aps.12.09": [60, true], "aps.12.10": [61, true], "aps.12.11": [65, true], "aps.12.12": [62, true], "aps.12.13": [67, true], "aps.12.14": [60, true], "aps.12.15": [62, true], "aps.12.16": [59, true], "aps.12.17": [59, true], "aps.12.18": [59, true], "aps.13.00": [7, false], "aps.14.00": [56, true], "aps.14.01": [56, true], "aps.14.02": [56, true], "aps.14.03": [56, true], "aps.14.04": [56, true], "aps.14.05": [56, true], "aps.14.06": [56, true], "aps.14.07": [56, true], "aps.14.08": [56, true], "aps.14.09": [56, true], "aps.14.10": [56, true], "aps.14.11": [56, true], "aps.14.12": [56, true], "aps.14.13": [56, true], "aps.14.14": [56, true], "aps.14.15": [56, true], "aps.14.16": [56, true], "aps.14.17": [56, true], "aps.14.18": [56, true], "aps.14.19": [56, true], "aps.14.20": [56, true], "aps.14.21": [56, true], "aps.14.22": [56, true], "aps.14.23": [56, true], "aps.14.24": [56, true], "aps.14.25": [56, true], "aps.14.26": [56, true], "aps.14.27": [56, true], "aps.14.28": [56, true], "aps.14.29": [56, true], "aps.14.30": [56, true], "aps.14.31": [56, true], "aps.14.32": [56, true], "aps.14.33": [56, true], "aps.14.34": [56, true], "aps.14.35": [56, true], "aps.14.36": [56, true], "aps.14.37": [56, true], "aps.14.38": [56, true], "aps.14.39": [56, true], "aps.15.00": [49, true], "aps.15.01": [45, true], "aps.15.02": [46, true], "aps.15.03": [45, true], "aps.15.04": [45, true], "aps.15.05": [45, true], "aps.15.06": [46, true], "aps.15.07": [48, true], "aps.15.08": [46, true], "aps.15.09": [45, true], "aps.15.10": [46, true], "aps.15.11": [49, true], "aps.15.12": [46, true], "aps.15.13": [49, true], "aps.15.14": [51, true], "aps.15.15": [46, true], "aps.15.16": [45, true], "aps.15.17": [49, true], "aps.15.18": [45, true], "aps.15.19": [47, true], "aps.15.20": [44, true], "aps.15.21": [47, true], "aps.15.22": [46, true], "aps.15.23": [49, true], "aps.15.24": [50, true], "aps.15.25": [45, true], "aps.15.26": [48, true], "aps.15.27": [47, true], "aps.15.28": [43, true], "aps.15.29": [42, true], "aps.15.30": [45, true]}}, "CHA": {"total": 3737, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [54, true], "fun1.2": [54, true], "fun1.3": [65, true], "fun1.4": [69, true], "fun1.5": [103, true], "fun2.1": [50, true], "fun2.2": [67, true], "fun2.3": [78, true], "fun2.4": [85, true], "fun2.5": [96, true], "fun3.1": [56, true], "fun3.2": [57, true], "fun3.3": [72, true], "fun3.4": [78, true], "fun3.5": [90, true], "fun4.1": [66, true], "fun4.2": [67, true], "fun4.3": [83, true], "fun4.4": [91, true], "fun4.5": [113, true], "fun5.1": [68, true], "fun5.2": [70, true], "fun5.3": [75, true], "fun5.4": [79, true], "fun5.5": [80, true], "fun6.1": [61, true], "fun6.2": [63, true], "fun6.3": [63, true], "fun6.4": [66, true], "fun6.5": [67, true], "fun7.1": [7, false], "fun7.2": [7, false], "fun7.3": [10, false], "fun7.4": [11, false], "fun7.5": [15, false], "fun8.1": [54, true], "fun8.2": [53, true], "fun8.3": [55, true], "fun8.4": [60, true], "fun8.5": [60, true], "fun9.1": [51, true], "fun9.2": [50, true], "fun9.3": [57, true], "fun9.4": [54, true], "fun9.5": [57, true]}}}, {"label": "pure.sqrt.derived.project", "spec": ["pure", "sqrt", "derived", "project"], "APS": {"total": 9912, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [60, true], "aps.02.00": [58, true], "aps.02.01": [62, true], "aps.02.02": [58, true], "aps.02.03": [64, true], "aps.02.04": [65, true], "aps.02.05": [65, true], "aps.02.06": [65, true], "aps.02.07": [65, true], "aps.02.08": [66, true], "aps.02.09": [66, true], "aps.03.00": [76, true], "aps.03.01": [67, true], "aps.03.02": [69, true], "aps.04.00": [66, true], "aps.04.01": [62, true], "aps.04.02": [64, true], "aps.04.03": [62, true], "aps.04.04": [66, true], "aps.04.05": [61, true], "aps.04.06": [64, true], "aps.04.07": [66, true], "aps.04.08": [64, true], "aps.04.09": [63, true], "aps.04.10": [64, true], "aps.04.11": [66, true], "aps.04.12": [64, true], "aps.04.13": [69, true], "aps.05.00": [59, true], "aps.06.00": [60, true], "aps.06.01": [59, true], "aps.06.02": [56, true], "aps.06.03": [59, true], "aps.06.04": [58, true], "aps.06.05": [58, true], "aps.06.06": [58, true], "aps.06.07": [56, true], "aps.06.08": [58, true], "aps.06.09": [54, true], "aps.07.00": [57, true], "aps.07.01": [52, true], "aps.07.02": [49, true], "aps.08.00": [60, true], "aps.08.01": [59, true], "aps.08.02": [59, true], "aps.08.03": [59, true], "aps.08.04": [58, true], "aps.09.00": [57, true], "aps.09.01": [58, true], "aps.09.02": [54, true], "aps.09.03": [52, true], "aps.09.04": [48, true], "aps.09.05": [42, true], "aps.09.06": [40, true], "aps.10.00": [60, true], "aps.10.01": [59, true], "aps.10.02": [58, true], "aps.10.03": [56, true], "aps.10.04": [53, true], "aps.11.00": [62, true], "aps.11.01": [61, true], "aps.11.02": [60, true], "aps.11.03": [58, true], "aps.12.00": [62, true], "aps.12.01": [63, true], "aps.12.02": [61, true], "aps.12.03": [64, true], "aps.12.04": [65, true], "aps.12.05": [66, true], "aps.12.06": [66, true], "aps.12.07": [65, true], "aps.12.08": [67, true], "aps.12.09": [67, true], "aps.12.10": [66, true], "aps.12.11": [65, true], "aps.12.12": [64, true], "aps.12.13": [65, true], "aps.12.14": [68, true], "aps.12.15": [69, true], "aps.12.16": [69, true], "aps.12.17": [69, true], "aps.12.18": [69, true], "aps.13.00": [52, false], "aps.14.00": [69, true], "aps.14.01": [69, true], "aps.14.02": [69, true], "aps.14.03": [69, true], "aps.14.04": [69, true], "aps.14.05": [69, true], "aps.14.06": [69, true], "aps.14.07": [69, true], "aps.14.08": [69, true], "aps.14.09": [69, true], "aps.14.10": [69, true], "aps.14.11": [69, true], "aps.14.12": [69, true], "aps.14.13": [69, true], "aps.14.14": [69, true], "aps.14.15": [69, true], "aps.14.16": [69, true], "aps.14.17": [69, true], "aps.14.18": [69, true], "aps.14.19": [69, true], "aps.14.20": [69, true], "aps.14.21": [69, true], "aps.14.22": [69, true], "aps.14.23": [69, true], "aps.14.24": [69, true], "aps.14.25": [69, true], "aps.14.26": [69, true], "aps.14.27": [69, true], "aps.14.28": [69, true], "aps.14.29": [69, true], "aps.14.30": [69, true], "aps.14.31": [69, true], "aps.14.32": [69, true], "aps.14.33": [69, true], "aps.14.34": [69, true], "aps.14.35": [69, true], "aps.14.36": [69, true], "aps.14.37": [69, true], "aps.14.38": [69, true], "aps.14.39": [69, true], "aps.15.00": [62, true], "aps.15.01": [62, true], "aps.15.02": [63, true], "aps.15.03": [64, true], "aps.15.04": [64, true], "aps.15.05": [64, true], "aps.15.06": [63, true], "aps.15.07": [63, true], "aps.15.08": [63, true], "aps.15.09": [63, true], "aps.15.10": [62, true], "aps.15.11": [62, true], "aps.15.12": [62, true], "aps.15.13": [62, true], "aps.15.14": [61, true], "aps.15.15": [61, true], "aps.15.16": [61, true], "aps.15.17": [60, true], "aps.15.18": [60, true], "aps.15.19": [58, true], "aps.15.20": [54, true], "aps.15.21": [60, true], "aps.15.22": [61, true], "aps.15.23": [63, true], "aps.15.24": [61, true], "aps.15.25": [64, true], "aps.15.26": [64, true], "aps.15.27": [65, true], "aps.15.28": [65, true], "aps.15.29": [66, true], "aps.15.30": [66, true]}}, "CHA": {"total": 3511, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [63, true], "fun1.3": [66, true], "fun1.4": [76, true], "fun1.5": [84, true], "fun2.1": [60, true], "fun2.2": [78, true], "fun2.3": [80, true], "fun2.4": [89, true], "fun2.5": [100, true], "fun3.1": [33, true], "fun3.2": [33, true], "fun3.3": [40, true], "fun3.4": [48, true], "fun3.5": [53, true], "fun4.1": [39, true], "fun4.2": [39, true], "fun4.3": [54, true], "fun4.4": [63, true], "fun4.5": [78, true], "fun5.1": [48, true], "fun5.2": [62, true], "fun5.3": [56, true], "fun5.4": [56, true], "fun5.5": [56, true], "fun6.1": [64, true], "fun6.2": [65, true], "fun6.3": [79, true], "fun6.4": [81, true], "fun6.5": [82, true], "fun7.1": [52, false], "fun7.2": [83, false], "fun7.3": [18, false], "fun7.4": [58, false], "fun7.5": [9, false], "fun8.1": [58, true], "fun8.2": [61, true], "fun8.3": [65, true], "fun8.4": [67, true], "fun8.5": [68, true], "fun9.1": [60, true], "fun9.2": [57, true], "fun9.3": [62, true], "fun9.4": [59, true], "fun9.5": [71, true]}}}, {"label": "pure.sqrt.derived3.safe", "spec": ["pure", "sqrt", "derived3", "safe"], "APS": {"total": 9292, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [60, true], "aps.02.00": [62, true], "aps.02.01": [63, true], "aps.02.02": [63, true], "aps.02.03": [65, true], "aps.02.04": [63, true], "aps.02.05": [64, true], "aps.02.06": [65, true], "aps.02.07": [64, true], "aps.02.08": [64, true], "aps.02.09": [65, true], "aps.03.00": [70, true], "aps.03.01": [68, true], "aps.03.02": [68, true], "aps.04.00": [61, true], "aps.04.01": [63, true], "aps.04.02": [64, true], "aps.04.03": [62, true], "aps.04.04": [63, true], "aps.04.05": [62, true], "aps.04.06": [60, true], "aps.04.07": [65, true], "aps.04.08": [66, true], "aps.04.09": [57, true], "aps.04.10": [62, true], "aps.04.11": [63, true], "aps.04.12": [64, true], "aps.04.13": [64, true], "aps.05.00": [60, true], "aps.06.00": [58, true], "aps.06.01": [59, true], "aps.06.02": [59, true], "aps.06.03": [59, true], "aps.06.04": [59, true], "aps.06.05": [57, true], "aps.06.06": [54, true], "aps.06.07": [55, true], "aps.06.08": [60, true], "aps.06.09": [60, true], "aps.07.00": [59, true], "aps.07.01": [58, true], "aps.07.02": [56, true], "aps.08.00": [3, true], "aps.08.01": [58, true], "aps.08.02": [54, true], "aps.08.03": [57, true], "aps.08.04": [55, true], "aps.09.00": [59, true], "aps.09.01": [59, true], "aps.09.02": [57, true], "aps.09.03": [55, true], "aps.09.04": [50, true], "aps.09.05": [45, true], "aps.09.06": [42, true], "aps.10.00": [59, true], "aps.10.01": [56, true], "aps.10.02": [54, true], "aps.10.03": [56, true], "aps.10.04": [58, true], "aps.11.00": [59, true], "aps.11.01": [58, true], "aps.11.02": [55, true], "aps.11.03": [57, true], "aps.12.00": [67, true], "aps.12.01": [68, true], "aps.12.02": [68, true], "aps.12.03": [69, true], "aps.12.04": [66, true], "aps.12.05": [67, true], "aps.12.06": [67, true], "aps.12.07": [67, true], "aps.12.08": [68, true], "aps.12.09": [67, true], "aps.12.10": [67, true], "aps.12.11": [67, true], "aps.12.12": [67, true], "aps.12.13": [67, true], "aps.12.14": [68, true], "aps.12.15": [68, true], "aps.12.16": [68, true], "aps.12.17": [68, true], "aps.12.18": [68, true], "aps.13.00": [11, false], "aps.14.00": [64, true], "aps.14.01": [64, true], "aps.14.02": [64, true], "aps.14.03": [64, true], "aps.14.04": [64, true], "aps.14.05": [64, true], "aps.14.06": [64, true], "aps.14.07": [64, true], "aps.14.08": [64, true], "aps.14.09": [64, true], "aps.14.10": [64, true], "aps.14.11": [64, true], "aps.14.12": [64, true], "aps.14.13": [64, true], "aps.14.14": [64, true], "aps.14.15": [64, true], "aps.14.16": [64, true], "aps.14.17": [64, true], "aps.14.18": [64, true], "aps.14.19": [64, true], "aps.14.20": [64, true], "aps.14.21": [64, true], "aps.14.22": [64, true], "aps.14.23": [64, true], "aps.14.24": [64, true], "aps.14.25": [64, true], "aps.14.26": [64, true], "aps.14.27": [64, true], "aps.14.28": [64, true], "aps.14.29": [64, true], "aps.14.30": [64, true], "aps.14.31": [64, true], "aps.14.32": [64, true], "aps.14.33": [64, true], "aps.14.34": [64, true], "aps.14.35": [64, true], "aps.14.36": [64, true], "aps.14.37": [64, true], "aps.14.38": [64, true], "aps.14.39": [64, true], "aps.15.00": [47, true], "aps.15.01": [49, true], "aps.15.02": [50, true], "aps.15.03": [50, true], "aps.15.04": [51, true], "aps.15.05": [51, true], "aps.15.06": [51, true], "aps.15.07": [51, true], "aps.15.08": [51, true], "aps.15.09": [51, true], "aps.15.10": [51, true], "aps.15.11": [50, true], "aps.15.12": [50, true], "aps.15.13": [50, true], "aps.15.14": [50, true], "aps.15.15": [50, true], "aps.15.16": [50, true], "aps.15.17": [50, true], "aps.15.18": [50, true], "aps.15.19": [50, true], "aps.15.20": [50, true], "aps.15.21": [52, true], "aps.15.22": [48, true], "aps.15.23": [50, true], "aps.15.24": [51, true], "aps.15.25": [49, true], "aps.15.26": [45, true], "aps.15.27": [49, true], "aps.15.28": [51, true], "aps.15.29": [52, true], "aps.15.30": [51, true]}}, "CHA": {"total": 3891, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [62, true], "fun1.3": [63, true], "fun1.4": [62, true], "fun1.5": [71, true], "fun2.1": [59, true], "fun2.2": [75, true], "fun2.3": [83, true], "fun2.4": [98, true], "fun2.5": [105, true], "fun3.1": [32, true], "fun3.2": [32, true], "fun3.3": [37, true], "fun3.4": [37, true], "fun3.5": [43, true], "fun4.1": [65, true], "fun4.2": [69, true], "fun4.3": [95, true], "fun4.4": [106, true], "fun4.5": [122, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [84, true], "fun6.2": [80, true], "fun6.3": [82, true], "fun6.4": [85, true], "fun6.5": [88, true], "fun7.1": [11, false], "fun7.2": [13, false], "fun7.3": [10, false], "fun7.4": [7, false], "fun7.5": [18, false], "fun8.1": [63, true], "fun8.2": [63, true], "fun8.3": [63, true], "fun8.4": [69, true], "fun8.5": [72, true], "fun9.1": [60, true], "fun9.2": [55, true], "fun9.3": [63, true], "fun9.4": [63, true], "fun9.5": [71, true]}}}, {"label": "pure.sqrt.derived.safe", "spec": ["pure", "sqrt", "derived", "safe"], "APS": {"total": 9588, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [60, true], "aps.02.00": [60, true], "aps.02.01": [61, true], "aps.02.02": [60, true], "aps.02.03": [62, true], "aps.02.04": [63, true], "aps.02.05": [63, true], "aps.02.06": [63, true], "aps.02.07": [64, true], "aps.02.08": [65, true], "aps.02.09": [65, true], "aps.03.00": [66, true], "aps.03.01": [65, true], "aps.03.02": [61, true], "aps.04.00": [59, true], "aps.04.01": [59, true], "aps.04.02": [64, true], "aps.04.03": [61, true], "aps.04.04": [64, true], "aps.04.05": [61, true], "aps.04.06": [59, true], "aps.04.07": [64, true], "aps.04.08": [63, true], "aps.04.09": [62, true], "aps.04.10": [62, true], "aps.04.11": [60, true], "aps.04.12": [60, true], "aps.04.13": [58, true], "aps.05.00": [60, true], "aps.06.00": [58, true], "aps.06.01": [59, true], "aps.06.02": [58, true], "aps.06.03": [52, true], "aps.06.04": [58, true], "aps.06.05": [55, true], "aps.06.06": [54, true], "aps.06.07": [57, true], "aps.06.08": [54, true], "aps.06.09": [56, true], "aps.07.00": [54, true], "aps.07.01": [49, true], "aps.07.02": [43, true], "aps.08.00": [3, true], "aps.08.01": [58, true], "aps.08.02": [58, true], "aps.08.03": [56, true], "aps.08.04": [58, true], "aps.09.00": [58, true], "aps.09.01": [56, true], "aps.09.02": [55, true], "aps.09.03": [53, true], "aps.09.04": [49, true], "aps.09.05": [43, true], "aps.09.06": [41, true], "aps.10.00": [59, true], "aps.10.01": [56, true], "aps.10.02": [54, true], "aps.10.03": [54, true], "aps.10.04": [53, true], "aps.11.00": [58, true], "aps.11.01": [57, true], "aps.11.02": [58, true], "aps.11.03": [58, true], "aps.12.00": [62, true], "aps.12.01": [63, true], "aps.12.02": [61, true], "aps.12.03": [64, true], "aps.12.04": [64, true], "aps.12.05": [58, true], "aps.12.06": [65, true], "aps.12.07": [68, true], "aps.12.08": [66, true], "aps.12.09": [69, true], "aps.12.10": [69, true], "aps.12.11": [69, true], "aps.12.12": [68, true], "aps.12.13": [68, true], "aps.12.14": [65, true], "aps.12.15": [62, true], "aps.12.16": [65, true], "aps.12.17": [66, true], "aps.12.18": [67, true], "aps.13.00": [12, false], "aps.14.00": [66, true], "aps.14.01": [66, true], "aps.14.02": [66, true], "aps.14.03": [66, true], "aps.14.04": [66, true], "aps.14.05": [66, true], "aps.14.06": [66, true], "aps.14.07": [66, true], "aps.14.08": [66, true], "aps.14.09": [66, true], "aps.14.10": [66, true], "aps.14.11": [66, true], "aps.14.12": [66, true], "aps.14.13": [66, true], "aps.14.14": [66, true], "aps.14.15": [66, true], "aps.14.16": [66, true], "aps.14.17": [66, true], "aps.14.18": [66, true], "aps.14.19": [66, true], "aps.14.20": [66, true], "aps.14.21": [66, true], "aps.14.22": [66, true], "aps.14.23": [66, true], "aps.14.24": [66, true], "aps.14.25": [66, true], "aps.14.26": [66, true], "aps.14.27": [66, true], "aps.14.28": [66, true], "aps.14.29": [66, true], "aps.14.30": [66, true], "aps.14.31": [66, true], "aps.14.32": [66, true], "aps.14.33": [66, true], "aps.14.34": [66, true], "aps.14.35": [66, true], "aps.14.36": [66, true], "aps.14.37": [66, true], "aps.14.38": [66, true], "aps.14.39": [66, true], "aps.15.00": [64, true], "aps.15.01": [64, true], "aps.15.02": [64, true], "aps.15.03": [64, true], "aps.15.04": [63, true], "aps.15.05": [63, true], "aps.15.06": [62, true], "aps.15.07": [62, true], "aps.15.08": [61, true], "aps.15.09": [59, true], "aps.15.10": [57, true], "aps.15.11": [60, true], "aps.15.12": [61, true], "aps.15.13": [61, true], "aps.15.14": [62, true], "aps.15.15": [62, true], "aps.15.16": [62, true], "aps.15.17": [62, true], "aps.15.18": [62, true], "aps.15.19": [63, true], "aps.15.20": [63, true], "aps.15.21": [65, true], "aps.15.22": [61, true], "aps.15.23": [62, true], "aps.15.24": [61, true], "aps.15.25": [59, true], "aps.15.26": [58, true], "aps.15.27": [61, true], "aps.15.28": [61, true], "aps.15.29": [62, true], "aps.15.30": [62, true]}}, "CHA": {"total": 3493, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [58, true], "fun1.2": [62, true], "fun1.3": [64, true], "fun1.4": [68, true], "fun1.5": [83, true], "fun2.1": [58, true], "fun2.2": [76, true], "fun2.3": [79, true], "fun2.4": [89, true], "fun2.5": [100, true], "fun3.1": [31, true], "fun3.2": [32, true], "fun3.3": [42, true], "fun3.4": [45, true], "fun3.5": [52, true], "fun4.1": [41, true], "fun4.2": [43, true], "fun4.3": [53, true], "fun4.4": [56, true], "fun4.5": [98, true], "fun5.1": [48, true], "fun5.2": [61, true], "fun5.3": [46, true], "fun5.4": [50, true], "fun5.5": [53, true], "fun6.1": [52, true], "fun6.2": [81, true], "fun6.3": [79, true], "fun6.4": [85, true], "fun6.5": [88, true], "fun7.1": [12, false], "fun7.2": [14, false], "fun7.3": [10, false], "fun7.4": [15, false], "fun7.5": [9, false], "fun8.1": [58, true], "fun8.2": [61, true], "fun8.3": [63, true], "fun8.4": [66, true], "fun8.5": [69, true], "fun9.1": [59, true], "fun9.2": [57, true], "fun9.3": [60, true], "fun9.4": [61, true], "fun9.5": [66, true]}}}, {"label": "pure.sqrt.start.project", "spec": ["pure", "sqrt", "start", "project"], "APS": {"total": 14434, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [84, true], "aps.02.00": [87, true], "aps.02.01": [89, true], "aps.02.02": [89, true], "aps.02.03": [90, true], "aps.02.04": [91, true], "aps.02.05": [91, true], "aps.02.06": [91, true], "aps.02.07": [90, true], "aps.02.08": [93, true], "aps.02.09": [92, true], "aps.03.00": [49, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [88, true], "aps.04.01": [88, true], "aps.04.02": [88, true], "aps.04.03": [88, true], "aps.04.04": [88, true], "aps.04.05": [89, true], "aps.04.06": [89, true], "aps.04.07": [89, true], "aps.04.08": [88, true], "aps.04.09": [88, true], "aps.04.10": [88, true], "aps.04.11": [88, true], "aps.04.12": [89, true], "aps.04.13": [88, true], "aps.05.00": [84, true], "aps.06.00": [83, true], "aps.06.01": [83, true], "aps.06.02": [83, true], "aps.06.03": [83, true], "aps.06.04": [83, true], "aps.06.05": [82, true], "aps.06.06": [83, true], "aps.06.07": [83, true], "aps.06.08": [83, true], "aps.06.09": [83, true], "aps.07.00": [82, true], "aps.07.01": [83, true], "aps.07.02": [82, true], "aps.08.00": [3, true], "aps.08.01": [83, true], "aps.08.02": [82, true], "aps.08.03": [82, true], "aps.08.04": [83, true], "aps.09.00": [82, true], "aps.09.01": [83, true], "aps.09.02": [83, true], "aps.09.03": [82, true], "aps.09.04": [82, true], "aps.09.05": [82, true], "aps.09.06": [82, true], "aps.10.00": [82, true], "aps.10.01": [82, true], "aps.10.02": [82, true], "aps.10.03": [83, true], "aps.10.04": [82, true], "aps.11.00": [83, true], "aps.11.01": [83, true], "aps.11.02": [83, true], "aps.11.03": [83, true], "aps.12.00": [96, true], "aps.12.01": [97, true], "aps.12.02": [96, true], "aps.12.03": [97, true], "aps.12.04": [97, true], "aps.12.05": [94, true], "aps.12.06": [97, true], "aps.12.07": [97, true], "aps.12.08": [97, true], "aps.12.09": [97, true], "aps.12.10": [96, true], "aps.12.11": [94, true], "aps.12.12": [96, true], "aps.12.13": [97, true], "aps.12.14": [96, true], "aps.12.15": [96, true], "aps.12.16": [97, true], "aps.12.17": [96, true], "aps.12.18": [96, true], "aps.13.00": [52, false], "aps.14.00": [102, true], "aps.14.01": [102, true], "aps.14.02": [102, true], "aps.14.03": [102, true], "aps.14.04": [102, true], "aps.14.05": [102, true], "aps.14.06": [102, true], "aps.14.07": [102, true], "aps.14.08": [102, true], "aps.14.09": [102, true], "aps.14.10": [102, true], "aps.14.11": [102, true], "aps.14.12": [102, true], "aps.14.13": [102, true], "aps.14.14": [102, true], "aps.14.15": [102, true], "aps.14.16": [102, true], "aps.14.17": [102, true], "aps.14.18": [102, true], "aps.14.19": [102, true], "aps.14.20": [102, true], "aps.14.21": [102, true], "aps.14.22": [102, true], "aps.14.23": [102, true], "aps.14.24": [102, true], "aps.14.25": [102, true], "aps.14.26": [102, true], "aps.14.27": [102, true], "aps.14.28": [102, true], "aps.14.29": [102, true], "aps.14.30": [102, true], "aps.14.31": [102, true], "aps.14.32": [102, true], "aps.14.33": [102, true], "aps.14.34": [102, true], "aps.14.35": [102, true], "aps.14.36": [102, true], "aps.14.37": [102, true], "aps.14.38": [102, true], "aps.14.39": [102, true], "aps.15.00": [102, true], "aps.15.01": [103, true], "aps.15.02": [102, true], "aps.15.03": [102, true], "aps.15.04": [102, true], "aps.15.05": [103, true], "aps.15.06": [102, true], "aps.15.07": [103, true], "aps.15.08": [103, true], "aps.15.09": [102, true], "aps.15.10": [103, true], "aps.15.11": [102, true], "aps.15.12": [83, true], "aps.15.13": [103, true], "aps.15.14": [103, true], "aps.15.15": [103, true], "aps.15.16": [103, true], "aps.15.17": [103, true], "aps.15.18": [103, true], "aps.15.19": [102, true], "aps.15.20": [102, true], "aps.15.21": [103, true], "aps.15.22": [103, true], "aps.15.23": [103, true], "aps.15.24": [86, true], "aps.15.25": [102, true], "aps.15.26": [103, true], "aps.15.27": [103, true], "aps.15.28": [102, true], "aps.15.29": [103, true], "aps.15.30": [103, true]}}, "CHA": {"total": 5120, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [83, true], "fun1.2": [90, true], "fun1.3": [97, true], "fun1.4": [113, true], "fun1.5": [152, true], "fun2.1": [82, true], "fun2.2": [110, true], "fun2.3": [122, true], "fun2.4": [150, true], "fun2.5": [162, true], "fun3.1": [89, true], "fun3.2": [93, true], "fun3.3": [113, true], "fun3.4": [124, true], "fun3.5": [153, true], "fun4.1": [88, true], "fun4.2": [93, true], "fun4.3": [113, true], "fun4.4": [125, true], "fun4.5": [153, true], "fun5.1": [88, true], "fun5.2": [88, true], "fun5.3": [90, true], "fun5.4": [94, true], "fun5.5": [96, true], "fun6.1": [89, true], "fun6.2": [89, true], "fun6.3": [91, true], "fun6.4": [95, true], "fun6.5": [97, true], "fun7.1": [52, false], "fun7.2": [50, false], "fun7.3": [54, false], "fun7.4": [57, false], "fun7.5": [8, false], "fun8.1": [84, true], "fun8.2": [86, true], "fun8.3": [90, true], "fun8.4": [93, true], "fun8.5": [97, true], "fun9.1": [82, true], "fun9.2": [87, true], "fun9.3": [90, true], "fun9.4": [92, true], "fun9.5": [97, true]}}}, {"label": "pure.sqrt.derived3.credit", "spec": ["pure", "sqrt", "derived3", "credit"], "APS": {"total": 7710, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [44, true], "aps.02.00": [45, true], "aps.02.01": [46, true], "aps.02.02": [46, true], "aps.02.03": [47, true], "aps.02.04": [47, true], "aps.02.05": [47, true], "aps.02.06": [47, true], "aps.02.07": [47, true], "aps.02.08": [48, true], "aps.02.09": [48, true], "aps.03.00": [49, true], "aps.03.01": [49, true], "aps.03.02": [49, true], "aps.04.00": [46, true], "aps.04.01": [46, true], "aps.04.02": [46, true], "aps.04.03": [46, true], "aps.04.04": [46, true], "aps.04.05": [46, true], "aps.04.06": [46, true], "aps.04.07": [46, true], "aps.04.08": [46, true], "aps.04.09": [46, true], "aps.04.10": [46, true], "aps.04.11": [46, true], "aps.04.12": [46, true], "aps.04.13": [46, true], "aps.05.00": [44, true], "aps.06.00": [43, true], "aps.06.01": [43, true], "aps.06.02": [43, true], "aps.06.03": [43, true], "aps.06.04": [43, true], "aps.06.05": [43, true], "aps.06.06": [43, true], "aps.06.07": [43, true], "aps.06.08": [43, true], "aps.06.09": [43, true], "aps.07.00": [43, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [43, true], "aps.08.01": [43, true], "aps.08.02": [43, true], "aps.08.03": [43, true], "aps.08.04": [43, true], "aps.09.00": [43, true], "aps.09.01": [43, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [43, true], "aps.09.05": [43, true], "aps.09.06": [39, true], "aps.10.00": [43, true], "aps.10.01": [43, true], "aps.10.02": [43, true], "aps.10.03": [43, true], "aps.10.04": [43, true], "aps.11.00": [43, true], "aps.11.01": [43, true], "aps.11.02": [43, true], "aps.11.03": [43, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [50, true], "aps.12.03": [50, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [50, true], "aps.12.08": [50, true], "aps.12.09": [50, true], "aps.12.10": [50, true], "aps.12.11": [50, true], "aps.12.12": [50, true], "aps.12.13": [50, true], "aps.12.14": [50, true], "aps.12.15": [50, true], "aps.12.16": [50, true], "aps.12.17": [50, true], "aps.12.18": [42, true], "aps.13.00": [9, false], "aps.14.00": [53, true], "aps.14.01": [53, true], "aps.14.02": [53, true], "aps.14.03": [53, true], "aps.14.04": [53, true], "aps.14.05": [53, true], "aps.14.06": [53, true], "aps.14.07": [53, true], "aps.14.08": [53, true], "aps.14.09": [53, true], "aps.14.10": [53, true], "aps.14.11": [53, true], "aps.14.12": [53, true], "aps.14.13": [53, true], "aps.14.14": [53, true], "aps.14.15": [53, true], "aps.14.16": [53, true], "aps.14.17": [53, true], "aps.14.18": [53, true], "aps.14.19": [53, true], "aps.14.20": [53, true], "aps.14.21": [53, true], "aps.14.22": [53, true], "aps.14.23": [53, true], "aps.14.24": [53, true], "aps.14.25": [53, true], "aps.14.26": [53, true], "aps.14.27": [53, true], "aps.14.28": [53, true], "aps.14.29": [53, true], "aps.14.30": [53, true], "aps.14.31": [53, true], "aps.14.32": [53, true], "aps.14.33": [53, true], "aps.14.34": [53, true], "aps.14.35": [53, true], "aps.14.36": [53, true], "aps.14.37": [53, true], "aps.14.38": [53, true], "aps.14.39": [53, true], "aps.15.00": [53, true], "aps.15.01": [53, true], "aps.15.02": [53, true], "aps.15.03": [53, true], "aps.15.04": [53, true], "aps.15.05": [53, true], "aps.15.06": [53, true], "aps.15.07": [53, true], "aps.15.08": [53, true], "aps.15.09": [53, true], "aps.15.10": [53, true], "aps.15.11": [53, true], "aps.15.12": [53, true], "aps.15.13": [53, true], "aps.15.14": [53, true], "aps.15.15": [53, true], "aps.15.16": [53, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [53, true], "aps.15.24": [53, true], "aps.15.25": [53, true], "aps.15.26": [53, true], "aps.15.27": [53, true], "aps.15.28": [53, true], "aps.15.29": [53, true], "aps.15.30": [53, true]}}, "CHA": {"total": 3130, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [43, true], "fun1.2": [47, true], "fun1.3": [50, true], "fun1.4": [58, true], "fun1.5": [78, true], "fun2.1": [43, true], "fun2.2": [57, true], "fun2.3": [63, true], "fun2.4": [77, true], "fun2.5": [83, true], "fun3.1": [46, true], "fun3.2": [48, true], "fun3.3": [58, true], "fun3.4": [64, true], "fun3.5": [78, true], "fun4.1": [46, true], "fun4.2": [48, true], "fun4.3": [58, true], "fun4.4": [64, true], "fun4.5": [78, true], "fun5.1": [46, true], "fun5.2": [46, true], "fun5.3": [47, true], "fun5.4": [49, true], "fun5.5": [50, true], "fun6.1": [46, true], "fun6.2": [46, true], "fun6.3": [47, true], "fun6.4": [49, true], "fun6.5": [50, true], "fun7.1": [9, false], "fun7.2": [46, false], "fun7.3": [10, false], "fun7.4": [7, false], "fun7.5": [12, false], "fun8.1": [44, true], "fun8.2": [45, true], "fun8.3": [47, true], "fun8.4": [48, true], "fun8.5": [50, true], "fun9.1": [43, true], "fun9.2": [45, true], "fun9.3": [47, true], "fun9.4": [48, true], "fun9.5": [50, true]}}}] \ No newline at end of file diff --git a/sweep_full.py b/sweep_full.py new file mode 100644 index 0000000..62802fd --- /dev/null +++ b/sweep_full.py @@ -0,0 +1,241 @@ +"""The full sweep: every similarity function x every scale x every safeguard, +over both benchmark sets, against every baseline. + +Purpose. Every claim in the paper so far rests on one configuration +(similarity = ratio) measured on eight hand-picked problems, with only two +configurations carried to the 199-problem benchmark. The convergence law of +stage 0c predicts the behaviour of ALL nine similarity functions; a law +confirmed on eight problems and one configuration is an anecdote. This sweep +is what turns it into evidence, and what would refute it if it is wrong. + +Grid + similarity 9 (ratio sqrt cbrt rational ratio_soft exp_abs + rat_sq exp_sq cosine) + scale 4 (start bracket derived derived3) + safeguard 4 (none step bracket both) + = 144 configurations, plus 10 baselines, over 199 problems. + +Cost model and reporting rules are the same as bench_full.py: evaluations of +f; failures charged the full budget; the 2x-bisection bound checked only on +solved runs; ITP reported both at its recommended constants and as a +per-problem oracle over a (kappa1, n0) grid. + +Run: python -u sweep_full.py full sweep + python -u sweep_full.py --smoke a reduced grid, for the pre-flight +""" +from __future__ import annotations + +import json +import math +import os +import sys +import time +from multiprocessing import Pool + +os.environ.setdefault("OMP_NUM_THREADS", "1") + +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +from simroot.baselines import (anderson_bjorck, best_of, bisection, brent, + brent_scipy, chandrupatla, chandrupatla_scipy, + dekker, illinois, itp, pegasus, regula_falsi, + ridders, toms748) +from simroot.pure import PURE_SIMS, pure_root + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 + +SCALES = ("start", "bracket", "derived", "derived3") +GUARD_MODES = ("none", "step", "bracket", "both", "project", "safe", + "credit") +ITP_GRID = [(fac, n0) for fac in (1.0, 0.1, 0.01, 1e-4) + for n0 in (0, 1, 2, 5)] + + +def load_problems(): + """(set, id, f, a, b, root). Rebuilt inside each worker so nothing that + has to cross a process boundary is a closure.""" + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(("APS", d["ID"], + (lambda ff, aa: lambda x: ff(x, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(("CHA", d["ID"], (lambda ff: lambda x: ff(x))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +def itp_oracle(f, a, b, xtol, maxfev): + best = None + for fac, n0 in ITP_GRID: + try: + x, n, conv = itp(f, a, b, xtol, maxfev, + kappa1=fac * 0.2 / (b - a), n0=n0) + except ValueError: + continue + if conv and (best is None or n < best[1]): + best = (x, n, True) + return best if best is not None else (0.5 * (a + b), maxfev, False) + + +# Competitors are taken at the better of SciPy's implementation and ours, +# problem by problem, wherever SciPy ships the method. Ours turned out to be +# the cheaper of the two - 6991 against brentq's 7004, 5209 against +# _chandrupatla's 5228 - so quoting the library alone would have flattered us. +BASELINES = { + "bisection": bisection, "regula_falsi": regula_falsi, + "illinois": illinois, "pegasus": pegasus, + "anderson_bjorck": anderson_bjorck, "ridders": ridders, + "dekker": dekker, + "brent": best_of(brent, brent_scipy), + "chandrupatla": best_of(chandrupatla, chandrupatla_scipy), + "toms748": toms748, + "itp": itp, "itp_oracle": itp_oracle, +} + + +def make_method(spec): + """spec is ('base', name) or ('pure', similarity, scale, guard).""" + if spec[0] == "base": + return BASELINES[spec[1]] + _, sim, scale, guard = spec + + def m(f, a, b, xtol, maxfev): + return pure_root(f, a, b, xtol, maxfev, similarity=sim, + scale=scale, guard=guard) + return m + + +def label(spec): + if spec[0] == "base": + return spec[1] + return f"pure.{spec[1]}.{spec[2]}.{spec[3]}" + + +def evaluate(spec): + """Run one configuration over all 199 problems. Returns a plain dict so + it can cross the process boundary.""" + method = make_method(spec) + probs = load_problems() + res = {"label": label(spec), "spec": list(spec)} + for setname in ("APS", "CHA"): + total = solved = over = 0 + n_probs = 0 + per = {} + for s, pid, f, a, b, root in probs: + if s != setname: + continue + n_probs += 1 + try: + x, n, conv = method(f, a, b, XTOL, MAXFEV) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + # scipy hands back numpy scalars, whose booleans are numpy.bool_ + # and do not serialise; coerce at the boundary rather than at the + # dump, so nothing numpy-shaped survives into the results + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + n = int(n) + total += n if ok else MAXFEV + per[pid] = [n, ok] + if ok: + solved += 1 + if n > 2 * math.ceil(math.log2(abs(b - a) / XTOL)) + 4: + over += 1 + res[setname] = {"total": total, "solved": solved, "n": n_probs, + "over": over, "per": per} + return res + + +def build_grid(smoke): + specs = [("base", nm) for nm in BASELINES] + sims = sorted(PURE_SIMS) + scales = SCALES + guards = GUARD_MODES + if smoke: + sims = ["ratio", "exp_abs"] + scales = ("derived", "derived3") + guards = ("step", "both") + specs = [("base", nm) for nm in ("bisection", "brent", "toms748")] + for sim in sims: + for sc in scales: + for gu in guards: + specs.append(("pure", sim, sc, gu)) + return specs + + +def main(): + smoke = "--smoke" in sys.argv + specs = build_grid(smoke) + t0 = time.time() + print(f"sweep: {len(specs)} configurations x 199 problems " + f"({'SMOKE' if smoke else 'FULL'})", flush=True) + + workers = max(1, min(8, (os.cpu_count() or 2) - 1)) + with Pool(workers) as pool: + results = [] + for i, r in enumerate(pool.imap_unordered(evaluate, specs), 1): + results.append(r) + if i % 10 == 0 or i == len(specs): + print(f" {i}/{len(specs)} done, " + f"{time.time() - t0:.0f}s elapsed", flush=True) + + out = "sweep_smoke.json" if smoke else "sweep_full.json" + with open(out, "w", encoding="utf8") as fh: + json.dump(results, fh) + print(f"\nwrote {out} ({time.time() - t0:.0f}s total)\n", flush=True) + report(results) + + +def report(results, top=20): + for setname in ("APS", "CHA"): + rows = sorted(results, + key=lambda r: (r[setname]["n"] - r[setname]["solved"], + r[setname]["total"])) + n = rows[0][setname]["n"] + print("=" * 84) + print(f"{setname}: {n} problems (top {top} of {len(rows)})") + print("=" * 84) + print(f"{'configuration':40s}{'solved':>9s}{'total fev':>12s}" + f"{'over 2x':>9s}") + print("-" * 84) + for r in rows[:top]: + d = r[setname] + print(f"{r['label']:40s}{d['solved']:>6d}/{d['n']:<3d}" + f"{d['total']:>12d}{d['over']:>9d}") + print() + + # the law of stage 0c, tested across the whole grid: similarities whose + # (1 - S) has zero slope at 0 must be the slow ones whenever the scale is + # chosen rather than derived. + print("=" * 84) + print("THE STAGE-0C LAW ACROSS THE GRID") + print("=" * 84) + quad = ("rat_sq", "exp_sq", "cosine") # (1-S) ~ c2*z^2, slope c = 0 + lin = ("ratio", "rational", "exp_abs") # (1-S) ~ z, slope c = 1 + for scale in SCALES: + for group, name in ((lin, "slope c=1 (linear)"), + (quad, "slope c=0 (quadratic)")): + tot = solved = cnt = 0 + for r in results: + if r["spec"][0] != "pure": + continue + _, sim, sc, gu = r["spec"] + if sc != scale or gu != "step" or sim not in group: + continue + cnt += 1 + tot += r["APS"]["total"] + r["CHA"]["total"] + solved += r["APS"]["solved"] + r["CHA"]["solved"] + if cnt: + print(f" scale={scale:9s} {name:26s} " + f"mean total {tot / cnt:9.0f} " + f"mean solved {solved / cnt:6.1f}/199") + + +if __name__ == "__main__": + main() diff --git a/sweep_smoke.json b/sweep_smoke.json new file mode 100644 index 0000000..d42960a --- /dev/null +++ b/sweep_smoke.json @@ -0,0 +1 @@ +[{"label": "bisection", "spec": ["base", "bisection"], "APS": {"total": 7530, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [43, true], "aps.02.00": [44, true], "aps.02.01": [45, true], "aps.02.02": [45, true], "aps.02.03": [46, true], "aps.02.04": [46, true], "aps.02.05": [46, true], "aps.02.06": [46, true], "aps.02.07": [46, true], "aps.02.08": [47, true], "aps.02.09": [47, true], "aps.03.00": [48, true], "aps.03.01": [48, true], "aps.03.02": [48, true], "aps.04.00": [45, true], "aps.04.01": [45, true], "aps.04.02": [45, true], "aps.04.03": [45, true], "aps.04.04": [45, true], "aps.04.05": [45, true], "aps.04.06": [45, true], "aps.04.07": [45, true], "aps.04.08": [45, true], "aps.04.09": [45, true], "aps.04.10": [45, true], "aps.04.11": [45, true], "aps.04.12": [45, true], "aps.04.13": [45, true], "aps.05.00": [43, true], "aps.06.00": [42, true], "aps.06.01": [42, true], "aps.06.02": [42, true], "aps.06.03": [42, true], "aps.06.04": [42, true], "aps.06.05": [42, true], "aps.06.06": [42, true], "aps.06.07": [42, true], "aps.06.08": [42, true], "aps.06.09": [42, true], "aps.07.00": [42, true], "aps.07.01": [42, true], "aps.07.02": [42, true], "aps.08.00": [3, true], "aps.08.01": [42, true], "aps.08.02": [42, true], "aps.08.03": [42, true], "aps.08.04": [42, true], "aps.09.00": [42, true], "aps.09.01": [42, true], "aps.09.02": [42, true], "aps.09.03": [42, true], "aps.09.04": [42, true], "aps.09.05": [42, true], "aps.09.06": [42, true], "aps.10.00": [42, true], "aps.10.01": [42, true], "aps.10.02": [42, true], "aps.10.03": [42, true], "aps.10.04": [42, true], "aps.11.00": [42, true], "aps.11.01": [42, true], "aps.11.02": [42, true], "aps.11.03": [42, true], "aps.12.00": [49, true], "aps.12.01": [49, true], "aps.12.02": [49, true], "aps.12.03": [49, true], "aps.12.04": [49, true], "aps.12.05": [49, true], "aps.12.06": [49, true], "aps.12.07": [49, true], "aps.12.08": [49, true], "aps.12.09": [49, true], "aps.12.10": [49, true], "aps.12.11": [49, true], "aps.12.12": [49, true], "aps.12.13": [49, true], "aps.12.14": [49, true], "aps.12.15": [49, true], "aps.12.16": [49, true], "aps.12.17": [49, true], "aps.12.18": [49, true], "aps.13.00": [8, false], "aps.14.00": [52, true], "aps.14.01": [52, true], "aps.14.02": [52, true], "aps.14.03": [52, true], "aps.14.04": [52, true], "aps.14.05": [52, true], "aps.14.06": [52, true], "aps.14.07": [52, true], "aps.14.08": [52, true], "aps.14.09": [52, true], "aps.14.10": [52, true], "aps.14.11": [52, true], "aps.14.12": [52, true], "aps.14.13": [52, true], "aps.14.14": [52, true], "aps.14.15": [52, true], "aps.14.16": [52, true], "aps.14.17": [52, true], "aps.14.18": [52, true], "aps.14.19": [52, true], "aps.14.20": [52, true], "aps.14.21": [52, true], "aps.14.22": [52, true], "aps.14.23": [52, true], "aps.14.24": [52, true], "aps.14.25": [52, true], "aps.14.26": [52, true], "aps.14.27": [52, true], "aps.14.28": [52, true], "aps.14.29": [52, true], "aps.14.30": [52, true], "aps.14.31": [52, true], "aps.14.32": [52, true], "aps.14.33": [52, true], "aps.14.34": [52, true], "aps.14.35": [52, true], "aps.14.36": [52, true], "aps.14.37": [52, true], "aps.14.38": [52, true], "aps.14.39": [52, true], "aps.15.00": [52, true], "aps.15.01": [52, true], "aps.15.02": [52, true], "aps.15.03": [52, true], "aps.15.04": [52, true], "aps.15.05": [52, true], "aps.15.06": [52, true], "aps.15.07": [52, true], "aps.15.08": [52, true], "aps.15.09": [52, true], "aps.15.10": [52, true], "aps.15.11": [52, true], "aps.15.12": [52, true], "aps.15.13": [52, true], "aps.15.14": [52, true], "aps.15.15": [52, true], "aps.15.16": [52, true], "aps.15.17": [52, true], "aps.15.18": [52, true], "aps.15.19": [52, true], "aps.15.20": [52, true], "aps.15.21": [52, true], "aps.15.22": [52, true], "aps.15.23": [52, true], "aps.15.24": [52, true], "aps.15.25": [52, true], "aps.15.26": [52, true], "aps.15.27": [52, true], "aps.15.28": [52, true], "aps.15.29": [52, true], "aps.15.30": [52, true]}}, "CHA": {"total": 3090, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [42, true], "fun1.2": [46, true], "fun1.3": [49, true], "fun1.4": [57, true], "fun1.5": [77, true], "fun2.1": [42, true], "fun2.2": [56, true], "fun2.3": [62, true], "fun2.4": [76, true], "fun2.5": [82, true], "fun3.1": [45, true], "fun3.2": [47, true], "fun3.3": [57, true], "fun3.4": [63, true], "fun3.5": [77, true], "fun4.1": [45, true], "fun4.2": [47, true], "fun4.3": [57, true], "fun4.4": [63, true], "fun4.5": [77, true], "fun5.1": [45, true], "fun5.2": [45, true], "fun5.3": [46, true], "fun5.4": [48, true], "fun5.5": [49, true], "fun6.1": [45, true], "fun6.2": [45, true], "fun6.3": [46, true], "fun6.4": [48, true], "fun6.5": [49, true], "fun7.1": [8, false], "fun7.2": [7, false], "fun7.3": [7, false], "fun7.4": [12, false], "fun7.5": [12, false], "fun8.1": [43, true], "fun8.2": [44, true], "fun8.3": [46, true], "fun8.4": [47, true], "fun8.5": [49, true], "fun9.1": [42, true], "fun9.2": [44, true], "fun9.3": [46, true], "fun9.4": [47, true], "fun9.5": [49, true]}}}, {"label": "brent", "spec": ["base", "brent"], "APS": {"total": 2889, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [15, true], "aps.02.01": [9, true], "aps.02.02": [15, true], "aps.02.03": [13, true], "aps.02.04": [13, true], "aps.02.05": [12, true], "aps.02.06": [12, true], "aps.02.07": [12, true], "aps.02.08": [12, true], "aps.02.09": [11, true], "aps.03.00": [17, true], "aps.03.01": [19, true], "aps.03.02": [20, true], "aps.04.00": [15, true], "aps.04.01": [17, true], "aps.04.02": [17, true], "aps.04.03": [17, true], "aps.04.04": [18, true], "aps.04.05": [15, true], "aps.04.06": [15, true], "aps.04.07": [15, true], "aps.04.08": [16, true], "aps.04.09": [17, true], "aps.04.10": [15, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [17, true], "aps.05.00": [10, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [14, true], "aps.06.08": [15, true], "aps.06.09": [14, true], "aps.07.00": [9, true], "aps.07.01": [9, true], "aps.07.02": [8, true], "aps.08.00": [3, true], "aps.08.01": [9, true], "aps.08.02": [10, true], "aps.08.03": [12, true], "aps.08.04": [13, true], "aps.09.00": [10, true], "aps.09.01": [11, true], "aps.09.02": [8, true], "aps.09.03": [8, true], "aps.09.04": [7, true], "aps.09.05": [7, true], "aps.09.06": [6, true], "aps.10.00": [8, true], "aps.10.01": [9, true], "aps.10.02": [9, true], "aps.10.03": [12, true], "aps.10.04": [12, true], "aps.11.00": [4, true], "aps.11.01": [12, true], "aps.11.02": [13, true], "aps.11.03": [14, true], "aps.12.00": [6, true], "aps.12.01": [10, true], "aps.12.02": [10, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [11, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [10, true], "aps.12.18": [10, true], "aps.13.00": [18, false], "aps.14.00": [18, true], "aps.14.01": [18, true], "aps.14.02": [18, true], "aps.14.03": [18, true], "aps.14.04": [18, true], "aps.14.05": [18, true], "aps.14.06": [18, true], "aps.14.07": [18, true], "aps.14.08": [18, true], "aps.14.09": [18, true], "aps.14.10": [18, true], "aps.14.11": [18, true], "aps.14.12": [18, true], "aps.14.13": [18, true], "aps.14.14": [18, true], "aps.14.15": [18, true], "aps.14.16": [18, true], "aps.14.17": [18, true], "aps.14.18": [18, true], "aps.14.19": [18, true], "aps.14.20": [18, true], "aps.14.21": [18, true], "aps.14.22": [18, true], "aps.14.23": [18, true], "aps.14.24": [18, true], "aps.14.25": [18, true], "aps.14.26": [18, true], "aps.14.27": [18, true], "aps.14.28": [18, true], "aps.14.29": [18, true], "aps.14.30": [18, true], "aps.14.31": [18, true], "aps.14.32": [18, true], "aps.14.33": [18, true], "aps.14.34": [18, true], "aps.14.35": [18, true], "aps.14.36": [18, true], "aps.14.37": [18, true], "aps.14.38": [18, true], "aps.14.39": [18, true], "aps.15.00": [32, true], "aps.15.01": [32, true], "aps.15.02": [32, true], "aps.15.03": [32, true], "aps.15.04": [32, true], "aps.15.05": [31, true], "aps.15.06": [31, true], "aps.15.07": [31, true], "aps.15.08": [31, true], "aps.15.09": [31, true], "aps.15.10": [30, true], "aps.15.11": [31, true], "aps.15.12": [31, true], "aps.15.13": [31, true], "aps.15.14": [32, true], "aps.15.15": [32, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [32, true], "aps.15.21": [33, true], "aps.15.22": [34, true], "aps.15.23": [35, true], "aps.15.24": [33, true], "aps.15.25": [35, true], "aps.15.26": [36, true], "aps.15.27": [36, true], "aps.15.28": [36, true], "aps.15.29": [36, true], "aps.15.30": [35, true]}}, "CHA": {"total": 4099, "solved": 38, "n": 45, "over": 18, "per": {"fun1.1": [8, true], "fun1.2": [15, true], "fun1.3": [16, true], "fun1.4": [36, true], "fun1.5": [75, true], "fun2.1": [10, true], "fun2.2": [24, true], "fun2.3": [29, true], "fun2.4": [44, true], "fun2.5": [49, true], "fun3.1": [110, true], "fun3.2": [134, true], "fun3.3": [145, true], "fun3.4": [169, true], "fun3.5": [200, false], "fun4.1": [110, true], "fun4.2": [114, true], "fun4.3": [144, true], "fun4.4": [167, true], "fun4.5": [200, false], "fun5.1": [120, true], "fun5.2": [122, true], "fun5.3": [121, true], "fun5.4": [127, true], "fun5.5": [129, true], "fun6.1": [102, true], "fun6.2": [104, true], "fun6.3": [104, true], "fun6.4": [112, true], "fun6.5": [116, true], "fun7.1": [18, false], "fun7.2": [21, false], "fun7.3": [24, false], "fun7.4": [27, false], "fun7.5": [33, false], "fun8.1": [10, true], "fun8.2": [12, true], "fun8.3": [12, true], "fun8.4": [15, true], "fun8.5": [17, true], "fun9.1": [9, true], "fun9.2": [11, true], "fun9.3": [16, true], "fun9.4": [19, true], "fun9.5": [22, true]}}}, {"label": "pure.ratio.derived.step", "spec": ["pure", "ratio", "derived", "step"], "APS": {"total": 3103, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [14, true], "aps.02.01": [13, true], "aps.02.02": [12, true], "aps.02.03": [18, true], "aps.02.04": [28, true], "aps.02.05": [26, true], "aps.02.06": [11, true], "aps.02.07": [20, true], "aps.02.08": [19, true], "aps.02.09": [29, true], "aps.03.00": [25, true], "aps.03.01": [15, true], "aps.03.02": [21, true], "aps.04.00": [17, true], "aps.04.01": [18, true], "aps.04.02": [24, true], "aps.04.03": [19, true], "aps.04.04": [20, true], "aps.04.05": [17, true], "aps.04.06": [17, true], "aps.04.07": [17, true], "aps.04.08": [15, true], "aps.04.09": [18, true], "aps.04.10": [16, true], "aps.04.11": [17, true], "aps.04.12": [18, true], "aps.04.13": [18, true], "aps.05.00": [10, true], "aps.06.00": [8, true], "aps.06.01": [10, true], "aps.06.02": [12, true], "aps.06.03": [11, true], "aps.06.04": [10, true], "aps.06.05": [13, true], "aps.06.06": [14, true], "aps.06.07": [15, true], "aps.06.08": [15, true], "aps.06.09": [15, true], "aps.07.00": [12, true], "aps.07.01": [10, true], "aps.07.02": [10, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [16, true], "aps.08.04": [15, true], "aps.09.00": [11, true], "aps.09.01": [23, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [9, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [9, true], "aps.10.01": [16, true], "aps.10.02": [15, true], "aps.10.03": [17, true], "aps.10.04": [45, true], "aps.11.00": [4, true], "aps.11.01": [13, true], "aps.11.02": [17, true], "aps.11.03": [18, true], "aps.12.00": [10, true], "aps.12.01": [12, true], "aps.12.02": [11, true], "aps.12.03": [11, true], "aps.12.04": [12, true], "aps.12.05": [12, true], "aps.12.06": [12, true], "aps.12.07": [12, true], "aps.12.08": [11, true], "aps.12.09": [10, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [33, true], "aps.15.01": [34, true], "aps.15.02": [33, true], "aps.15.03": [33, true], "aps.15.04": [37, true], "aps.15.05": [37, true], "aps.15.06": [33, true], "aps.15.07": [32, true], "aps.15.08": [31, true], "aps.15.09": [31, true], "aps.15.10": [32, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [33, true], "aps.15.15": [33, true], "aps.15.16": [32, true], "aps.15.17": [32, true], "aps.15.18": [32, true], "aps.15.19": [32, true], "aps.15.20": [33, true], "aps.15.21": [34, true], "aps.15.22": [37, true], "aps.15.23": [37, true], "aps.15.24": [34, true], "aps.15.25": [35, true], "aps.15.26": [37, true], "aps.15.27": [38, true], "aps.15.28": [40, true], "aps.15.29": [36, true], "aps.15.30": [35, true]}}, "CHA": {"total": 3526, "solved": 40, "n": 45, "over": 10, "per": {"fun1.1": [9, true], "fun1.2": [14, true], "fun1.3": [19, true], "fun1.4": [21, true], "fun1.5": [69, true], "fun2.1": [11, true], "fun2.2": [29, true], "fun2.3": [32, true], "fun2.4": [45, true], "fun2.5": [50, true], "fun3.1": [85, true], "fun3.2": [88, true], "fun3.3": [108, true], "fun3.4": [117, true], "fun3.5": [141, true], "fun4.1": [94, true], "fun4.2": [99, true], "fun4.3": [116, true], "fun4.4": [131, true], "fun4.5": [156, true], "fun5.1": [102, true], "fun5.2": [100, true], "fun5.3": [96, true], "fun5.4": [102, true], "fun5.5": [105, true], "fun6.1": [74, true], "fun6.2": [89, true], "fun6.3": [88, true], "fun6.4": [93, true], "fun6.5": [87, true], "fun7.1": [10, false], "fun7.2": [13, false], "fun7.3": [11, false], "fun7.4": [10, false], "fun7.5": [8, false], "fun8.1": [12, true], "fun8.2": [13, true], "fun8.3": [13, true], "fun8.4": [18, true], "fun8.5": [21, true], "fun9.1": [10, true], "fun9.2": [12, true], "fun9.3": [15, true], "fun9.4": [20, true], "fun9.5": [22, true]}}}, {"label": "pure.exp_abs.derived.step", "spec": ["pure", "exp_abs", "derived", "step"], "APS": {"total": 3288, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [9, true], "aps.02.00": [15, true], "aps.02.01": [30, true], "aps.02.02": [12, true], "aps.02.03": [14, true], "aps.02.04": [13, true], "aps.02.05": [14, true], "aps.02.06": [41, true], "aps.02.07": [13, true], "aps.02.08": [12, true], "aps.02.09": [12, true], "aps.03.00": [18, true], "aps.03.01": [19, true], "aps.03.02": [20, true], "aps.04.00": [16, true], "aps.04.01": [40, true], "aps.04.02": [34, true], "aps.04.03": [15, true], "aps.04.04": [15, true], "aps.04.05": [16, true], "aps.04.06": [15, true], "aps.04.07": [16, true], "aps.04.08": [16, true], "aps.04.09": [17, true], "aps.04.10": [18, true], "aps.04.11": [17, true], "aps.04.12": [17, true], "aps.04.13": [18, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [11, true], "aps.06.04": [11, true], "aps.06.05": [13, true], "aps.06.06": [15, true], "aps.06.07": [16, true], "aps.06.08": [16, true], "aps.06.09": [16, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [14, true], "aps.08.00": [7, true], "aps.08.01": [10, true], "aps.08.02": [11, true], "aps.08.03": [16, true], "aps.08.04": [12, true], "aps.09.00": [11, true], "aps.09.01": [26, true], "aps.09.02": [12, true], "aps.09.03": [13, true], "aps.09.04": [15, true], "aps.09.05": [18, true], "aps.09.06": [19, true], "aps.10.00": [36, true], "aps.10.01": [28, true], "aps.10.02": [16, true], "aps.10.03": [17, true], "aps.10.04": [38, true], "aps.11.00": [10, true], "aps.11.01": [12, true], "aps.11.02": [18, true], "aps.11.03": [19, true], "aps.12.00": [10, true], "aps.12.01": [11, true], "aps.12.02": [12, true], "aps.12.03": [11, true], "aps.12.04": [11, true], "aps.12.05": [12, true], "aps.12.06": [12, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [10, true], "aps.12.14": [10, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [10, true], "aps.13.00": [10, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [33, true], "aps.15.01": [33, true], "aps.15.02": [33, true], "aps.15.03": [34, true], "aps.15.04": [34, true], "aps.15.05": [34, true], "aps.15.06": [34, true], "aps.15.07": [35, true], "aps.15.08": [35, true], "aps.15.09": [35, true], "aps.15.10": [34, true], "aps.15.11": [34, true], "aps.15.12": [34, true], "aps.15.13": [34, true], "aps.15.14": [34, true], "aps.15.15": [34, true], "aps.15.16": [34, true], "aps.15.17": [34, true], "aps.15.18": [34, true], "aps.15.19": [35, true], "aps.15.20": [34, true], "aps.15.21": [34, true], "aps.15.22": [34, true], "aps.15.23": [36, true], "aps.15.24": [34, true], "aps.15.25": [37, true], "aps.15.26": [38, true], "aps.15.27": [38, true], "aps.15.28": [36, true], "aps.15.29": [37, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3502, "solved": 40, "n": 45, "over": 8, "per": {"fun1.1": [30, true], "fun1.2": [38, true], "fun1.3": [38, true], "fun1.4": [32, true], "fun1.5": [80, true], "fun2.1": [12, true], "fun2.2": [29, true], "fun2.3": [36, true], "fun2.4": [47, true], "fun2.5": [57, true], "fun3.1": [87, true], "fun3.2": [91, true], "fun3.3": [111, true], "fun3.4": [122, true], "fun3.5": [146, true], "fun4.1": [88, true], "fun4.2": [94, true], "fun4.3": [116, true], "fun4.4": [128, true], "fun4.5": [157, true], "fun5.1": [96, true], "fun5.2": [95, true], "fun5.3": [100, true], "fun5.4": [106, true], "fun5.5": [109, true], "fun6.1": [61, true], "fun6.2": [52, true], "fun6.3": [60, true], "fun6.4": [64, true], "fun6.5": [64, true], "fun7.1": [10, false], "fun7.2": [12, false], "fun7.3": [13, false], "fun7.4": [17, false], "fun7.5": [15, false], "fun8.1": [12, true], "fun8.2": [12, true], "fun8.3": [17, true], "fun8.4": [17, true], "fun8.5": [22, true], "fun9.1": [9, true], "fun9.2": [12, true], "fun9.3": [16, true], "fun9.4": [20, true], "fun9.5": [19, true]}}}, {"label": "pure.ratio.derived3.step", "spec": ["pure", "ratio", "derived3", "step"], "APS": {"total": 3035, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [19, true], "aps.02.01": [35, true], "aps.02.02": [47, true], "aps.02.03": [20, true], "aps.02.04": [22, true], "aps.02.05": [15, true], "aps.02.06": [21, true], "aps.02.07": [21, true], "aps.02.08": [17, true], "aps.02.09": [17, true], "aps.03.00": [17, true], "aps.03.01": [16, true], "aps.03.02": [20, true], "aps.04.00": [19, true], "aps.04.01": [15, true], "aps.04.02": [42, true], "aps.04.03": [17, true], "aps.04.04": [17, true], "aps.04.05": [11, true], "aps.04.06": [15, true], "aps.04.07": [15, true], "aps.04.08": [16, true], "aps.04.09": [15, true], "aps.04.10": [16, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [17, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [9, true], "aps.06.04": [9, true], "aps.06.05": [10, true], "aps.06.06": [10, true], "aps.06.07": [10, true], "aps.06.08": [13, true], "aps.06.09": [13, true], "aps.07.00": [10, true], "aps.07.01": [11, true], "aps.07.02": [11, true], "aps.08.00": [3, true], "aps.08.01": [10, true], "aps.08.02": [12, true], "aps.08.03": [14, true], "aps.08.04": [18, true], "aps.09.00": [8, true], "aps.09.01": [10, true], "aps.09.02": [12, true], "aps.09.03": [10, true], "aps.09.04": [10, true], "aps.09.05": [11, true], "aps.09.06": [10, true], "aps.10.00": [9, true], "aps.10.01": [12, true], "aps.10.02": [34, true], "aps.10.03": [16, true], "aps.10.04": [39, true], "aps.11.00": [5, true], "aps.11.01": [11, true], "aps.11.02": [16, true], "aps.11.03": [15, true], "aps.12.00": [9, true], "aps.12.01": [9, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [9, true], "aps.12.14": [9, true], "aps.12.15": [9, true], "aps.12.16": [9, true], "aps.12.17": [9, true], "aps.12.18": [9, true], "aps.13.00": [10, false], "aps.14.00": [17, true], "aps.14.01": [17, true], "aps.14.02": [17, true], "aps.14.03": [17, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [17, true], "aps.14.07": [17, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [17, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [17, true], "aps.14.14": [17, true], "aps.14.15": [17, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [17, true], "aps.14.22": [17, true], "aps.14.23": [17, true], "aps.14.24": [17, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [17, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [17, true], "aps.14.32": [17, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [17, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [31, true], "aps.15.01": [31, true], "aps.15.02": [32, true], "aps.15.03": [31, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [31, true], "aps.15.07": [32, true], "aps.15.08": [31, true], "aps.15.09": [30, true], "aps.15.10": [30, true], "aps.15.11": [31, true], "aps.15.12": [31, true], "aps.15.13": [31, true], "aps.15.14": [31, true], "aps.15.15": [31, true], "aps.15.16": [31, true], "aps.15.17": [31, true], "aps.15.18": [31, true], "aps.15.19": [31, true], "aps.15.20": [31, true], "aps.15.21": [35, true], "aps.15.22": [33, true], "aps.15.23": [36, true], "aps.15.24": [36, true], "aps.15.25": [35, true], "aps.15.26": [35, true], "aps.15.27": [37, true], "aps.15.28": [36, true], "aps.15.29": [36, true], "aps.15.30": [36, true]}}, "CHA": {"total": 3460, "solved": 40, "n": 45, "over": 10, "per": {"fun1.1": [7, true], "fun1.2": [22, true], "fun1.3": [21, true], "fun1.4": [20, true], "fun1.5": [48, true], "fun2.1": [9, true], "fun2.2": [24, true], "fun2.3": [30, true], "fun2.4": [43, true], "fun2.5": [49, true], "fun3.1": [85, true], "fun3.2": [85, true], "fun3.3": [99, true], "fun3.4": [110, true], "fun3.5": [113, true], "fun4.1": [92, true], "fun4.2": [97, true], "fun4.3": [118, true], "fun4.4": [131, true], "fun4.5": [160, true], "fun5.1": [102, true], "fun5.2": [105, true], "fun5.3": [104, true], "fun5.4": [107, true], "fun5.5": [110, true], "fun6.1": [81, true], "fun6.2": [85, true], "fun6.3": [87, true], "fun6.4": [86, true], "fun6.5": [90, true], "fun7.1": [10, false], "fun7.2": [13, false], "fun7.3": [11, false], "fun7.4": [10, false], "fun7.5": [8, false], "fun8.1": [12, true], "fun8.2": [11, true], "fun8.3": [12, true], "fun8.4": [16, true], "fun8.5": [18, true], "fun9.1": [8, true], "fun9.2": [10, true], "fun9.3": [17, true], "fun9.4": [18, true], "fun9.5": [18, true]}}}, {"label": "pure.ratio.derived3.both", "spec": ["pure", "ratio", "derived3", "both"], "APS": {"total": 7147, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [52, true], "aps.02.00": [58, true], "aps.02.01": [49, true], "aps.02.02": [64, true], "aps.02.03": [30, true], "aps.02.04": [28, true], "aps.02.05": [16, true], "aps.02.06": [21, true], "aps.02.07": [20, true], "aps.02.08": [36, true], "aps.02.09": [26, true], "aps.03.00": [19, true], "aps.03.01": [83, true], "aps.03.02": [83, true], "aps.04.00": [56, true], "aps.04.01": [70, true], "aps.04.02": [37, true], "aps.04.03": [19, true], "aps.04.04": [20, true], "aps.04.05": [16, true], "aps.04.06": [16, true], "aps.04.07": [36, true], "aps.04.08": [56, true], "aps.04.09": [52, true], "aps.04.10": [56, true], "aps.04.11": [16, true], "aps.04.12": [21, true], "aps.04.13": [56, true], "aps.05.00": [53, true], "aps.06.00": [26, true], "aps.06.01": [52, true], "aps.06.02": [56, true], "aps.06.03": [56, true], "aps.06.04": [56, true], "aps.06.05": [60, true], "aps.06.06": [62, true], "aps.06.07": [64, true], "aps.06.08": [63, true], "aps.06.09": [65, true], "aps.07.00": [58, true], "aps.07.01": [57, true], "aps.07.02": [63, true], "aps.08.00": [3, true], "aps.08.01": [56, true], "aps.08.02": [32, true], "aps.08.03": [19, true], "aps.08.04": [27, true], "aps.09.00": [37, true], "aps.09.01": [37, true], "aps.09.02": [58, true], "aps.09.03": [62, true], "aps.09.04": [53, true], "aps.09.05": [14, true], "aps.09.06": [44, true], "aps.10.00": [32, true], "aps.10.01": [58, true], "aps.10.02": [54, true], "aps.10.03": [55, true], "aps.10.04": [63, true], "aps.11.00": [4, true], "aps.11.01": [13, true], "aps.11.02": [60, true], "aps.11.03": [17, true], "aps.12.00": [11, true], "aps.12.01": [50, true], "aps.12.02": [23, true], "aps.12.03": [53, true], "aps.12.04": [51, true], "aps.12.05": [51, true], "aps.12.06": [51, true], "aps.12.07": [47, true], "aps.12.08": [14, true], "aps.12.09": [24, true], "aps.12.10": [14, true], "aps.12.11": [48, true], "aps.12.12": [49, true], "aps.12.13": [20, true], "aps.12.14": [15, true], "aps.12.15": [14, true], "aps.12.16": [15, true], "aps.12.17": [14, true], "aps.12.18": [14, true], "aps.13.00": [7, false], "aps.14.00": [43, true], "aps.14.01": [43, true], "aps.14.02": [45, true], "aps.14.03": [43, true], "aps.14.04": [43, true], "aps.14.05": [45, true], "aps.14.06": [43, true], "aps.14.07": [43, true], "aps.14.08": [45, true], "aps.14.09": [43, true], "aps.14.10": [45, true], "aps.14.11": [45, true], "aps.14.12": [43, true], "aps.14.13": [43, true], "aps.14.14": [43, true], "aps.14.15": [43, true], "aps.14.16": [45, true], "aps.14.17": [45, true], "aps.14.18": [43, true], "aps.14.19": [43, true], "aps.14.20": [43, true], "aps.14.21": [45, true], "aps.14.22": [45, true], "aps.14.23": [45, true], "aps.14.24": [45, true], "aps.14.25": [43, true], "aps.14.26": [43, true], "aps.14.27": [43, true], "aps.14.28": [43, true], "aps.14.29": [43, true], "aps.14.30": [43, true], "aps.14.31": [43, true], "aps.14.32": [45, true], "aps.14.33": [45, true], "aps.14.34": [45, true], "aps.14.35": [45, true], "aps.14.36": [45, true], "aps.14.37": [43, true], "aps.14.38": [45, true], "aps.14.39": [43, true], "aps.15.00": [73, true], "aps.15.01": [73, true], "aps.15.02": [73, true], "aps.15.03": [73, true], "aps.15.04": [73, true], "aps.15.05": [72, true], "aps.15.06": [72, true], "aps.15.07": [69, true], "aps.15.08": [70, true], "aps.15.09": [66, true], "aps.15.10": [74, true], "aps.15.11": [75, true], "aps.15.12": [75, true], "aps.15.13": [38, true], "aps.15.14": [38, true], "aps.15.15": [35, true], "aps.15.16": [36, true], "aps.15.17": [38, true], "aps.15.18": [71, true], "aps.15.19": [73, true], "aps.15.20": [72, true], "aps.15.21": [67, true], "aps.15.22": [48, true], "aps.15.23": [71, true], "aps.15.24": [38, true], "aps.15.25": [72, true], "aps.15.26": [42, true], "aps.15.27": [39, true], "aps.15.28": [65, true], "aps.15.29": [67, true], "aps.15.30": [66, true]}}, "CHA": {"total": 3490, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [48, true], "fun1.2": [56, true], "fun1.3": [21, true], "fun1.4": [69, true], "fun1.5": [87, true], "fun2.1": [54, true], "fun2.2": [68, true], "fun2.3": [33, true], "fun2.4": [44, true], "fun2.5": [51, true], "fun3.1": [63, true], "fun3.2": [66, true], "fun3.3": [77, true], "fun3.4": [83, true], "fun3.5": [92, true], "fun4.1": [70, true], "fun4.2": [73, true], "fun4.3": [89, true], "fun4.4": [94, true], "fun4.5": [116, true], "fun5.1": [69, true], "fun5.2": [71, true], "fun5.3": [75, true], "fun5.4": [73, true], "fun5.5": [74, true], "fun6.1": [60, true], "fun6.2": [66, true], "fun6.3": [64, true], "fun6.4": [64, true], "fun6.5": [65, true], "fun7.1": [7, false], "fun7.2": [9, false], "fun7.3": [9, false], "fun7.4": [6, false], "fun7.5": [6, false], "fun8.1": [55, true], "fun8.2": [37, true], "fun8.3": [14, true], "fun8.4": [18, true], "fun8.5": [63, true], "fun9.1": [50, true], "fun9.2": [70, true], "fun9.3": [19, true], "fun9.4": [65, true], "fun9.5": [64, true]}}}, {"label": "pure.ratio.derived.both", "spec": ["pure", "ratio", "derived", "both"], "APS": {"total": 4259, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [15, true], "aps.02.00": [28, true], "aps.02.01": [21, true], "aps.02.02": [20, true], "aps.02.03": [28, true], "aps.02.04": [26, true], "aps.02.05": [24, true], "aps.02.06": [25, true], "aps.02.07": [24, true], "aps.02.08": [34, true], "aps.02.09": [36, true], "aps.03.00": [24, true], "aps.03.01": [25, true], "aps.03.02": [32, true], "aps.04.00": [25, true], "aps.04.01": [30, true], "aps.04.02": [36, true], "aps.04.03": [24, true], "aps.04.04": [28, true], "aps.04.05": [21, true], "aps.04.06": [19, true], "aps.04.07": [26, true], "aps.04.08": [25, true], "aps.04.09": [26, true], "aps.04.10": [24, true], "aps.04.11": [21, true], "aps.04.12": [27, true], "aps.04.13": [27, true], "aps.05.00": [18, true], "aps.06.00": [16, true], "aps.06.01": [17, true], "aps.06.02": [18, true], "aps.06.03": [19, true], "aps.06.04": [17, true], "aps.06.05": [23, true], "aps.06.06": [20, true], "aps.06.07": [21, true], "aps.06.08": [21, true], "aps.06.09": [23, true], "aps.07.00": [23, true], "aps.07.01": [20, true], "aps.07.02": [19, true], "aps.08.00": [3, true], "aps.08.01": [19, true], "aps.08.02": [20, true], "aps.08.03": [19, true], "aps.08.04": [18, true], "aps.09.00": [16, true], "aps.09.01": [27, true], "aps.09.02": [12, true], "aps.09.03": [11, true], "aps.09.04": [10, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [20, true], "aps.10.01": [30, true], "aps.10.02": [17, true], "aps.10.03": [18, true], "aps.10.04": [36, true], "aps.11.00": [4, true], "aps.11.01": [23, true], "aps.11.02": [21, true], "aps.11.03": [27, true], "aps.12.00": [17, true], "aps.12.01": [19, true], "aps.12.02": [20, true], "aps.12.03": [21, true], "aps.12.04": [16, true], "aps.12.05": [20, true], "aps.12.06": [20, true], "aps.12.07": [19, true], "aps.12.08": [23, true], "aps.12.09": [17, true], "aps.12.10": [17, true], "aps.12.11": [15, true], "aps.12.12": [19, true], "aps.12.13": [19, true], "aps.12.14": [19, true], "aps.12.15": [18, true], "aps.12.16": [17, true], "aps.12.17": [20, true], "aps.12.18": [19, true], "aps.13.00": [7, false], "aps.14.00": [27, true], "aps.14.01": [27, true], "aps.14.02": [25, true], "aps.14.03": [27, true], "aps.14.04": [27, true], "aps.14.05": [25, true], "aps.14.06": [27, true], "aps.14.07": [27, true], "aps.14.08": [27, true], "aps.14.09": [27, true], "aps.14.10": [27, true], "aps.14.11": [25, true], "aps.14.12": [27, true], "aps.14.13": [27, true], "aps.14.14": [27, true], "aps.14.15": [27, true], "aps.14.16": [27, true], "aps.14.17": [27, true], "aps.14.18": [27, true], "aps.14.19": [27, true], "aps.14.20": [27, true], "aps.14.21": [27, true], "aps.14.22": [25, true], "aps.14.23": [25, true], "aps.14.24": [25, true], "aps.14.25": [27, true], "aps.14.26": [27, true], "aps.14.27": [27, true], "aps.14.28": [27, true], "aps.14.29": [27, true], "aps.14.30": [27, true], "aps.14.31": [27, true], "aps.14.32": [27, true], "aps.14.33": [27, true], "aps.14.34": [27, true], "aps.14.35": [27, true], "aps.14.36": [27, true], "aps.14.37": [27, true], "aps.14.38": [27, true], "aps.14.39": [27, true], "aps.15.00": [40, true], "aps.15.01": [42, true], "aps.15.02": [42, true], "aps.15.03": [42, true], "aps.15.04": [42, true], "aps.15.05": [44, true], "aps.15.06": [40, true], "aps.15.07": [42, true], "aps.15.08": [38, true], "aps.15.09": [39, true], "aps.15.10": [34, true], "aps.15.11": [35, true], "aps.15.12": [36, true], "aps.15.13": [36, true], "aps.15.14": [39, true], "aps.15.15": [41, true], "aps.15.16": [41, true], "aps.15.17": [42, true], "aps.15.18": [42, true], "aps.15.19": [44, true], "aps.15.20": [42, true], "aps.15.21": [45, true], "aps.15.22": [41, true], "aps.15.23": [47, true], "aps.15.24": [34, true], "aps.15.25": [38, true], "aps.15.26": [44, true], "aps.15.27": [45, true], "aps.15.28": [49, true], "aps.15.29": [47, true], "aps.15.30": [42, true]}}, "CHA": {"total": 3199, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [16, true], "fun1.2": [29, true], "fun1.3": [30, true], "fun1.4": [42, true], "fun1.5": [69, true], "fun2.1": [20, true], "fun2.2": [36, true], "fun2.3": [35, true], "fun2.4": [56, true], "fun2.5": [59, true], "fun3.1": [66, true], "fun3.2": [72, true], "fun3.3": [89, true], "fun3.4": [99, true], "fun3.5": [122, true], "fun4.1": [68, true], "fun4.2": [69, true], "fun4.3": [90, true], "fun4.4": [101, true], "fun4.5": [125, true], "fun5.1": [68, true], "fun5.2": [73, true], "fun5.3": [73, true], "fun5.4": [74, true], "fun5.5": [75, true], "fun6.1": [61, true], "fun6.2": [62, true], "fun6.3": [61, true], "fun6.4": [65, true], "fun6.5": [66, true], "fun7.1": [7, false], "fun7.2": [11, false], "fun7.3": [8, false], "fun7.4": [7, false], "fun7.5": [7, false], "fun8.1": [21, true], "fun8.2": [20, true], "fun8.3": [22, true], "fun8.4": [23, true], "fun8.5": [29, true], "fun9.1": [16, true], "fun9.2": [24, true], "fun9.3": [22, true], "fun9.4": [20, true], "fun9.5": [31, true]}}}, {"label": "pure.exp_abs.derived3.step", "spec": ["pure", "exp_abs", "derived3", "step"], "APS": {"total": 3285, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [8, true], "aps.02.00": [15, true], "aps.02.01": [14, true], "aps.02.02": [41, true], "aps.02.03": [16, true], "aps.02.04": [16, true], "aps.02.05": [25, true], "aps.02.06": [39, true], "aps.02.07": [29, true], "aps.02.08": [27, true], "aps.02.09": [24, true], "aps.03.00": [28, true], "aps.03.01": [26, true], "aps.03.02": [40, true], "aps.04.00": [17, true], "aps.04.01": [19, true], "aps.04.02": [44, true], "aps.04.03": [18, true], "aps.04.04": [24, true], "aps.04.05": [12, true], "aps.04.06": [15, true], "aps.04.07": [15, true], "aps.04.08": [17, true], "aps.04.09": [17, true], "aps.04.10": [16, true], "aps.04.11": [16, true], "aps.04.12": [16, true], "aps.04.13": [16, true], "aps.05.00": [8, true], "aps.06.00": [7, true], "aps.06.01": [8, true], "aps.06.02": [9, true], "aps.06.03": [10, true], "aps.06.04": [10, true], "aps.06.05": [11, true], "aps.06.06": [13, true], "aps.06.07": [13, true], "aps.06.08": [13, true], "aps.06.09": [14, true], "aps.07.00": [11, true], "aps.07.01": [11, true], "aps.07.02": [12, true], "aps.08.00": [7, true], "aps.08.01": [10, true], "aps.08.02": [10, true], "aps.08.03": [30, true], "aps.08.04": [11, true], "aps.09.00": [31, true], "aps.09.01": [12, true], "aps.09.02": [12, true], "aps.09.03": [11, true], "aps.09.04": [14, true], "aps.09.05": [16, true], "aps.09.06": [17, true], "aps.10.00": [9, true], "aps.10.01": [10, true], "aps.10.02": [33, true], "aps.10.03": [38, true], "aps.10.04": [18, true], "aps.11.00": [12, true], "aps.11.01": [12, true], "aps.11.02": [17, true], "aps.11.03": [16, true], "aps.12.00": [10, true], "aps.12.01": [10, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [10, true], "aps.12.07": [10, true], "aps.12.08": [10, true], "aps.12.09": [10, true], "aps.12.10": [10, true], "aps.12.11": [10, true], "aps.12.12": [10, true], "aps.12.13": [9, true], "aps.12.14": [10, true], "aps.12.15": [10, true], "aps.12.16": [10, true], "aps.12.17": [11, true], "aps.12.18": [11, true], "aps.13.00": [10, false], "aps.14.00": [19, true], "aps.14.01": [19, true], "aps.14.02": [19, true], "aps.14.03": [19, true], "aps.14.04": [19, true], "aps.14.05": [19, true], "aps.14.06": [19, true], "aps.14.07": [19, true], "aps.14.08": [19, true], "aps.14.09": [19, true], "aps.14.10": [19, true], "aps.14.11": [19, true], "aps.14.12": [19, true], "aps.14.13": [19, true], "aps.14.14": [19, true], "aps.14.15": [19, true], "aps.14.16": [19, true], "aps.14.17": [19, true], "aps.14.18": [19, true], "aps.14.19": [19, true], "aps.14.20": [19, true], "aps.14.21": [19, true], "aps.14.22": [19, true], "aps.14.23": [19, true], "aps.14.24": [19, true], "aps.14.25": [19, true], "aps.14.26": [19, true], "aps.14.27": [19, true], "aps.14.28": [19, true], "aps.14.29": [19, true], "aps.14.30": [19, true], "aps.14.31": [19, true], "aps.14.32": [19, true], "aps.14.33": [19, true], "aps.14.34": [19, true], "aps.14.35": [19, true], "aps.14.36": [19, true], "aps.14.37": [19, true], "aps.14.38": [19, true], "aps.14.39": [19, true], "aps.15.00": [32, true], "aps.15.01": [33, true], "aps.15.02": [32, true], "aps.15.03": [32, true], "aps.15.04": [32, true], "aps.15.05": [32, true], "aps.15.06": [32, true], "aps.15.07": [32, true], "aps.15.08": [32, true], "aps.15.09": [32, true], "aps.15.10": [33, true], "aps.15.11": [32, true], "aps.15.12": [32, true], "aps.15.13": [32, true], "aps.15.14": [32, true], "aps.15.15": [32, true], "aps.15.16": [33, true], "aps.15.17": [33, true], "aps.15.18": [33, true], "aps.15.19": [33, true], "aps.15.20": [32, true], "aps.15.21": [31, true], "aps.15.22": [34, true], "aps.15.23": [34, true], "aps.15.24": [34, true], "aps.15.25": [36, true], "aps.15.26": [36, true], "aps.15.27": [35, true], "aps.15.28": [36, true], "aps.15.29": [37, true], "aps.15.30": [37, true]}}, "CHA": {"total": 3580, "solved": 40, "n": 45, "over": 10, "per": {"fun1.1": [10, true], "fun1.2": [29, true], "fun1.3": [27, true], "fun1.4": [34, true], "fun1.5": [95, true], "fun2.1": [9, true], "fun2.2": [27, true], "fun2.3": [34, true], "fun2.4": [45, true], "fun2.5": [53, true], "fun3.1": [85, true], "fun3.2": [89, true], "fun3.3": [104, true], "fun3.4": [115, true], "fun3.5": [140, true], "fun4.1": [94, true], "fun4.2": [99, true], "fun4.3": [119, true], "fun4.4": [138, true], "fun4.5": [162, true], "fun5.1": [96, true], "fun5.2": [99, true], "fun5.3": [104, true], "fun5.4": [109, true], "fun5.5": [112, true], "fun6.1": [76, true], "fun6.2": [83, true], "fun6.3": [79, true], "fun6.4": [85, true], "fun6.5": [82, true], "fun7.1": [10, false], "fun7.2": [11, false], "fun7.3": [11, false], "fun7.4": [16, false], "fun7.5": [18, false], "fun8.1": [13, true], "fun8.2": [11, true], "fun8.3": [13, true], "fun8.4": [17, true], "fun8.5": [18, true], "fun9.1": [8, true], "fun9.2": [12, true], "fun9.3": [19, true], "fun9.4": [18, true], "fun9.5": [18, true]}}}, {"label": "pure.exp_abs.derived.both", "spec": ["pure", "exp_abs", "derived", "both"], "APS": {"total": 8099, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [49, true], "aps.02.00": [48, true], "aps.02.01": [49, true], "aps.02.02": [47, true], "aps.02.03": [51, true], "aps.02.04": [51, true], "aps.02.05": [51, true], "aps.02.06": [51, true], "aps.02.07": [51, true], "aps.02.08": [52, true], "aps.02.09": [52, true], "aps.03.00": [46, true], "aps.03.01": [54, true], "aps.03.02": [49, true], "aps.04.00": [52, true], "aps.04.01": [51, true], "aps.04.02": [50, true], "aps.04.03": [47, true], "aps.04.04": [50, true], "aps.04.05": [50, true], "aps.04.06": [50, true], "aps.04.07": [51, true], "aps.04.08": [51, true], "aps.04.09": [51, true], "aps.04.10": [49, true], "aps.04.11": [51, true], "aps.04.12": [51, true], "aps.04.13": [50, true], "aps.05.00": [42, true], "aps.06.00": [46, true], "aps.06.01": [47, true], "aps.06.02": [46, true], "aps.06.03": [44, true], "aps.06.04": [44, true], "aps.06.05": [46, true], "aps.06.06": [47, true], "aps.06.07": [45, true], "aps.06.08": [46, true], "aps.06.09": [46, true], "aps.07.00": [42, true], "aps.07.01": [44, true], "aps.07.02": [43, true], "aps.08.00": [47, true], "aps.08.01": [47, true], "aps.08.02": [47, true], "aps.08.03": [42, true], "aps.08.04": [43, true], "aps.09.00": [48, true], "aps.09.01": [44, true], "aps.09.02": [44, true], "aps.09.03": [45, true], "aps.09.04": [43, true], "aps.09.05": [42, true], "aps.09.06": [40, true], "aps.10.00": [46, true], "aps.10.01": [47, true], "aps.10.02": [47, true], "aps.10.03": [47, true], "aps.10.04": [46, true], "aps.11.00": [34, true], "aps.11.01": [47, true], "aps.11.02": [43, true], "aps.11.03": [49, true], "aps.12.00": [46, true], "aps.12.01": [46, true], "aps.12.02": [48, true], "aps.12.03": [49, true], "aps.12.04": [49, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [53, true], "aps.12.08": [52, true], "aps.12.09": [52, true], "aps.12.10": [50, true], "aps.12.11": [52, true], "aps.12.12": [51, true], "aps.12.13": [53, true], "aps.12.14": [52, true], "aps.12.15": [54, true], "aps.12.16": [54, true], "aps.12.17": [52, true], "aps.12.18": [52, true], "aps.13.00": [6, false], "aps.14.00": [57, true], "aps.14.01": [57, true], "aps.14.02": [57, true], "aps.14.03": [57, true], "aps.14.04": [57, true], "aps.14.05": [57, true], "aps.14.06": [57, true], "aps.14.07": [57, true], "aps.14.08": [57, true], "aps.14.09": [57, true], "aps.14.10": [57, true], "aps.14.11": [57, true], "aps.14.12": [57, true], "aps.14.13": [57, true], "aps.14.14": [57, true], "aps.14.15": [57, true], "aps.14.16": [57, true], "aps.14.17": [57, true], "aps.14.18": [57, true], "aps.14.19": [57, true], "aps.14.20": [57, true], "aps.14.21": [57, true], "aps.14.22": [57, true], "aps.14.23": [57, true], "aps.14.24": [57, true], "aps.14.25": [57, true], "aps.14.26": [57, true], "aps.14.27": [57, true], "aps.14.28": [57, true], "aps.14.29": [57, true], "aps.14.30": [57, true], "aps.14.31": [57, true], "aps.14.32": [57, true], "aps.14.33": [57, true], "aps.14.34": [57, true], "aps.14.35": [57, true], "aps.14.36": [57, true], "aps.14.37": [57, true], "aps.14.38": [57, true], "aps.14.39": [57, true], "aps.15.00": [56, true], "aps.15.01": [56, true], "aps.15.02": [53, true], "aps.15.03": [56, true], "aps.15.04": [56, true], "aps.15.05": [57, true], "aps.15.06": [56, true], "aps.15.07": [56, true], "aps.15.08": [56, true], "aps.15.09": [55, true], "aps.15.10": [55, true], "aps.15.11": [55, true], "aps.15.12": [55, true], "aps.15.13": [55, true], "aps.15.14": [55, true], "aps.15.15": [55, true], "aps.15.16": [54, true], "aps.15.17": [54, true], "aps.15.18": [54, true], "aps.15.19": [54, true], "aps.15.20": [53, true], "aps.15.21": [55, true], "aps.15.22": [54, true], "aps.15.23": [55, true], "aps.15.24": [46, true], "aps.15.25": [52, true], "aps.15.26": [55, true], "aps.15.27": [54, true], "aps.15.28": [55, true], "aps.15.29": [54, true], "aps.15.30": [47, true]}}, "CHA": {"total": 3614, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [46, true], "fun1.2": [53, true], "fun1.3": [55, true], "fun1.4": [66, true], "fun1.5": [96, true], "fun2.1": [47, true], "fun2.2": [65, true], "fun2.3": [68, true], "fun2.4": [82, true], "fun2.5": [79, true], "fun3.1": [65, true], "fun3.2": [69, true], "fun3.3": [83, true], "fun3.4": [88, true], "fun3.5": [108, true], "fun4.1": [69, true], "fun4.2": [63, true], "fun4.3": [78, true], "fun4.4": [91, true], "fun4.5": [112, true], "fun5.1": [69, true], "fun5.2": [68, true], "fun5.3": [72, true], "fun5.4": [77, true], "fun5.5": [79, true], "fun6.1": [54, true], "fun6.2": [57, true], "fun6.3": [50, true], "fun6.4": [50, true], "fun6.5": [50, true], "fun7.1": [6, false], "fun7.2": [9, false], "fun7.3": [8, false], "fun7.4": [14, false], "fun7.5": [12, false], "fun8.1": [37, true], "fun8.2": [50, true], "fun8.3": [49, true], "fun8.4": [55, true], "fun8.5": [58, true], "fun9.1": [45, true], "fun9.2": [49, true], "fun9.3": [53, true], "fun9.4": [54, true], "fun9.5": [55, true]}}}, {"label": "pure.exp_abs.derived3.both", "spec": ["pure", "exp_abs", "derived3", "both"], "APS": {"total": 8064, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [48, true], "aps.02.00": [49, true], "aps.02.01": [49, true], "aps.02.02": [50, true], "aps.02.03": [51, true], "aps.02.04": [50, true], "aps.02.05": [51, true], "aps.02.06": [50, true], "aps.02.07": [52, true], "aps.02.08": [51, true], "aps.02.09": [52, true], "aps.03.00": [54, true], "aps.03.01": [54, true], "aps.03.02": [54, true], "aps.04.00": [51, true], "aps.04.01": [51, true], "aps.04.02": [52, true], "aps.04.03": [35, true], "aps.04.04": [51, true], "aps.04.05": [50, true], "aps.04.06": [50, true], "aps.04.07": [51, true], "aps.04.08": [45, true], "aps.04.09": [52, true], "aps.04.10": [50, true], "aps.04.11": [48, true], "aps.04.12": [49, true], "aps.04.13": [50, true], "aps.05.00": [47, true], "aps.06.00": [46, true], "aps.06.01": [46, true], "aps.06.02": [45, true], "aps.06.03": [46, true], "aps.06.04": [46, true], "aps.06.05": [46, true], "aps.06.06": [46, true], "aps.06.07": [46, true], "aps.06.08": [46, true], "aps.06.09": [46, true], "aps.07.00": [44, true], "aps.07.01": [43, true], "aps.07.02": [43, true], "aps.08.00": [47, true], "aps.08.01": [45, true], "aps.08.02": [46, true], "aps.08.03": [47, true], "aps.08.04": [41, true], "aps.09.00": [45, true], "aps.09.01": [45, true], "aps.09.02": [43, true], "aps.09.03": [43, true], "aps.09.04": [41, true], "aps.09.05": [39, true], "aps.09.06": [39, true], "aps.10.00": [46, true], "aps.10.01": [48, true], "aps.10.02": [48, true], "aps.10.03": [49, true], "aps.10.04": [49, true], "aps.11.00": [34, true], "aps.11.01": [47, true], "aps.11.02": [47, true], "aps.11.03": [42, true], "aps.12.00": [50, true], "aps.12.01": [50, true], "aps.12.02": [51, true], "aps.12.03": [44, true], "aps.12.04": [50, true], "aps.12.05": [50, true], "aps.12.06": [50, true], "aps.12.07": [51, true], "aps.12.08": [50, true], "aps.12.09": [52, true], "aps.12.10": [48, true], "aps.12.11": [51, true], "aps.12.12": [51, true], "aps.12.13": [53, true], "aps.12.14": [50, true], "aps.12.15": [48, true], "aps.12.16": [51, true], "aps.12.17": [53, true], "aps.12.18": [52, true], "aps.13.00": [6, false], "aps.14.00": [56, true], "aps.14.01": [56, true], "aps.14.02": [56, true], "aps.14.03": [56, true], "aps.14.04": [56, true], "aps.14.05": [56, true], "aps.14.06": [56, true], "aps.14.07": [56, true], "aps.14.08": [57, true], "aps.14.09": [56, true], "aps.14.10": [57, true], "aps.14.11": [56, true], "aps.14.12": [56, true], "aps.14.13": [56, true], "aps.14.14": [56, true], "aps.14.15": [56, true], "aps.14.16": [56, true], "aps.14.17": [57, true], "aps.14.18": [56, true], "aps.14.19": [56, true], "aps.14.20": [56, true], "aps.14.21": [57, true], "aps.14.22": [56, true], "aps.14.23": [56, true], "aps.14.24": [56, true], "aps.14.25": [56, true], "aps.14.26": [56, true], "aps.14.27": [56, true], "aps.14.28": [56, true], "aps.14.29": [56, true], "aps.14.30": [56, true], "aps.14.31": [56, true], "aps.14.32": [57, true], "aps.14.33": [56, true], "aps.14.34": [56, true], "aps.14.35": [57, true], "aps.14.36": [56, true], "aps.14.37": [56, true], "aps.14.38": [56, true], "aps.14.39": [56, true], "aps.15.00": [56, true], "aps.15.01": [55, true], "aps.15.02": [55, true], "aps.15.03": [55, true], "aps.15.04": [55, true], "aps.15.05": [54, true], "aps.15.06": [56, true], "aps.15.07": [55, true], "aps.15.08": [55, true], "aps.15.09": [55, true], "aps.15.10": [54, true], "aps.15.11": [55, true], "aps.15.12": [54, true], "aps.15.13": [55, true], "aps.15.14": [55, true], "aps.15.15": [54, true], "aps.15.16": [54, true], "aps.15.17": [53, true], "aps.15.18": [53, true], "aps.15.19": [53, true], "aps.15.20": [53, true], "aps.15.21": [53, true], "aps.15.22": [53, true], "aps.15.23": [55, true], "aps.15.24": [56, true], "aps.15.25": [56, true], "aps.15.26": [56, true], "aps.15.27": [55, true], "aps.15.28": [54, true], "aps.15.29": [57, true], "aps.15.30": [57, true]}}, "CHA": {"total": 3694, "solved": 40, "n": 45, "over": 0, "per": {"fun1.1": [47, true], "fun1.2": [49, true], "fun1.3": [54, true], "fun1.4": [68, true], "fun1.5": [93, true], "fun2.1": [44, true], "fun2.2": [65, true], "fun2.3": [71, true], "fun2.4": [80, true], "fun2.5": [90, true], "fun3.1": [64, true], "fun3.2": [68, true], "fun3.3": [84, true], "fun3.4": [92, true], "fun3.5": [109, true], "fun4.1": [69, true], "fun4.2": [68, true], "fun4.3": [87, true], "fun4.4": [96, true], "fun4.5": [120, true], "fun5.1": [70, true], "fun5.2": [69, true], "fun5.3": [73, true], "fun5.4": [76, true], "fun5.5": [77, true], "fun6.1": [54, true], "fun6.2": [63, true], "fun6.3": [56, true], "fun6.4": [64, true], "fun6.5": [64, true], "fun7.1": [6, false], "fun7.2": [11, false], "fun7.3": [8, false], "fun7.4": [13, false], "fun7.5": [38, false], "fun8.1": [48, true], "fun8.2": [48, true], "fun8.3": [49, true], "fun8.4": [54, true], "fun8.5": [57, true], "fun9.1": [46, true], "fun9.2": [48, true], "fun9.3": [51, true], "fun9.4": [54, true], "fun9.5": [55, true]}}}, {"label": "toms748", "spec": ["base", "toms748"], "APS": {"total": 2819, "solved": 153, "n": 154, "over": 0, "per": {"aps.01.00": [10, true], "aps.02.00": [19, true], "aps.02.01": [15, true], "aps.02.02": [19, true], "aps.02.03": [13, true], "aps.02.04": [15, true], "aps.02.05": [11, true], "aps.02.06": [14, true], "aps.02.07": [13, true], "aps.02.08": [11, true], "aps.02.09": [11, true], "aps.03.00": [14, true], "aps.03.01": [14, true], "aps.03.02": [14, true], "aps.04.00": [18, true], "aps.04.01": [18, true], "aps.04.02": [20, true], "aps.04.03": [15, true], "aps.04.04": [19, true], "aps.04.05": [12, true], "aps.04.06": [12, true], "aps.04.07": [15, true], "aps.04.08": [14, true], "aps.04.09": [18, true], "aps.04.10": [19, true], "aps.04.11": [21, true], "aps.04.12": [22, true], "aps.04.13": [24, true], "aps.05.00": [9, true], "aps.06.00": [8, true], "aps.06.01": [9, true], "aps.06.02": [10, true], "aps.06.03": [10, true], "aps.06.04": [11, true], "aps.06.05": [12, true], "aps.06.06": [13, true], "aps.06.07": [13, true], "aps.06.08": [14, true], "aps.06.09": [14, true], "aps.07.00": [9, true], "aps.07.01": [7, true], "aps.07.02": [7, true], "aps.08.00": [3, true], "aps.08.01": [11, true], "aps.08.02": [12, true], "aps.08.03": [14, true], "aps.08.04": [13, true], "aps.09.00": [13, true], "aps.09.01": [11, true], "aps.09.02": [9, true], "aps.09.03": [8, true], "aps.09.04": [9, true], "aps.09.05": [7, true], "aps.09.06": [7, true], "aps.10.00": [11, true], "aps.10.01": [12, true], "aps.10.02": [15, true], "aps.10.03": [17, true], "aps.10.04": [17, true], "aps.11.00": [13, true], "aps.11.01": [16, true], "aps.11.02": [18, true], "aps.11.03": [18, true], "aps.12.00": [6, true], "aps.12.01": [6, true], "aps.12.02": [10, true], "aps.12.03": [10, true], "aps.12.04": [10, true], "aps.12.05": [10, true], "aps.12.06": [11, true], "aps.12.07": [11, true], "aps.12.08": [11, true], "aps.12.09": [11, true], "aps.12.10": [11, true], "aps.12.11": [11, true], "aps.12.12": [11, true], "aps.12.13": [11, true], "aps.12.14": [11, true], "aps.12.15": [11, true], "aps.12.16": [11, true], "aps.12.17": [11, true], "aps.12.18": [11, true], "aps.13.00": [16, false], "aps.14.00": [16, true], "aps.14.01": [16, true], "aps.14.02": [17, true], "aps.14.03": [16, true], "aps.14.04": [17, true], "aps.14.05": [17, true], "aps.14.06": [16, true], "aps.14.07": [16, true], "aps.14.08": [17, true], "aps.14.09": [17, true], "aps.14.10": [16, true], "aps.14.11": [17, true], "aps.14.12": [17, true], "aps.14.13": [16, true], "aps.14.14": [17, true], "aps.14.15": [16, true], "aps.14.16": [17, true], "aps.14.17": [17, true], "aps.14.18": [17, true], "aps.14.19": [17, true], "aps.14.20": [17, true], "aps.14.21": [16, true], "aps.14.22": [16, true], "aps.14.23": [17, true], "aps.14.24": [16, true], "aps.14.25": [17, true], "aps.14.26": [17, true], "aps.14.27": [16, true], "aps.14.28": [17, true], "aps.14.29": [17, true], "aps.14.30": [17, true], "aps.14.31": [16, true], "aps.14.32": [16, true], "aps.14.33": [17, true], "aps.14.34": [17, true], "aps.14.35": [17, true], "aps.14.36": [16, true], "aps.14.37": [17, true], "aps.14.38": [17, true], "aps.14.39": [17, true], "aps.15.00": [29, true], "aps.15.01": [29, true], "aps.15.02": [29, true], "aps.15.03": [29, true], "aps.15.04": [29, true], "aps.15.05": [29, true], "aps.15.06": [29, true], "aps.15.07": [29, true], "aps.15.08": [28, true], "aps.15.09": [29, true], "aps.15.10": [29, true], "aps.15.11": [27, true], "aps.15.12": [27, true], "aps.15.13": [27, true], "aps.15.14": [28, true], "aps.15.15": [27, true], "aps.15.16": [29, true], "aps.15.17": [28, true], "aps.15.18": [28, true], "aps.15.19": [29, true], "aps.15.20": [29, true], "aps.15.21": [31, true], "aps.15.22": [31, true], "aps.15.23": [33, true], "aps.15.24": [33, true], "aps.15.25": [33, true], "aps.15.26": [33, true], "aps.15.27": [31, true], "aps.15.28": [31, true], "aps.15.29": [33, true], "aps.15.30": [33, true]}}, "CHA": {"total": 4023, "solved": 40, "n": 45, "over": 16, "per": {"fun1.1": [11, true], "fun1.2": [15, true], "fun1.3": [19, true], "fun1.4": [39, true], "fun1.5": [81, true], "fun2.1": [11, true], "fun2.2": [48, true], "fun2.3": [66, true], "fun2.4": [95, true], "fun2.5": [113, true], "fun3.1": [91, true], "fun3.2": [97, true], "fun3.3": [131, true], "fun3.4": [157, true], "fun3.5": [172, true], "fun4.1": [95, true], "fun4.2": [89, true], "fun4.3": [141, true], "fun4.4": [141, true], "fun4.5": [129, true], "fun5.1": [95, true], "fun5.2": [108, true], "fun5.3": [117, true], "fun5.4": [129, true], "fun5.5": [132, true], "fun6.1": [70, true], "fun6.2": [112, true], "fun6.3": [110, true], "fun6.4": [138, true], "fun6.5": [95, true], "fun7.1": [18, false], "fun7.2": [19, false], "fun7.3": [22, false], "fun7.4": [19, false], "fun7.5": [10, false], "fun8.1": [14, true], "fun8.2": [14, true], "fun8.3": [20, true], "fun8.4": [21, true], "fun8.5": [28, true], "fun9.1": [9, true], "fun9.2": [11, true], "fun9.3": [20, true], "fun9.4": [16, true], "fun9.5": [23, true]}}}] \ No newline at end of file diff --git a/tests/test_analysis.py b/tests/test_analysis.py new file mode 100644 index 0000000..19edbff --- /dev/null +++ b/tests/test_analysis.py @@ -0,0 +1,150 @@ +"""Tests for the ANALYSIS code in stage4_why. + +The conclusions about why the method wins and loses rest entirely on three +pieces of machinery here - the phase boundary, the bracket replay, and the +observed order - plus the `stats` instrumentation added to brent and +pure_root. None of it was covered, which made the explanation the least +verified part of the project. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.baselines import bisection, brent +from simroot.pure import GUARDS, pure_root +from stage4_why import (observed_order, ours, phase_boundary, phases, + replay_bracket, traced) + +XTOL = 1e-12 +MAXFEV = 200 + + +# -------------------------------------------------------------------------- +# the phase boundary +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("width", [1.0, 5.0, 41.0, 1e4, 1e8, 1e12]) +def test_phase_boundary_splits_bisection_evenly(width): + """The boundary is defined as the log-midpoint of the journey, so + bisection - which halves at a constant rate - must spend the same number + of evaluations either side of it, on a bracket of any width. If this + fails, the approach/endgame table means nothing.""" + a, b = 0.0, width + root = width * 0.3 # away from the midpoint, so nothing is by luck + f = lambda x: x - root + app, end, tot = phases(bisection, f, a, b, root) + assert app + end == tot + assert abs(app - end) <= 4, f"width {width}: {app} vs {end}" + + +def test_phase_boundary_is_the_geometric_mean_of_width_and_attainable_tol(): + # near the origin the attainable tolerance is xtol itself + assert phase_boundary(1e12, 0.0, 1e-12) == pytest.approx(1.0) + assert phase_boundary(4.0, 0.0, 1e-12) == pytest.approx(2e-6) + # far from it, floating-point spacing is the real floor + assert phase_boundary(1e12, 1e12, 1e-12) > 1e3 + + +# -------------------------------------------------------------------------- +# the bracket replay +# -------------------------------------------------------------------------- +def test_replay_scores_bisection_at_exactly_one_half(): + """End-to-end check of the reconstruction: every bisection probe sits at + the midpoint and removes exactly half, by construction. Any error in the + replay shows up here immediately.""" + f = lambda x: x * x - 2.0 + g, xs = traced(f) + bisection(g, 0.0, 2.0, 1e-9, MAXFEV) + pos, shrinks, skipped = replay_bracket(f, 0.0, 2.0, xs[2:]) + assert skipped == 0 + assert pos, "no probes replayed" + for t in pos: + assert t == pytest.approx(0.5, abs=1e-12) + for s in shrinks: + assert s == pytest.approx(0.5, abs=1e-12) + + +def test_replay_counts_probes_outside_the_bracket(): + """A probe outside the proven bracket must be counted as skipped, not + silently dropped - dropping them flatters whoever probes outside.""" + f = lambda x: x - 1.0 + # 5.0 is outside [0, 2]; 1.5 and 0.5 are inside + pos, shrinks, skipped = replay_bracket(f, 0.0, 2.0, [1.5, 5.0, 0.5]) + assert skipped == 1 + assert len(pos) == len(shrinks) == 2 + + +def test_replay_shrinks_are_fractions(): + f = lambda x: math.cos(x) - x + g, xs = traced(f) + ours(g, 0.0, 1.0, XTOL, MAXFEV) + _pos, shrinks, _sk = replay_bracket(f, 0.0, 1.0, xs[2:]) + assert shrinks + for s in shrinks: + assert 0.0 <= s <= 1.0 + + +# -------------------------------------------------------------------------- +# the observed order +# -------------------------------------------------------------------------- +def test_observed_order_recovers_the_known_orders(): + """The whole explanation of the endgame loss is the measured order. It + must reproduce the textbook values for methods whose order is known.""" + f = lambda x: x * x - 2.0 + root = math.sqrt(2.0) + p_ours = observed_order(ours, f, 0.0, 2.0, root) + p_brent = observed_order(brent, f, 0.0, 2.0, root) + p_bis = observed_order(bisection, f, 0.0, 2.0, root) + assert 1.3 < p_ours < 1.9, p_ours # secant, 1.618 + assert p_brent > p_ours # inverse quadratic, 1.839 + assert p_bis < 1.3, p_bis # linear + + +# -------------------------------------------------------------------------- +# the instrumentation must not perturb what it measures +# -------------------------------------------------------------------------- +PROBS = [ + (lambda x: x * x - 2.0, 0.0, 2.0), + (lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0), + (lambda x: x ** 10 - 1.0, 0.0, 1.3), +] + + +@pytest.mark.parametrize("f,a,b", PROBS) +def test_brent_stats_do_not_change_brent(f, a, b): + plain = brent(f, a, b, XTOL, MAXFEV) + st = {} + withstats = brent(f, a, b, XTOL, MAXFEV, stats=st) + assert plain == withstats + assert 0 <= st["bisect"] <= plain[1] + + +@pytest.mark.parametrize("guard", GUARDS) +@pytest.mark.parametrize("f,a,b", PROBS) +def test_pure_stats_do_not_change_pure_root(f, a, b, guard): + plain = pure_root(f, a, b, XTOL, MAXFEV, guard=guard) + st = {} + withstats = pure_root(f, a, b, XTOL, MAXFEV, guard=guard, stats=st) + assert plain == withstats + assert 0 <= st["forced"] <= plain[1] + + +@pytest.mark.parametrize("f,a,b", PROBS) +def test_an_unguarded_run_forces_nothing(f, a, b): + st = {} + pure_root(f, a, b, XTOL, MAXFEV, guard="none", stats=st) + assert st["forced"] == 0 + + +def test_the_bracket_guard_actually_fires_where_it_is_needed(): + """The flat problem is the one that defeats every interpolation-only + rule; the safeguard must be doing visible work there.""" + f = lambda x: math.exp(-x) * (x - 1.0) + st = {} + pure_root(f, -1.0, 40.0, XTOL, MAXFEV, guard="bracket", stats=st) + assert st["forced"] > 0 diff --git a/tests/test_anc.py b/tests/test_anc.py new file mode 100644 index 0000000..8c9ef83 --- /dev/null +++ b/tests/test_anc.py @@ -0,0 +1,91 @@ +"""Active noise control: the step size of an NLMS canceller. + +The third domain, and the third instance of the same pattern. What is pinned +here is the pattern and the mistake, not a victory. +""" +from __future__ import annotations + +import math +import os +import sys + +import numpy as np +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from anc.bench import SCENARIOS, make_primary_path, make_secondary_path, run_nlms +from anc.rules import Fixed, InSampleMeasured, KwongJohnston, Measured + +N, SEEDS = 8000, 4 + + +SNRS = (30.0, 15.0) + + +def sweep(rule, snrs=SNRS): + """Both noise levels, as the experiment uses. + + Measuring at 30 dB alone is the wrong test and was: with almost no + measurement noise there is nothing for a safety factor to hedge against, + the exact step mu = 1 is near optimal, and any hedging costs a little. + The whole point of the rule appears at 15 dB. A claim about the grid has + to be tested on the grid.""" + vals = [] + for snr in snrs: + for s in range(SEEDS): + for _sname, gen in SCENARIOS: + rng = np.random.default_rng(1000 + s) + noise = gen(N, rng) + nr = run_nlms(noise, make_primary_path(rng), + make_secondary_path(rng), rule, snr_db=snr, + seed=s) + if math.isfinite(nr): + vals.append(nr) + return sum(vals) / len(vals), min(vals), len(vals) + + +def test_the_in_sample_observable_is_uninformative(): + """The mistake, pinned. NLMS with mu = 1 drives the a posteriori error of + the current sample to exactly zero, so a rule that measures it reads 'the + model was perfect' and proposes mu = 1 for ever. It is therefore the + fixed mu = 1 rule under another name, and the numbers say so.""" + a, _lo, _n = sweep(InSampleMeasured()) + b, _lo2, _n2 = sweep(Fixed(1.0)) + assert abs(a - b) < 0.1, (a, b) + + +def test_measuring_out_of_sample_is_better_than_measuring_in_sample(): + """The fix: what mu hedges against is the part of the error the filter + cannot cancel, and that is observable as the floor the error keeps + hitting - not as the residual of the sample just fitted.""" + good, _lo, _n = sweep(Measured()) + bad, _lo2, _n2 = sweep(InSampleMeasured()) + assert good > bad, (good, bad) + + +def test_the_measured_rule_beats_the_four_constant_scheme(): + """Kwong-Johnston is the classical variable-step-size rule and carries + four constants. This is the comparison the transfer is about.""" + ours, _lo, _n = sweep(Measured()) + kj, _lo2, _n2 = sweep(KwongJohnston()) + assert ours > kj + 3.0, (ours, kj) + + +def test_and_loses_to_one_well_chosen_constant(): + """The other half, and the same in all three domains: measuring the + constant beats the elaborate multi-constant schemes and does not beat a + single constant chosen correctly for the benchmark.""" + ours, _lo, _n = sweep(Measured()) + best_fixed, _lo2, _n2 = sweep(Fixed(0.5)) + assert best_fixed > ours, (best_fixed, ours) + assert best_fixed - ours < 3.0, (best_fixed, ours) + + +def test_no_rule_diverges(): + """A step size that is too large makes the filter blow up; none of these + may.""" + for rule in (Fixed(0.1), Fixed(0.5), Fixed(1.0), KwongJohnston(), + Measured()): + _m, _lo, n = sweep(rule) + assert n == SEEDS * len(SCENARIOS) * len(SNRS), (rule.name, n) diff --git a/tests/test_article_numbers.py b/tests/test_article_numbers.py new file mode 100644 index 0000000..5a2e309 --- /dev/null +++ b/tests/test_article_numbers.py @@ -0,0 +1,89 @@ +"""The paper's numbers are part of the regression. + +A table transcribed by hand drifts from its data the first time the data is +regenerated. verify_article.py asserts all 72 stated numbers against +sweep_full.json; this makes that check part of the suite, so a re-run of the +sweep that moves a number fails the build instead of quietly invalidating the +paper. +""" +from __future__ import annotations + +import os +import subprocess +import sys + +import pytest + +ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + +# the other end of the trade the paper states: better average, one constant +PROJ_LABEL = "pure.ratio.derived3.project" + + +@pytest.mark.skipif(not os.path.exists(os.path.join(ROOT, "sweep_full.json")), + reason="sweep_full.json not present; run sweep_full.py") +def test_every_number_in_the_paper_matches_the_sweep(): + r = subprocess.run([sys.executable, "verify_article.py"], cwd=ROOT, + capture_output=True, text=True, timeout=600) + tail = "\n".join(r.stdout.strip().splitlines()[-25:]) + assert r.returncode == 0, f"the paper disagrees with the data:\n{tail}" + assert "every number stated in the paper matches" in r.stdout + assert r.stdout.count(" OK ") >= 72, r.stdout.count(" OK ") + + +@pytest.mark.skipif(not os.path.exists(os.path.join(ROOT, "sweep_full.json")), + reason="sweep_full.json not present") +def test_the_headline_claim_is_what_the_paper_says_it_is(): + """Guard against the one mistake that would matter most: the abstract + claiming a place the data does not support. + + It caught exactly that. Until Chandrupatla's own method was added - a + reader asked why the owner of half the benchmark was missing - this test + asserted that a configuration of ours came first, and it passed only + because the method that beats us was absent from the field. The claim it + now guards is the corrected one: we are not first, Chandrupatla is, and + our margin behind it on the canonical set is under one percent.""" + import json + + from report_sweep import PROPOSED, rank + with open(os.path.join(ROOT, "sweep_full.json"), encoding="utf8") as fh: + rows = json.load(fh) + by = {r["label"]: r for r in rows} + assert "chandrupatla" in by, "the sweep predates the missing baselines" + + aps = rank(rows, "APS") + assert aps[0]["label"] == "chandrupatla", aps[0]["label"] + + def both(lbl): + return by[lbl]["APS"]["total"] + by[lbl]["CHA"]["total"] + + # What the paper may claim for the credit method, and nothing more. + # It is NOT within a percent of the best on Alefeld-Potra-Shi - that was + # true of the projection variant, which carries a constant. Buying + # constant-freedom and a near-bisection worst case costs average + # performance, and the test pins the direction of that trade so the + # abstract cannot quietly reclaim the projection variant's numbers. + assert both(PROPOSED) > both("chandrupatla"), "behind Chandrupatla" + for weaker in ("toms748", "brent", "itp", "ridders", "bisection"): + assert both(PROPOSED) < both(weaker), weaker + + # On the canonical set alone it is behind the classical methods; saying + # otherwise would be quoting the projection variant. + assert by[PROPOSED]["APS"]["total"] > by["toms748"]["APS"]["total"] + assert by[PROPOSED]["APS"]["total"] > by["brent"]["APS"]["total"] + + # The claim it does own: the worst single problem, over the problems it + # solves, is close to bisection's and far below the classical methods'. + def worst(lbl): + w = 0 + for setname in ("APS", "CHA"): + for n, ok in by[lbl][setname]["per"].values(): + if ok: + w = max(w, n) + return w + + assert worst(PROPOSED) < 100, worst(PROPOSED) + assert worst(PROPOSED) < worst("brent") + assert worst(PROPOSED) < worst("toms748") + assert worst(PROPOSED) < worst(PROJ_LABEL), (worst(PROPOSED), + worst(PROJ_LABEL)) diff --git a/tests/test_blend.py b/tests/test_blend.py new file mode 100644 index 0000000..44cd5a0 --- /dev/null +++ b/tests/test_blend.py @@ -0,0 +1,90 @@ +"""Grafting similarity onto existing methods: where it works and where not. + +The project's one clear success was a graft - the credit safeguard turned +regula falsi, the secant rule and inverse quadratic interpolation into methods +that solve 193 of 199 with a near-bisection worst case. This file pins the +graft that FAILED, and the boundary the two of them mark out. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.baselines import brent, chandrupatla +from stage16_blend import brent_blend, chandrupatla_blend, load, measure + +PROBS = load() + + +def both(m): + t, ok, worst = measure(m, PROBS) + return t["APS"] + t["CHA"], ok["APS"] + ok["CHA"], worst + + +def test_the_controls_reproduce_the_published_methods_exactly(): + """Without this the experiment is void: a blend must be compared against + the same code with the blend switched off, not against a different + implementation.""" + pub_b = both(lambda f, a, b, xt, mx: brent(f, a, b, xt, mx)) + off_b = both(lambda f, a, b, xt, mx: brent_blend(f, a, b, xt, mx, + mode="off")) + assert pub_b == off_b, (pub_b, off_b) + pub_c = both(lambda f, a, b, xt, mx: chandrupatla(f, a, b, xt, mx)) + off_c = both(lambda f, a, b, xt, mx: chandrupatla_blend(f, a, b, xt, mx, + mode="off")) + assert pub_c == off_c, (pub_c, off_c) + + +def test_softening_brents_acceptance_test_makes_it_worse(): + base, _s, _w = both(lambda f, a, b, xt, mx: brent(f, a, b, xt, mx)) + blend, _s2, _w2 = both(lambda f, a, b, xt, mx: brent_blend(f, a, b, xt, mx, + mode="blend")) + assert blend > 1.2 * base, (base, blend) + + +def test_softening_chandrupatlas_acceptance_test_makes_it_worse(): + base, s_base, _w = both(lambda f, a, b, xt, mx: chandrupatla(f, a, b, xt, + mx)) + blend, s_blend, _w2 = both( + lambda f, a, b, xt, mx: chandrupatla_blend(f, a, b, xt, mx, + mode="blend")) + assert blend > 1.2 * base, (base, blend) + assert s_blend < s_base, (s_base, s_blend) # and it breaks problems + + +def test_projecting_onto_brents_bound_also_fails(): + """The move that worked inside our own method - project, do not replace - + does not transfer to somebody else's acceptance condition. Clamping to + the boundary produces the most aggressive still-permitted step, which is + exactly where the interpolation has stopped carrying information.""" + base, s_base, _w = both(lambda f, a, b, xt, mx: brent(f, a, b, xt, mx)) + proj, s_proj, _w2 = both(lambda f, a, b, xt, mx: brent_blend( + f, a, b, xt, mx, mode="project")) + assert proj > base, (base, proj) + assert s_proj < s_base, (s_base, s_proj) + + +def test_the_boundary_this_marks_out(): + """Three failures against one success, and they differ in kind. + + The safeguard graft succeeded where the quantity being controlled is a + GRADED QUALITY - how much margin to leave, how bold a step to take. The + blend graft failed where the quantity is a VALIDITY CONDITION - whether + the interpolation model applies at all. Near such a boundary a point is + not partly good; it is where the model has just stopped holding, which is + why Brent and Chandrupatla discard it rather than shrink it.""" + from stage14_is_anything_reusable import RULES, load as load14, measure as m14 + p14 = load14() + for name, rule in RULES: + t_raw, s_raw, _w = m14(rule, False, p14) + t_g, s_g, _w2 = m14(rule, True, p14) + assert s_g > s_raw and t_g < t_raw, name # the graft that works + base, _s, _w = both(lambda f, a, b, xt, mx: brent(f, a, b, xt, mx)) + blend, _s2, _w2 = both(lambda f, a, b, xt, mx: brent_blend( + f, a, b, xt, mx, mode="blend")) + assert blend > base # the graft that does not diff --git a/tests/test_bulletproof.py b/tests/test_bulletproof.py new file mode 100644 index 0000000..19b0c16 --- /dev/null +++ b/tests/test_bulletproof.py @@ -0,0 +1,161 @@ +"""The one claim that survives the objection a reader raises first. + +Everything else in this project is a tie, a loss, or a negative result. This +file pins the exception and, just as important, pins its scope: it is a claim +about REPAIRING regula falsi, not about being the best root finder. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.baselines import (anderson_bjorck, brent, chandrupatla, illinois, + pegasus, regula_falsi) +from stage18_bulletproof import falsi_driver, load_roots + +XTOL, MAXFEV, ACC = 1e-12, 200, 1e-6 +PROBS = load_roots() +REPAIRS = ("none", "illinois", "pegasus", "anderson", "credit") + + +def score(method): + total = solved = worst = 0 + for f, a, b, root in PROBS: + try: + x, n, conv = method(f, a, b, XTOL, MAXFEV) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + total += n if ok else MAXFEV + solved += ok + if ok: + worst = max(worst, n) + return total, solved, worst + + +def by_repair(repair): + return score(lambda f, a, b, xt, mx: falsi_driver(f, a, b, xt, mx, repair)) + + +# -------------------------------------------------------------------------- +# the driver cannot be handicapping the competitors +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("repair,independent", [ + ("none", regula_falsi), ("illinois", illinois), ("pegasus", pegasus), + ("anderson", anderson_bjorck)]) +def test_two_independent_implementations_agree_exactly(repair, independent): + """The classical repairs exist twice in this repository, written at + different times against different structures: `_false_position_family` in + simroot.baselines, and the pluggable driver in stage18. They agree to the + evaluation, which is what removes 'your driver favours your repair' from + the table.""" + a = score(independent) + b = by_repair(repair) + assert a[:2] == b[:2], (repair, a, b) + + +# -------------------------------------------------------------------------- +# the claim +# -------------------------------------------------------------------------- +def test_credit_beats_every_classical_repair_on_both_axes_at_once(): + """Same interpolation, same driver, same budget; only the repair differs. + Against Illinois (1971), Pegasus (1972) and Anderson-Bjorck (1973).""" + c_total, c_solved, c_worst = by_repair("credit") + for repair in ("illinois", "pegasus", "anderson"): + t, s, w = by_repair(repair) + assert c_solved > s, (repair, c_solved, s) + assert c_worst < w, (repair, c_worst, w) + assert c_total < min(by_repair(r)[0] for r in ("illinois", "pegasus", + "anderson")) + + +def test_no_classical_repair_gets_near_the_solved_count(): + """193 of 199 is what bisection, Chandrupatla and TOMS 748 achieve; the + best classical repair of regula falsi reaches 176.""" + _t, c_solved, _w = by_repair("credit") + assert c_solved == 193, c_solved + for repair in ("none", "illinois", "pegasus", "anderson"): + assert by_repair(repair)[1] <= 176, repair + + +def test_the_advantage_is_not_an_artefact_of_aggregating_two_sets(): + """A reader will ask whether the win comes from one set. On the + wide-bracket set the credit repair halves the cost and doubles the solved + count; on the canonical set it matches Illinois's solved count at lower + cost. Anderson-Bjorck is cheaper there, and fails eight problems the + credit repair solves - that trade is stated, not hidden.""" + from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + + def per_set(repair, dicts, chand): + total = solved = 0 + for d in dicts: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + args = () if chand else d.get("args", ()) + f = (lambda ff, aa: lambda t: ff(t, *aa))(d["f"], args) + try: + x, n, conv = falsi_driver(f, a, b, XTOL, MAXFEV, repair) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = bool(conv and math.isfinite(x) + and abs(x - float(d["root"])) <= ACC) + total += n if ok else MAXFEV + solved += ok + return total, solved + + for repair in ("illinois", "pegasus", "anderson"): + c_t, c_s = per_set("credit", _CHANDRUPATLA_TESTS_DICTS, True) + t, s = per_set(repair, _CHANDRUPATLA_TESTS_DICTS, True) + assert c_t < 0.7 * t, (repair, c_t, t) # halves the cost + assert c_s >= 1.7 * s, (repair, c_s, s) # doubles the solved + + +def test_the_scope_of_the_claim_is_repairs_not_the_field(): + """The credit repair of regula falsi is still beaten by Brent and by + Chandrupatla. The claim must never be stated as 'the best root finder'.""" + c_total, _s, _w = by_repair("credit") + for better in (brent, chandrupatla): + t, _s2, _w2 = score(lambda f, a, b, xt, mx, _m=better: _m(f, a, b, xt, + mx)) + assert t < c_total, (better.__name__, t, c_total) + + +# -------------------------------------------------------------------------- +# the claim that does NOT survive, pinned so it is not overstated +# -------------------------------------------------------------------------- +def test_the_anc_claim_is_not_uniform_and_must_be_stated_as_such(): + """Against a Kwong-Johnston oracle tuned per scenario the measured step + size wins on the mean (19.14 dB against 17.51) but on only four of ten + cells, and the mean is carried by two of them. It is a real result and + it is not bullet-proof; this test exists so the difference is not blurred.""" + import numpy as np + + from anc.bench import SCENARIOS, make_primary_path, make_secondary_path, \ + run_nlms + from anc.rules import Measured + from stage18_bulletproof import KJTuned, KJ_GRID + + wins = cells = 0 + for _sname, gen in SCENARIOS: + for snr in (30.0, 15.0): + def sc(rule): + vals = [] + for s in range(3): + rng = np.random.default_rng(1000 + s) + noise = gen(8000, rng) + nr = run_nlms(noise, make_primary_path(rng), + make_secondary_path(rng), rule, + snr_db=snr, seed=s) + if math.isfinite(nr): + vals.append(nr) + return sum(vals) / len(vals) + ours = sc(Measured()) + best_kj = max(sc(KJTuned(a, g)) for a, g in KJ_GRID) + cells += 1 + wins += ours > best_kj + assert 0 < wins < cells, (wins, cells) diff --git a/tests/test_credit_guard.py b/tests/test_credit_guard.py new file mode 100644 index 0000000..0d91cb0 --- /dev/null +++ b/tests/test_credit_guard.py @@ -0,0 +1,246 @@ +"""The credit safeguard: the budget earned instead of scheduled. + +The scheduled projection needs a multiplier, and the argument for 2 was +circular. This one banks the surplus a step delivers beyond a halving and +lends only what has been banked, so the only constant left is the endowment, +and one bit is the smallest integer for which the rule is not degenerate. + +What must hold, and is asserted here: the stronger guarantee is real, the +endowment is minimal, and the cost of the stronger guarantee is stated rather +than hidden. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.pure import _Safeguard, pure_root + +XTOL, MAXFEV, ACC = 1e-12, 200, 1e-6 + + +def problems(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append(((lambda ff, aa: lambda x: ff(x, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append(((lambda ff: lambda x: ff(x))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +ALL = problems() + + +def sweep(guard): + total = solved = over = 0 + for f, a, b, root in ALL: + try: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", + scale="derived3", guard=guard) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + total += n if ok else MAXFEV + solved += ok + if ok and n > math.ceil(math.log2(abs(b - a) / XTOL)) + 4: + over += 1 + return total, solved, over + + +def test_the_credit_guard_meets_the_near_minimal_bound_everywhere(): + """bisection + one step, on all 199 problems. The scheduled projection + is allowed twice that and uses it on 19 of them.""" + _t, solved, over = sweep("credit") + assert solved == 193, solved + assert over == 0, over + + +def test_the_scheduled_projection_really_does_use_its_larger_budget(): + """If this ever drops to zero the two guards have converged and the + multiplier stopped mattering - which would be worth knowing.""" + _t, solved, over = sweep("project") + assert solved == 193, solved + assert over > 10, over + + +def test_the_stronger_guarantee_costs_and_the_cost_is_stated(): + """No free lunch: the paper must not claim the credit rule is both + cheaper and safer.""" + t_credit, _s, _o = sweep("credit") + t_sched, _s2, _o2 = sweep("project") + assert t_credit > t_sched, (t_credit, t_sched) + assert (t_credit - t_sched) / t_sched < 0.15, (t_credit, t_sched) + + +def test_a_zero_endowment_is_degenerate(): + """Why one bit is the minimum: with no endowment the allowance on the + first step is exactly half the bracket, which forces the midpoint.""" + sg = _Safeguard("credit", 1.0, XTOL) + assert sg.credit == 1.0 + sg.credit = 0.0 + assert sg.project_credit(0.9, 0.0, 1.0) == pytest.approx(0.5) + # with the endowment the same step is left alone + sg.credit = 1.0 + assert sg.project_credit(0.9, 0.0, 1.0) == pytest.approx(0.9) + + +def test_credit_never_goes_negative_and_banks_surplus(): + sg = _Safeguard("credit", 1.0, XTOL) + sg.credit = 0.0 + sg.note_shrink(1.0, 1.0) # no shrink at all + assert sg.credit == 0.0 # clamped, never a debt + sg.note_shrink(1.0, 0.125) # three bits of shrink + assert sg.credit == pytest.approx(2.0) + + +@pytest.mark.parametrize("c0,steps_over", [(0.25, 1), (0.5, 1), (1.0, 1), + (2.0, 2), (3.0, 3)]) +def test_the_guarantee_is_bisection_plus_ceil_of_the_endowment(c0, steps_over): + """The relation that makes the endowment determined rather than chosen.""" + worst = 0 + for f, a, b, root in ALL: + try: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", + scale="derived3", guard="credit", + endowment=c0) + except Exception: + continue + if conv and math.isfinite(x) and abs(x - root) <= ACC: + half = math.ceil(math.log2(abs(b - a) / XTOL)) + worst = max(worst, (n - 2) - half) + assert worst == steps_over, (c0, worst, steps_over) + + +def test_one_bit_is_the_cheapest_endowment_that_promises_one_step(): + """Why C0 = 1 is forced and not picked: every C0 in (0,1] gives the same + one-step guarantee, and 1 is the most permissive of them, hence the + cheapest. If a smaller endowment ever became cheaper, the argument that + the constant is determined would collapse.""" + def cost(c0): + t = 0 + for f, a, b, root in ALL: + try: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, + similarity="ratio", scale="derived3", + guard="credit", endowment=c0) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = conv and math.isfinite(x) and abs(x - root) <= ACC + t += n if ok else MAXFEV + return t + + c_one = cost(1.0) + for smaller in (0.1, 0.25, 0.5): + assert cost(smaller) > c_one, smaller + + +def test_the_scheduled_multiplier_has_no_such_determination(): + """The contrast that decides which safeguard the paper should propose. + The multiplicative family has no smallest non-trivial member: 1 is + degenerate and everything above it is admissible with a different cost, so + the multiplier is genuinely free.""" + def cost(fac): + t = 0 + for f, a, b, root in ALL: + try: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, + similarity="ratio", scale="derived3", + guard="project", budget_factor=fac) + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = conv and math.isfinite(x) and abs(x - root) <= ACC + t += n if ok else MAXFEV + return t + + degenerate = cost(1.0) + assert degenerate > cost(2.0) # 1 is degenerate + assert cost(1.25) < cost(2.0) # and 2 is not the best either + + +def test_the_endowment_cannot_be_earned_and_so_cannot_be_computed(): + """Why C0 is a licence rather than a quantity to be derived from the run. + + Credit is earned only by a step that beats a halving, and such a step is + permitted only when credit already exists. Starting from zero the + mechanism is locked: the allowance is exactly half the bracket, which + forces the midpoint, which delivers exactly one bit, which banks nothing. + The method is then bisection and stays bisection - so no amount of running + can produce the evidence that would justify a larger endowment.""" + sg = _Safeguard("credit", 1.0, XTOL) + sg.credit = 0.0 + probe = None + for _ in range(30): + probe = sg.project_credit(0.99, 0.0, 1.0) # a bold step is proposed + assert probe == pytest.approx(0.5) # ...and always refused + sg.note_shrink(1.0, max(probe, 1.0 - probe)) + assert sg.credit == 0.0 # nothing is ever banked + + # end to end: zero endowment reproduces bisection's cost + from simroot.baselines import bisection + t_zero = t_bis = 0 + for f, a, b, root in ALL: + for meth, acc in ((lambda: pure_root(f, a, b, XTOL, MAXFEV, + similarity="ratio", + scale="derived3", guard="credit", + endowment=0.0), "z"), + (lambda: bisection(f, a, b, XTOL, MAXFEV), "b")): + try: + x, n, conv = meth() + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = conv and math.isfinite(x) and abs(x - root) <= ACC + if acc == "z": + t_zero += n if ok else MAXFEV + else: + t_bis += n if ok else MAXFEV + assert abs(t_zero - t_bis) / t_bis < 0.01, (t_zero, t_bis) + + +def test_a_large_credit_cannot_overflow_the_exponent(): + """Found by the algorithm audit. The allowance is w * 2^(C-1) and C + accumulates the log of every shrink without bound, so the exponentiation + overflowed a double at C ~ 1025 and the OverflowError escaped - only the + budget exception is caught in pure_root. It is reachable: sixty + nine-decade steps reach C = 1012, and a bracket of width 1e300 with a + tolerance of 1e-8 has about 1023 bits of shrink available.""" + sg = _Safeguard("credit", 1.0, XTOL) + for c in (1.0, 100.0, 1024.0, 1100.0, 1e6): + sg.credit = c + assert sg.project_credit(0.9, 0.0, 1.0) == 0.9, c + # and the accumulation that gets there must not raise either + sg.credit = 1.0 + w = 1.0 + for _ in range(60): + sg.note_shrink(w, w * 1e-9) + w *= 1e-9 + assert sg.credit > 1000.0 + assert sg.project_credit(0.9, 0.0, 1.0) == 0.9 + + +def test_a_very_wide_bracket_is_solved_end_to_end(): + """The same defect, reached through the public entry point.""" + x, n, conv = pure_root(lambda t: t - 1.0, -1e150, 1e150, 1e-12, 4000, + similarity="ratio", scale="derived3", + guard="credit") + assert conv and abs(x - 1.0) < 1e-6, (x, n, conv) + + +def test_credit_needs_no_tolerance_at_all(): + """Unlike the scheduled version it reads only widths, so there is no + n_max, no eps, and nothing fixed in advance from the initial bracket.""" + f = lambda t: t * t - 2.0 + x, _n, conv = pure_root(f, 0.0, 2.0, XTOL, MAXFEV, similarity="ratio", + scale="derived3", guard="credit") + assert conv and abs(x - math.sqrt(2.0)) <= 1e-8 diff --git a/tests/test_modern_repairs.py b/tests/test_modern_repairs.py new file mode 100644 index 0000000..c3f5f52 --- /dev/null +++ b/tests/test_modern_repairs.py @@ -0,0 +1,111 @@ +"""The objection that the comparison stopped at 1973, and what it settled. + +Two things came out of running it, and they scope the claim exactly: + + the credit projection is the best repair known for the false-position + family - better than 1971, 1972, 1973, 1995 and 2011 on evaluations, + solved count and worst case at once, and the only one that reaches the + 193-of-199 ceiling; + + and it is NOT better than a purpose-built acceptance test: swapped into + Chandrupatla's own interpolation it costs 7627 where his test costs 5209. + +So the safeguard is a good DEFAULT for a rule that has none, not a +replacement for one that has a good one. Both halves are pinned. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.baselines import chandrupatla +from stage18_bulletproof import falsi_driver, load_roots +from stage19_modern import chandrupatla_guard, falsi_modern, score + +PROBS = load_roots() +XTOL, MAXFEV = 1e-12, 200 + + +def falsi(repair): + return score(lambda f, a, b, xt, mx: falsi_driver(f, a, b, xt, mx, repair), + PROBS) + + +def modern(variant): + return score(lambda f, a, b, xt, mx: falsi_modern(f, a, b, xt, mx, variant), + PROBS) + + +# -------------------------------------------------------------------------- +# the half that holds +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("name,getter", [ + ("illinois-1971", lambda: falsi("illinois")), + ("pegasus-1972", lambda: falsi("pegasus")), + ("anderson-1973", lambda: falsi("anderson")), + ("ford-1995", lambda: modern("ford")), + ("galdino-2011", lambda: modern("galdino")), +]) +def test_credit_beats_every_published_repair_on_all_three_axes(name, getter): + c_t, c_s, c_w = falsi("credit") + t, s, w = getter() + assert c_t < t, (name, c_t, t) + assert c_s > s, (name, c_s, s) + assert c_w < w, (name, c_w, w) + + +def test_no_published_repair_reaches_the_ceiling(): + """193 of 199 is what bisection, Chandrupatla and TOMS 748 reach. Fifty + years of repairs of the false-position family stop at 176.""" + assert falsi("credit")[1] == 193 + for g in (lambda: falsi("illinois"), lambda: falsi("pegasus"), + lambda: falsi("anderson"), lambda: modern("ford"), + lambda: modern("galdino")): + assert g()[1] <= 176 + + +# -------------------------------------------------------------------------- +# the half that does not - pinned so the claim is never overstated +# -------------------------------------------------------------------------- +def test_the_pluggable_chandrupatla_reproduces_the_published_one(): + """Without this the swap below compares against a different algorithm.""" + a = score(lambda f, x, y, xt, mx: chandrupatla_guard(f, x, y, xt, mx, + "own"), PROBS) + b = score(lambda f, x, y, xt, mx: chandrupatla(f, x, y, xt, mx), PROBS) + assert a[:2] == b[:2], (a, b) + + +def test_credit_rescues_chandrupatlas_interpolation_but_loses_to_his_test(): + """The sharp test. Same interpolation, same bookkeeping, only the guard + differs. Credit turns an unguarded rule that solves 165 into one that + solves 193 - and Chandrupatla's own acceptance test does the same job for + a third fewer evaluations.""" + own = score(lambda f, a, b, xt, mx: chandrupatla_guard(f, a, b, xt, mx, + "own"), PROBS) + cred = score(lambda f, a, b, xt, mx: chandrupatla_guard(f, a, b, xt, mx, + "credit"), PROBS) + none = score(lambda f, a, b, xt, mx: chandrupatla_guard(f, a, b, xt, mx, + "none"), PROBS) + assert cred[1] > none[1] and cred[0] < none[0] # it rescues + assert own[0] < cred[0] # and is beaten + assert own[1] == cred[1] == 193 + + +def test_the_scope_sentence_the_paper_may_use(): + """A default safeguard for a rule that has none - not a replacement for a + purpose-built one. Both directions asserted together so neither can be + quoted alone.""" + c_t, c_s, _cw = falsi("credit") + best_published = min(falsi(r)[0] for r in ("illinois", "pegasus", + "anderson")) + best_published = min(best_published, modern("ford")[0], + modern("galdino")[0]) + assert c_t < best_published # best repair known + own = score(lambda f, a, b, xt, mx: chandrupatla_guard(f, a, b, xt, mx, + "own"), PROBS) + assert own[0] < c_t # and not the best guard diff --git a/tests/test_ode_controllers.py b/tests/test_ode_controllers.py new file mode 100644 index 0000000..f59d174 --- /dev/null +++ b/tests/test_ode_controllers.py @@ -0,0 +1,102 @@ +"""The second domain: adaptive step-size control for ODEs. + +What is being tested is the transfer, not the integrator: everything except +the controller is shared, so a difference can only come from the controller. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from odestep.controllers import (ALL, Classical, Elementary, GustafssonPI, + MeasuredSafety) +from odestep.driver import integrate, validate_against_scipy +from stage15_ode import PROBLEMS, TOLS, reference, scaled_err + + +def test_the_driver_reproduces_the_library(): + """The instrument before the experiment. + + The first version of this work carried a hand-typed Dormand-Prince + tableau and validated it by measuring convergence orders. That was both + an unnecessary risk and, as it turned out, a material one: with the + hand-written tableau the measured-safety controller appeared to beat the + five-constant PI controller by 8%, and with SciPy's it is 2.6% behind. + The integrator is now SciPy's throughout and the check is direct.""" + for name, mine, ref, endpoint in validate_against_scipy(): + assert abs(mine - ref) / ref < 0.05, (name, mine, ref) + assert endpoint < 1e-6, (name, endpoint) + + +def test_every_controller_solves_an_easy_problem(): + f = lambda t, y: [-y[0]] + for c in ALL: + r = integrate(f, 0.0, 10.0, [1.0], c, atol=1e-8, rtol=1e-8) + assert r["reached_end"], c.name + assert abs(r["y"][0] - math.exp(-10.0)) < 1e-6, c.name + + +def test_the_constant_free_baseline_is_the_one_to_beat(): + """The elementary controller is what the error model alone dictates and + what every practical code refuses to use. If it were not much worse, + there would be nothing for a safety factor - chosen or measured - to buy.""" + f = lambda t, y: [y[1], 5.0 * (1 - y[0] * y[0]) * y[1] - y[0]] + elem = integrate(f, 0.0, 25.0, [2.0, 0.0], Elementary(), atol=1e-8, + rtol=1e-8) + meas = integrate(f, 0.0, 25.0, [2.0, 0.0], MeasuredSafety(), atol=1e-8, + rtol=1e-8) + # margins measured with SciPy's integrator. An earlier version demanded + # a factor of two on evaluations and five on rejections; those came from + # a hand-written tableau and are not what the library produces. + assert elem["nfev"] > 1.2 * meas["nfev"], (elem["nfev"], meas["nfev"]) + assert elem["rejected"] > 1.5 * meas["rejected"], (elem["rejected"], + meas["rejected"]) + + +def test_where_the_measured_safety_factor_actually_stands(): + """The honest position, over the whole grid, with SciPy's integrator. + + It is NOT ahead of the PI controller - an earlier version of this test + asserted that, on numbers produced by a hand-written tableau. What it is: + level with a five-constant controller to within a few percent while + having none, and clearly ahead of the constant-free elementary rule that + every practical code refuses to use. It is behind the three-constant + classical controller and the test says so.""" + tot = {c.name: 0 for c in ALL} + fails = {c.name: 0 for c in ALL} + refs = {name: (exact if exact is not None else reference(f, t0, t1, y0)) + for name, f, t0, t1, y0, exact in PROBLEMS} + for tol in TOLS: + for name, f, t0, t1, y0, _exact in PROBLEMS: + for c in ALL: + r = integrate(f, t0, t1, y0, c, atol=tol, rtol=tol) + err = scaled_err(r["y"], refs[name], tol, tol) + bad = (not r["reached_end"]) or (math.isfinite(err) + and err > 1000.0) + tot[c.name] += r["nfev"] + fails[c.name] += bad + # nobody wins by failing more + assert len(set(fails.values())) == 1, fails + m = tot[MeasuredSafety().name] + pi = tot[GustafssonPI().name] + # level with the five-constant PI controller, within five percent + assert abs(m - pi) / pi < 0.05, (m, pi) + # clearly ahead of the constant-free rule the error model alone dictates + assert m < 0.9 * tot[Elementary().name], (m, tot[Elementary().name]) + # and honestly behind the three-constant classical one + assert m > tot[Classical().name], (m, tot[Classical().name]) + + +def test_the_controller_holds_no_unused_state(): + """It was called a credit controller while banking a margin that took no + part in any decision - the ledger was vestigial and the name unearned. + Nothing may accumulate here that the step factor does not read.""" + c = MeasuredSafety() + c.reset() + fields = set(vars(c)) + assert fields == {"predicted", "delta"}, fields diff --git a/tests/test_phase_detector.py b/tests/test_phase_detector.py new file mode 100644 index 0000000..9004027 --- /dev/null +++ b/tests/test_phase_detector.py @@ -0,0 +1,144 @@ +"""Pins the phase detector as REFUTED. + +The rho correction was derived, implemented and measured; it failed on all +three criteria set before it was run. These tests exist so nobody adopts it +later on the strength of the derivation alone, and so that if someone repairs +it the tests fail loudly and the claim gets re-examined. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest +from scipy.optimize._tstutils import _CHANDRUPATLA_TESTS_DICTS + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.pure import pure_root +from stage5_three_point import PROBLEMS, order_of + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 + + +def total(scale, sim="ratio"): + t = 0 + for _n, f, a, b, root in PROBLEMS: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, similarity=sim, + scale=scale, guard="project") + t += n if (conv and abs(x - root) <= 1e-8) else MAXFEV + return t + + +def med_order(scale, sim="ratio"): + ps = [order_of(lambda f_, a_, b_, xt, mx: pure_root( + f_, a_, b_, XTOL, MAXFEV, similarity=sim, scale=scale, guard="project"), + f, a, b, root) for _n, f, a, b, root in PROBLEMS] + ps = [p for p in ps if math.isfinite(p) and 0.5 < p < 5.0] + return sorted(ps)[len(ps) // 2] if ps else float("nan") + + +def test_rho_makes_the_standard_problems_worse(): + plain, rho = total("derived3"), total("derived3_rho") + assert rho > plain * 1.4, (plain, rho) + + +def test_rho_destroys_the_order_it_was_meant_to_preserve(): + """The correction was supposed to vanish near the root. It does not.""" + assert med_order("derived3") > 1.7 + assert med_order("derived3_rho") < 1.3 + + +def test_rho_does_not_capture_the_family_it_was_built_for(): + """fun3/fun4/fun5 are where cbrt beats us 2.6x. The detector was built to + recover that and recovers essentially none of it.""" + fam = [d for d in _CHANDRUPATLA_TESTS_DICTS + if d["ID"].startswith(("fun3.", "fun4.", "fun5."))] + + def t(sim, scale): + s = 0 + for d in fam: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + x, n, conv = pure_root(d["f"], a, b, XTOL, MAXFEV, + similarity=sim, scale=scale, guard="project") + s += n if (conv and abs(x - float(d["root"])) <= ACC) else MAXFEV + return s + + plain, rho, cb = t("ratio", "derived3"), t("ratio", "derived3_rho"), t("cbrt", "derived3") + assert cb < 0.6 * plain, (cb, plain) # the regime is real + assert rho > 0.9 * plain, (rho, plain) # the detector does not reach it + + +def test_the_refuted_scales_are_still_reachable_and_still_converge(): + """Refuted is not broken: the experiment must stay reproducible.""" + for scale in ("derived_rho", "derived3_rho"): + x, n, conv = pure_root(lambda t: t * t - 2.0, 0.0, 2.0, XTOL, MAXFEV, + scale=scale, guard="project") + assert conv and abs(x - math.sqrt(2.0)) <= 1e-8 + + +def test_the_proposed_configuration_uses_neither_refuted_variant(): + """Guards against a refuted variant quietly becoming the default.""" + from report_sweep import PROPOSED + assert "_rho" not in PROPOSED + assert "_m" not in PROPOSED + + +# -------------------------------------------------------------------------- +# the m correction: derivation sound, estimator not +# -------------------------------------------------------------------------- +def test_m_preserves_the_order_and_the_small_set_which_is_why_it_deceives(): + """Unlike rho, the m correction passes both of the tests a hand-picked + set can show. Pinned precisely because that is what makes it dangerous.""" + assert med_order("derived3_m") > 1.7 + assert total("derived3_m") <= total("derived3") + + +def test_m_loses_on_the_full_benchmark(): + """And fails the only test that matters. If this ever flips, the + estimator has been improved and the refutation must be revisited.""" + import json + if not os.path.exists(os.path.join( + os.path.dirname(os.path.dirname(os.path.abspath(__file__))), + "sweep_full.json")): + pytest.skip("sweep not present") + from scipy.optimize._tstutils import _APS_TESTS_DICTS + plain = m = 0 + for d in _APS_TESTS_DICTS: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + args = d.get("args", ()) + f = (lambda ff, aa: lambda t: ff(t, *aa))(d["f"], args) + root = float(d["root"]) + for scale, acc in (("derived3", "p"), ("derived3_m", "m")): + try: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, + similarity="ratio", scale=scale, + guard="project") + except Exception: + x, n, conv = float("nan"), MAXFEV, False + good = conv and math.isfinite(x) and abs(x - root) <= ACC + if acc == "p": + plain += n if good else MAXFEV + else: + m += n if good else MAXFEV + assert m > plain, (m, plain) + + +def test_the_local_order_estimator_declines_when_the_model_does_not_apply(): + """theta outside (0,1) means the power-law picture does not describe the + data; the estimator must return 1 rather than clamp a value into range.""" + from simroot.pure import _local_order + # a straight line: f'' = 0, theta = 0, m must be exactly 1 + lin = lambda t: 3.0 * t - 6.0 + assert _local_order(3.0, lin(3.0), 2.0, lin(2.0), 1.0, lin(1.0)) == 1.0 + # missing third point + assert _local_order(1.0, 1.0, 0.5, 0.5, None, None) == 1.0 + # repeated nodes + assert _local_order(1.0, 1.0, 1.0, 1.0, 1.0, 1.0) == 1.0 + # a double root at 0: f = t^2 has theta = 1/2, so m = 2 + sq = lambda t: t * t + m = _local_order(1e-3, sq(1e-3), 2e-3, sq(2e-3), 3e-3, sq(3e-3)) + assert abs(m - 2.0) < 1e-6, m diff --git a/tests/test_projection.py b/tests/test_projection.py new file mode 100644 index 0000000..61e2ef2 --- /dev/null +++ b/tests/test_projection.py @@ -0,0 +1,142 @@ +"""Tests for the projection safeguard. + +This is the guard the paper will propose, so its guarantee has to be checked +where it matters - on every problem of both benchmark sets, not on a sample - +and the order it was built to preserve has to be shown to survive. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.pure import PURE_SIMS, pure_root +from stage5_three_point import PROBLEMS, order_of + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 + +PROJECTING = ("project", "safe") + + +def _all_problems(): + out = [] + for d in _APS_TESTS_DICTS: + a, b = d["bracket"] + args = d.get("args", ()) + out.append((d["ID"], (lambda ff, aa: lambda x: ff(x, *aa))(d["f"], args), + float(a), float(b), float(d["root"]))) + for d in _CHANDRUPATLA_TESTS_DICTS: + a, b = d["bracket"] + out.append((d["ID"], (lambda ff: lambda x: ff(x))(d["f"]), + float(a), float(b), float(d["root"]))) + return out + + +ALL = _all_problems() + + +def bound(a, b): + """The guarantee the paper may state. + + The budget gives w_{j+1} <= 2^(n_max - j) * eps with n_max = 2*half, so in + exact arithmetic the width reaches xtol = 2*eps at step j = n_max - 1 and + the run costs n_max steps plus the two endpoint evaluations. + + In floating point the bracket can land exactly ON the budget boundary - + the instrumented invariant in stage6b shows the worst ratio at 1.000000 - + and the loop condition `w > xtol` then demands one further step. The + honest statement is therefore n_max + 1 steps, i.e. + + 2 * ceil(log2(w / xtol)) + 3 evaluations, + + which is still at most twice bisection plus one step. The `+1` is stated + rather than hidden: it is a property of the termination test at the + boundary, not slack that could absorb a real violation.""" + return 2 * math.ceil(math.log2(abs(b - a) / XTOL)) + 3 + + +@pytest.mark.parametrize("guard", PROJECTING) +@pytest.mark.parametrize("scale", ["derived", "derived3"]) +def test_projection_respects_the_bound_on_all_199_problems(guard, scale): + """The claim the paper makes about the projection guard. A single + violation invalidates it, so every problem is checked.""" + bad = [] + for pid, f, a, b, root in ALL: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", + scale=scale, guard=guard) + if conv and abs(x - root) <= ACC and n > bound(a, b): + bad.append((pid, n, bound(a, b))) + assert not bad, f"{guard}/{scale} exceeded the bound on {bad[:5]}" + + +@pytest.mark.parametrize("guard", PROJECTING) +def test_projection_solves_as_much_as_the_unguarded_rule(guard): + """A safeguard that bought its guarantee by failing more often would be + no bargain.""" + solved_guard = solved_none = 0 + for _pid, f, a, b, root in ALL: + for g, acc in ((guard, "g"), ("none", "n")): + x, _n, conv = pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", + scale="derived3", guard=g) + ok = conv and abs(x - root) <= ACC + if acc == "g": + solved_guard += ok + else: + solved_none += ok + assert solved_guard >= solved_none, (solved_guard, solved_none) + + +def test_projection_keeps_the_order_the_other_guards_destroy(): + """The whole point: `bracket` and `both` collapse the three-point rule + from order ~1.94 to ~1.00; `project` and `safe` must not.""" + med = {} + for guard in ("none", "bracket", "both", "project", "safe", "step"): + ps = [order_of((lambda g: lambda f_, a_, b_, xt, mx: pure_root( + f_, a_, b_, XTOL, MAXFEV, scale="derived3", guard=g))(guard), + f, a, b, root) for _n, f, a, b, root in PROBLEMS] + ps = [p for p in ps if math.isfinite(p) and 0.5 < p < 5.0] + med[guard] = sorted(ps)[len(ps) // 2] if ps else float("nan") + assert med["bracket"] < 1.2, med # the known collapse + assert med["both"] < 1.2, med + assert med["project"] > 1.7, med # the fix + assert med["safe"] > 1.7, med + assert med["safe"] >= med["bracket"] + 0.5, med + + +def test_zero_slack_would_be_degenerate(): + """Guards against someone 'tightening' the budget back to the exact + bisection bound: with no slack the projection radius on a unit bracket is + a twentieth of it from the very first step, and the method becomes + bisection. The doubling is load-bearing.""" + from simroot.pure import _Safeguard + sg = _Safeguard("project", 1.0, XTOL) + r_doubled = 2.0 ** (sg.n_half - 0) * sg.eps - 0.5 + half = sg.n_half // 2 + r_zero_slack = 2.0 ** half * sg.eps - 0.5 + assert r_zero_slack < 0.06, r_zero_slack + assert r_doubled > 1e6, r_doubled + + +@pytest.mark.parametrize("sim", sorted(PURE_SIMS)) +def test_every_similarity_works_under_the_projection(sim): + f = lambda t: t * t - 2.0 + x, _n, conv = pure_root(f, 0.0, 2.0, XTOL, MAXFEV, similarity=sim, + scale="derived3", guard="safe") + assert conv and abs(x - math.sqrt(2.0)) <= 1e-8 + + +def test_projection_needs_a_tolerance_and_a_real_bracket(): + with pytest.raises(ValueError): + from simroot.pure import _Safeguard + _Safeguard("project", 1.0, 0.0) + with pytest.raises(ValueError): + from simroot.pure import _Safeguard + _Safeguard("safe", 0.0, XTOL) diff --git a/tests/test_pure.py b/tests/test_pure.py new file mode 100644 index 0000000..28c9f14 --- /dev/null +++ b/tests/test_pure.py @@ -0,0 +1,177 @@ +"""Regression suite for simroot.pure and for the benchmark harness. + +Each audited defect is pinned as a test, then the contracts the method is +allowed to claim in the paper - and only those. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest +from scipy.optimize._tstutils import (_APS_TESTS_DICTS, + _CHANDRUPATLA_TESTS_DICTS) + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.baselines import bisection, itp +from simroot.pure import GUARDS, PURE_SIMS, pure_root + +XTOL = 1e-12 +MAXFEV = 200 +ACC = 1e-6 + +SMALL = [ + ("x^2-2", lambda x: x * x - 2.0, 0.0, 2.0, math.sqrt(2.0)), + ("cos-x", lambda x: math.cos(x) - x, 0.0, 1.0, 0.7390851332151607), + ("cubic", lambda x: x ** 3 - x - 2.0, 1.0, 2.0, 1.5213797068045676), + ("x^10-1", lambda x: x ** 10 - 1.0, 0.0, 1.3, 1.0), + ("flat", lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0, 1.0), + ("atan", lambda x: math.atan(x), -1.0, 3.0, 0.0), +] + +# the guards that are ALLOWED to claim a worst-case bound +SOUND_GUARDS = ("bracket", "both") + + +def _problems(dicts, chandrupatla=False): + out = [] + for d in dicts: + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + args = () if chandrupatla else d.get("args", ()) + f = (lambda ff, aa: lambda x: ff(x, *aa))(d["f"], args) + out.append((d["ID"], f, a, b, float(d["root"]))) + return out + + +APS = _problems(_APS_TESTS_DICTS) +CHA = _problems(_CHANDRUPATLA_TESTS_DICTS, chandrupatla=True) + + +def two_x_bisection_bound(a, b): + return 2 * math.ceil(math.log2(abs(b - a) / XTOL)) + 4 + + +# -------------------------------------------------------------------------- +# audited defects, pinned +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("guard", SOUND_GUARDS) +def test_bug_pending_flag_gave_three_x_not_two_x(guard): + """The bracket guard cleared `pending` on the halving branch and then + returned early, so TWO similarity steps were granted after every halving + instead of one - a 3x bisection guarantee dressed up as 2x. Chandrupatla + fun4.3 caught it: 139 evaluations against a bound of 114.""" + d = next(x for x in _CHANDRUPATLA_TESTS_DICTS if x["ID"] == "fun4.3") + a, b = float(d["bracket"][0]), float(d["bracket"][1]) + x, n, conv = pure_root(d["f"], a, b, XTOL, MAXFEV, + similarity="ratio", scale="derived", guard=guard) + assert conv and abs(x - float(d["root"])) <= ACC + assert n <= two_x_bisection_bound(a, b), f"{n} evaluations, 3x regression" + + +def test_step_guard_makes_no_worst_case_claim(): + """The step guard is cheap but unsound: a sequence creeping towards a + non-root with halving steps never trips it. The suite must NOT assert a + bound for it - this test exists so that nobody adds one later without + noticing that the benchmark reports real violations.""" + violations = 0 + for _pid, f, a, b, root in CHA: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", + scale="derived", guard="step") + if conv and abs(x - root) <= ACC and n > two_x_bisection_bound(a, b): + violations += 1 + assert violations > 0, ("the step guard no longer violates the 2x bound; " + "if that is a real improvement, promote it to " + "SOUND_GUARDS and prove it") + + +# -------------------------------------------------------------------------- +# contracts +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("guard", SOUND_GUARDS) +def test_sound_guards_respect_the_bound_on_every_benchmark_problem(guard): + """The only worst-case claim the paper may make.""" + bad = [] + for pid, f, a, b, root in APS + CHA: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", + scale="derived", guard=guard) + if conv and abs(x - root) <= ACC and n > two_x_bisection_bound(a, b): + bad.append((pid, n, two_x_bisection_bound(a, b))) + assert not bad, f"{guard} exceeded the 2x bound on {bad[:5]}" + + +@pytest.mark.parametrize("sim", sorted(PURE_SIMS)) +@pytest.mark.parametrize("prob", SMALL, ids=[p[0] for p in SMALL]) +def test_derived_scale_with_a_sound_guard_always_converges(sim, prob): + _, f, a, b, root = prob + x, n, conv = pure_root(f, a, b, XTOL, 400, similarity=sim, + scale="derived", guard="both") + assert conv, f"pure.{sim}.both did not converge" + assert abs(x - root) <= 1e-8 + + +@pytest.mark.parametrize("guard", GUARDS) +def test_never_leaves_the_bracket(guard): + for _pid, f, a, b, _root in SMALL: + x, _n, _c = pure_root(f, a, b, XTOL, MAXFEV, guard=guard) + assert min(a, b) - 1e-9 <= x <= max(a, b) + 1e-9 + + +def test_rejects_unknown_settings_loudly(): + f = lambda t: t * t - 2.0 + with pytest.raises(ValueError): + pure_root(f, 0.0, 2.0, XTOL, MAXFEV, similarity="no-such") + with pytest.raises(ValueError): + pure_root(f, 0.0, 2.0, XTOL, MAXFEV, scale="no-such") + with pytest.raises(ValueError): + pure_root(f, 0.0, 2.0, XTOL, MAXFEV, guard="no-such") + with pytest.raises(ValueError): + pure_root(f, 3.0, 4.0, XTOL, MAXFEV) # no sign change + + +def test_budget_is_never_exceeded(): + for budget in (0, 1, 2, 5, 30): + for guard in GUARDS: + _x, n, _c = pure_root(lambda t: math.exp(-t) * (t - 1.0), + -1.0, 40.0, XTOL, budget, guard=guard) + assert n <= budget + + +# -------------------------------------------------------------------------- +# the competitor must be sound too, or the benchmark is worthless +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("n0", [0, 1, 2, 5]) +def test_itp_respects_its_own_published_guarantee(n0): + """ITP's theorem: it never needs more iterations than bisection plus n0. + Checking the theorem is the strongest validation available for the + implementation without a reference to diff against. + + The permitted count is n_half + n0 + 1, not n_half + n0: the induction + gives bracket_j <= 2^(n_max-j+1)*eps, so the width first drops to 2*eps at + j = n_max, and the iterations actually run j = 0 .. n_max, which is + n_max + 1 of them. Stating it as n_max flagged 3 of 154 problems by + exactly one iteration - the signature of an indexing mistake in the test + rather than of a broken implementation.""" + bad = [] + for pid, f, a, b, root in APS: + if not a < b: + continue + allowed = math.ceil(math.log2((b - a) / XTOL)) + n0 + 1 + x, n, conv = itp(f, a, b, XTOL, 400, kappa1=0.2 / (b - a), n0=n0) + if conv and abs(x - root) <= ACC and (n - 2) > allowed: + bad.append((pid, n - 2, allowed)) + assert not bad, f"ITP broke its own bound on {bad[:5]}" + + +def test_bisection_is_the_reference_ceiling_everyone_beats(): + """Sanity check on the harness: if the new method were not actually + solving anything, this is the comparison that would expose it.""" + tot_pure = tot_bis = 0 + for _pid, f, a, b, root in APS: + _x, n1, c1 = pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", + scale="derived", guard="both") + _y, n2, c2 = bisection(f, a, b, XTOL, MAXFEV) + tot_pure += n1 if c1 else MAXFEV + tot_bis += n2 if c2 else MAXFEV + assert tot_pure < tot_bis, (tot_pure, tot_bis) diff --git a/tests/test_regimes.py b/tests/test_regimes.py new file mode 100644 index 0000000..cd07c66 --- /dev/null +++ b/tests/test_regimes.py @@ -0,0 +1,107 @@ +"""Pins the regime findings of stage 7. + +Three conclusions were drawn from that analysis and used to decide what to do +next. Each is asserted here so that a re-run of the sweep which moves them +fails the build instead of quietly invalidating the conclusion. +""" +from __future__ import annotations + +import json +import os +import sys + +import pytest + +ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +sys.path.insert(0, ROOT) + +SWEEP = os.path.join(ROOT, "sweep_full.json") +pytestmark = pytest.mark.skipif(not os.path.exists(SWEEP), + reason="sweep_full.json not present") + +SCALES = ("start", "bracket", "derived", "derived3") +MAXFEV = 200 + + +def load(): + with open(SWEEP, encoding="utf8") as fh: + return {r["label"]: r for r in json.load(fh)} + + +def cost(rows, sim, scale, pid): + r = rows[f"pure.{sim}.{scale}.project"] + d = r["APS"]["per"].get(pid) or r["CHA"]["per"].get(pid) + return d[0] if d[1] else MAXFEV + + +def all_pids(rows): + r = rows["pure.ratio.derived3.project"] + return list(r["APS"]["per"]) + list(r["CHA"]["per"]) + + +def test_the_scale_axis_has_little_headroom(): + """5.3%. If this ever grows a lot, the scale is worth revisiting; as it + stands it is not where the regimes live.""" + rows = load() + pids = all_pids(rows) + ours = sum(cost(rows, "ratio", "derived3", p) for p in pids) + oracle = sum(min(cost(rows, "ratio", s, p) for s in SCALES) for p in pids) + head = (ours - oracle) / ours + assert 0.0 <= head < 0.10, head + + +def test_cbrt_beats_us_consistently_on_the_fun4_family(): + """The signature of a real regime rather than luck: the same function at + five different parameters all prefer the same similarity, by a wide + margin. This is the finding that keeps the line open.""" + rows = load() + fam = [f"fun4.{i}" for i in range(1, 6)] + better = 0 + for pid in fam: + ours = cost(rows, "ratio", "derived3", pid) + cb = cost(rows, "cbrt", "derived3", pid) + if cb < ours: + better += 1 + assert better == 5, f"only {better}/5 of the fun4 family prefer cbrt" + tot_ours = sum(cost(rows, "ratio", "derived3", p) for p in fam) + tot_cb = sum(cost(rows, "cbrt", "derived3", p) for p in fam) + assert tot_cb < 0.6 * tot_ours, (tot_cb, tot_ours) + + +def test_switching_by_benchmark_set_is_worse_than_not_switching(): + """The finding that closed the obvious exploit: cbrt wins the fun3/4/5 + families but loses the rest of Chandrupatla, so a set-level switch costs + more than a single fixed choice. Any future 'regime' proposal has to beat + this, not merely beat one family.""" + rows = load() + single = (rows["pure.ratio.derived3.project"]["APS"]["total"] + + rows["pure.ratio.derived3.project"]["CHA"]["total"]) + switched = (rows["pure.ratio.derived3.project"]["APS"]["total"] + + rows["pure.cbrt.derived3.project"]["CHA"]["total"]) + assert switched > single, (switched, single) + + +def test_the_proposed_similarity_wins_most_problems_outright(): + """155 of 199. The per-problem oracle over similarities is an upper + bound on regime detection, not a method, and most of the field is already + ours without it.""" + rows = load() + pids = all_pids(rows) + sims = ("ratio", "sqrt", "cbrt", "rational", "ratio_soft", "exp_abs", + "rat_sq", "exp_sq", "cosine") + wins = 0 + for p in pids: + c = {s: cost(rows, s, "derived3", p) for s in sims} + if c["ratio"] == min(c.values()): + wins += 1 + assert wins >= 150, wins + + +def test_stage7_runs(): + """The analysis script itself must still execute against the current + sweep file.""" + import subprocess + r = subprocess.run([sys.executable, "stage7_regimes.py"], cwd=ROOT, + capture_output=True, text=True, timeout=600) + assert r.returncode == 0, r.stderr[-800:] + assert "SETTLING THE TWO SUSPICIONS" in r.stdout diff --git a/tests/test_registered_prediction.py b/tests/test_registered_prediction.py new file mode 100644 index 0000000..9372d21 --- /dev/null +++ b/tests/test_registered_prediction.py @@ -0,0 +1,77 @@ +"""A prediction registered before the run, and falsified by it. + +The hypothesis was that a method which wins in some places and loses in others +must have a regime where it wins outright, and that the regime is where the +quantity the constant approximates CHANGES during the run - because one +constant cannot be right at two different noise levels while a measured value +tracks. + +It was stated before measuring, with the falsification condition attached: the +measured rule had to lose every constant-noise cell and win every +varying-noise cell. It lost all twelve. + +The first version of the test could not have confirmed it either way - noise +reduction was scored on the second half of the run, by which time every ramp +and step had already arrived, so the metric never saw a transition. That flaw +was found and fixed before the conclusion was drawn, and the conclusion did +not change. + +This file exists so the line is not reopened without new evidence. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from anc.rules import Fixed, Measured +from stage20_prediction import (FLAT_5, FLAT_30, STEP_25, SWING_25, sig_cabin, + sig_tonal, score) + +SEEDS = 3 + + +def test_the_metric_window_sees_the_transition(): + """The flaw that would have produced a false falsification. A varying + profile must not score the same as a constant one at its final level.""" + varying = score(Fixed(0.1), sig_tonal, SWING_25, seeds=SEEDS) + final_level = score(Fixed(0.1), sig_tonal, FLAT_5, seeds=SEEDS) + assert varying > final_level + 2.0, (varying, final_level) + + +@pytest.mark.parametrize("signal", [sig_tonal, sig_cabin], + ids=["tonal", "cabin"]) +@pytest.mark.parametrize("profile,kind", [(FLAT_30, "control"), + (FLAT_5, "control"), + (SWING_25, "prediction"), + (STEP_25, "prediction")], + ids=["flat30", "flat5", "ramp", "step"]) +def test_an_oracle_constant_beats_the_measured_rule_everywhere(signal, profile, + kind): + """The registered prediction required the measured rule to WIN the two + 'prediction' cells. It does not, on either signal. A single constant, + chosen with knowledge of the scenario, is ahead even when the noise level + swings by 25 dB inside the run.""" + ms = score(Measured(), signal, profile, seeds=SEEDS) + best = max(score(Fixed(mu), signal, profile, seeds=SEEDS) + for mu in (0.05, 0.1, 0.2, 0.5, 1.0)) + assert best > ms, (kind, best, ms) + + +def test_the_conclusion_this_licenses(): + """Winning somewhere and losing elsewhere does not imply a regime of + outright victory exists; it is equally consistent with a middling + generalist. On this evidence there is no such regime, and the claim the + work may make is the scoped one in test_modern_repairs.py.""" + losses = 0 + for signal in (sig_tonal, sig_cabin): + for profile in (FLAT_30, FLAT_5, SWING_25, STEP_25): + ms = score(Measured(), signal, profile, seeds=SEEDS) + best = max(score(Fixed(mu), signal, profile, seeds=SEEDS) + for mu in (0.05, 0.2, 1.0)) + losses += ms < best + assert losses == 8, losses diff --git a/tests/test_relaxation.py b/tests/test_relaxation.py new file mode 100644 index 0000000..7ad9f86 --- /dev/null +++ b/tests/test_relaxation.py @@ -0,0 +1,95 @@ +"""The relaxation parameter: the fourth domain, and the fourth time the same +pattern appears. + +omega in SOR is the oldest hand-tuned step length in numerical computing. The +similarity form - omega = 1 + cos between successive corrections - lands +exactly in the admissible interval [1, 2] with nothing chosen, and it beats +Gauss-Seidel five-fold. It loses to a swept omega two-fold. + +A second map, derived from the theory rather than from the geometry, was tried +and is worse than the first. Both are pinned: the working one so it is not +lost, the refuted one so it is not retried. +""" +from __future__ import annotations + +import math +import os +import sys + +import numpy as np +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from relax.sor import (ContractionOmega, Fixed, SimilarityOmega, poisson_rhs, + residual, solve, sweep_gs) +from stage23_relaxation import anisotropic, convection, theory_check + +N = 14 +F = poisson_rhs(N) +W_OPT = 2.0 / (1.0 + math.sin(math.pi / (N + 1))) + + +def test_the_sweep_reproduces_the_sor_theory(): + """The instrument before the experiment: for the model problem the SOR + spectral radius is exactly omega* - 1.""" + _w, theory, measured = theory_check(16) + assert abs(theory - measured) < 0.02, (theory, measured) + + +def test_the_similarity_omega_lands_in_the_admissible_interval(): + """Range of the similarity and convergence condition of the method + coincide, which is why nothing had to be clipped by hand.""" + r = SimilarityOmega() + r.reset() + d1 = np.array([1.0, 2.0, 3.0]) + assert r.next_omega(None, None) == 1.0 + assert r.next_omega(d1, d1) == pytest.approx(2.0) # identical + assert r.next_omega(d1, -d1) == pytest.approx(1.0) # opposed + assert r.next_omega(np.array([1.0, 0.0, 0.0]), + np.array([0.0, 1.0, 0.0])) == pytest.approx(1.0) + + +@pytest.mark.parametrize("label,coeff", [ + ("poisson", None), ("aniso", anisotropic(N, 0.1))]) +def test_similarity_beats_gauss_seidel_by_a_wide_margin(label, coeff): + gs, _ = solve(F, Fixed(1.0), coeff=coeff) + sim, _ = solve(F, SimilarityOmega(), coeff=coeff) + assert sim * 3 < gs, (label, sim, gs) + + +@pytest.mark.parametrize("label,coeff", [ + ("poisson", None), ("aniso", anisotropic(N, 0.1))]) +def test_and_loses_to_a_swept_omega(label, coeff): + """The other half, stated so the claim is never inflated.""" + sim, _ = solve(F, SimilarityOmega(), coeff=coeff) + best = min(solve(F, Fixed(w), coeff=coeff)[0] + for w in (1.2, 1.4, 1.6, 1.8, W_OPT)) + assert best < sim, (label, best, sim) + + +def test_the_similarity_rule_over_relaxes(): + """The diagnosis, not just the outcome: the cosine between successive SOR + corrections sits near 1, so 1 + cos saturates near 2 and the rule picks a + larger omega than the optimum.""" + _sim, mean_w = solve(F, SimilarityOmega()) + assert mean_w > W_OPT, (mean_w, W_OPT) + + +def test_the_contraction_map_is_refuted_and_worse(): + """The second attempt, pinned so it is not tried again. Undamped + feedback pins omega at the limit from the first sweep.""" + sim, _ = solve(F, SimilarityOmega()) + con, mean_w = solve(F, ContractionOmega()) + assert con > sim, (con, sim) + assert mean_w > 1.9, mean_w + + +def test_convection_is_where_it_actually_hurts(): + """On a strongly non-symmetric problem Gauss-Seidel is already fast and + the rule makes it slower - the one case where the similarity form is not + merely second but harmful.""" + coeff = convection(N, 10.0) + gs, _ = solve(F, Fixed(1.0), coeff=coeff) + sim, _ = solve(F, SimilarityOmega(), coeff=coeff) + assert sim > gs, (sim, gs) diff --git a/tests/test_reusability.py b/tests/test_reusability.py new file mode 100644 index 0000000..2d0f656 --- /dev/null +++ b/tests/test_reusability.py @@ -0,0 +1,82 @@ +"""The credit safeguard applied to step rules it was not designed for. + +This is the finding that decides what the work is about. As a +one-dimensional root finder the similarity method is subsumed by +Chandrupatla 1997 on every axis measured. The safeguard is not: it is +independent of the similarity framing and it converts unsafe interpolating +rules into safe ones without a constant and without a cost. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.baselines import chandrupatla +from stage14_is_anything_reusable import RULES, load, measure + +PROBS = load() + + +@pytest.mark.parametrize("name,rule", RULES, ids=[n for n, _ in RULES]) +def test_the_guard_makes_an_unsafe_rule_solve_everything(name, rule): + """Every rule, guarded, must reach the 193 of 199 that is the most any + method here achieves - including bisection and Chandrupatla.""" + _t_raw, s_raw, _w_raw = measure(rule, False, PROBS) + _t_g, s_g, _w_g = measure(rule, True, PROBS) + assert s_g == 193, (name, s_g) + assert s_g > s_raw, (name, s_raw, s_g) + + +@pytest.mark.parametrize("name,rule", RULES, ids=[n for n, _ in RULES]) +def test_the_guard_is_free_or_better(name, rule): + """Safety normally costs evaluations. Here it saves them, because the + failures it prevents were being charged the full budget.""" + t_raw, _s, _w = measure(rule, False, PROBS) + t_g, _s2, _w2 = measure(rule, True, PROBS) + assert t_g < t_raw, (name, t_raw, t_g) + + +@pytest.mark.parametrize("name,rule", RULES, ids=[n for n, _ in RULES]) +def test_the_guarded_worst_case_is_at_bisection_level(name, rule): + """The point of a safeguard. Bisection's worst problem here costs 82 + evaluations; every guarded rule must be in that neighbourhood, where the + raw rules run to 135, 178 and the 200-evaluation cap.""" + _t, _s, w_g = measure(rule, True, PROBS) + assert w_g <= 90, (name, w_g) + + +def test_the_similarity_method_is_subsumed_by_chandrupatla(): + """Stated as a test so the paper cannot drift back to claiming otherwise. + Chandrupatla is better on total, on the worst case, and on stability, + with the same number of constants (none) and the same 193 solved.""" + from simroot.pure import pure_root + XTOL, MAXFEV, ACC = 1e-12, 200, 1e-6 + ours_t = ours_w = ours_s = 0 + cha_t = cha_w = cha_s = 0 + for f, a, b, root in PROBS: + for meth, which in ((lambda: pure_root(f, a, b, XTOL, MAXFEV, + similarity="ratio", + scale="derived3", + guard="credit"), "o"), + (lambda: chandrupatla(f, a, b, XTOL, MAXFEV), "c")): + try: + x, n, conv = meth() + except Exception: + x, n, conv = float("nan"), MAXFEV, False + ok = bool(conv and math.isfinite(x) and abs(x - root) <= ACC) + if which == "o": + ours_t += n if ok else MAXFEV + ours_s += ok + ours_w = max(ours_w, n) if ok else ours_w + else: + cha_t += n if ok else MAXFEV + cha_s += ok + cha_w = max(cha_w, n) if ok else cha_w + assert cha_s == ours_s == 193 + assert cha_t < ours_t, (cha_t, ours_t) + assert cha_w <= ours_w, (cha_w, ours_w) diff --git a/tests/test_revision_points.py b/tests/test_revision_points.py new file mode 100644 index 0000000..e8ed3cb --- /dev/null +++ b/tests/test_revision_points.py @@ -0,0 +1,177 @@ +"""Pins the corrections the revision made. + +Each of these replaced a statement in the paper that was wrong or too broad. +They are asserted here so a later edit cannot quietly restore the old claim. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.pure import PURE_SIMS, pure_root +from stage5_three_point import PROBLEMS, order_of + +R2 = math.sqrt(2.0) +F = lambda x: x * x - 2.0 +XTOL, MAXFEV = 1e-12, 200 + + +def iterate(S, n, sigma=2.0, x0=0.0, xfar=2.0): + x, errs = x0, [] + for _ in range(n): + x = x + (1.0 - S(F(x) / sigma)) * (xfar - x) + errs.append(abs(x - R2)) + return errs + + +# -------------------------------------------------------------------------- +# the naming contradiction: the proposed similarity is the tent, and its +# degeneracy is a property of the CHOSEN scale only +# -------------------------------------------------------------------------- +def test_the_tent_is_captured_under_the_chosen_scale(): + """Table 1's last row. Not a slow rate - capture at the far end on the + first step.""" + e = iterate(PURE_SIMS["ratio"], 200) + assert abs(e[0] - e[-1]) < 1e-15, (e[0], e[-1]) + assert abs(e[0] - 0.5858) < 1e-3, e[0] + + +def test_the_tent_is_the_best_similarity_under_the_derived_scale(): + """The same function, the other scale. If these two tests ever agree in + sign, the paper's central thesis - that the content is in the scale - has + been broken.""" + tot = {} + for sim in PURE_SIMS: + s = 0 + for _n, f, a, b, root in PROBLEMS: + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, similarity=sim, + scale="derived3", guard="project") + s += n if (conv and abs(x - root) <= 1e-8) else MAXFEV + tot[sim] = s + assert min(tot, key=lambda k: tot[k]) == "ratio", tot + + +def test_the_tent_never_clips_under_the_derived_scale(): + """Why the degeneracy disappears: |f|/sigma stays below 1, so the + truncation in max(0, 1-|z|) never engages.""" + from simroot.pure import _slope3 + a, b = 0.0, 2.0 + fa, fb = F(a), F(b) + A, FA, B = a, fa, b + x, fx, xp, fp = a, fa, b, fb + xp2 = fp2 = None + clipped = steps = 0 + for _ in range(40): + if abs(B - A) <= XTOL: + break + far = B if abs(B - x) >= abs(A - x) else A + sc = abs(_slope3(x, fx, xp, fp, xp2, fp2)) * abs(far - x) + if sc == 0.0: + break + steps += 1 + clipped += abs(fx) / sc >= 1.0 + xn = x + min(1.0, abs(fx) / sc) * (far - x) + if not (min(A, B) < xn < max(A, B)): + xn = 0.5 * (A + B) + fn = F(xn) + xp2, fp2, xp, fp, x, fx = xp, fp, x, fx, xn, fn + if FA * fn < 0.0: + B = xn + else: + A, FA = xn, fn + assert steps > 0 + assert clipped == 0, f"{clipped} of {steps} steps clipped" + + +# -------------------------------------------------------------------------- +# Proposition 1 is specific; Proposition 1' locates the boundary +# -------------------------------------------------------------------------- +def test_only_the_ratio_form_reproduces_regula_falsi(): + a, b = 1.0, 4.0 + fa, fb = F(a), F(b) + falsi = (a * fb - b * fa) / (fb - fa) + matches = [] + for name, S in (("rational", PURE_SIMS["rational"]), + ("exp_abs", PURE_SIMS["exp_abs"]), + ("rat_sq", PURE_SIMS["rat_sq"]), + ("cosine", PURE_SIMS["cosine"]), + ("ratio", PURE_SIMS["ratio"])): + pt = a + (1.0 - S(F(a) / abs(fb))) * (b - a) + if abs(pt - falsi) < 1e-12: + matches.append(name) + assert matches == ["rational"], matches + + +def test_the_bracket_end_difference_gives_regula_falsi_exactly(): + """Proposition 1'. This is why 'most recent' in the definition of the + divided difference is load-bearing.""" + a, b = 1.0, 4.0 + fa, fb = F(a), F(b) + falsi = (a * fb - b * fa) / (fb - fa) + sigma = abs((fb - fa) / (b - a)) * abs(b - a) + pt = a + min(1.0, abs(fa) / sigma) * (b - a) + assert pt == falsi + + +# -------------------------------------------------------------------------- +# Table 1's c = 0 rows: a sublinear law with a predicted coefficient +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("sim,want", [("rat_sq", 0.8536), ("exp_sq", 0.8536), + ("cosine", 1.7071)]) +def test_the_quadratic_similarities_are_sublinear_with_a_predicted_constant(sim, want): + S = PURE_SIMS[sim] + h = 1e-4 + c2 = (1.0 - S(h)) / (h * h) + fp, D, sigma = 2.0 * R2, 2.0 - R2, 2.0 + predicted = sigma * sigma / (c2 * fp * fp * D) + assert abs(predicted - want) < 1e-3, predicted + e = iterate(S, 4001) + assert abs(4000 * e[4000] - predicted) < 0.02, (4000 * e[4000], predicted) + + +def test_there_is_no_rate_to_measure_for_those_rows(): + """The old table reported 0.93-0.94 as a 'measured rate'; the ratio + creeps to 1, so that number was the window's end, not a rate.""" + e = iterate(PURE_SIMS["rat_sq"], 4001) + ratios = [e[n] / e[n - 1] for n in (10, 100, 1000, 4000)] + assert ratios == sorted(ratios), ratios + assert ratios[0] < 0.94 < ratios[-1] + assert ratios[-1] > 0.999 + + +# -------------------------------------------------------------------------- +# the order is 2, not Muller's 1.84 +# -------------------------------------------------------------------------- +def test_the_three_point_order_is_two(): + ps = [order_of(lambda f_, a_, b_, xt, mx: pure_root( + f_, a_, b_, XTOL, MAXFEV, scale="derived3", guard="project"), + f, a, b, root) for _n, f, a, b, root in PROBLEMS] + ps = [p for p in ps if math.isfinite(p) and 0.5 < p < 5.0] + med = sorted(ps)[len(ps) // 2] + assert abs(med - 2.0) < 0.1, med + + +# -------------------------------------------------------------------------- +# the two evaluation-count conventions must both be reported and must differ +# in the direction the paper says +# -------------------------------------------------------------------------- +@pytest.mark.skipif(not os.path.exists(os.path.join( + os.path.dirname(os.path.dirname(os.path.abspath(__file__))), + "sweep_full.json")), reason="sweep not present") +def test_charged_totals_are_what_section_5_reports(): + import json + root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + with open(os.path.join(root, "sweep_full.json"), encoding="utf8") as fh: + rows = {r["label"]: r for r in json.load(fh)} + # brent is now run at the better of ours and scipy.brentq per problem, + # which is why it is 6988 rather than the 6991 of our implementation alone + for lbl, want in (("pure.ratio.derived3.project", 6026), + ("brent", 6988), ("bisection", 10620), + ("chandrupatla", 5208)): + got = rows[lbl]["APS"]["total"] + rows[lbl]["CHA"]["total"] + assert got == want, (lbl, got, want) diff --git a/tests/test_similarity_family_anc.py b/tests/test_similarity_family_anc.py new file mode 100644 index 0000000..f230f44 --- /dev/null +++ b/tests/test_similarity_family_anc.py @@ -0,0 +1,105 @@ +"""The similarity family for the NLMS step size, and what it settled. + +Two corrections came from outside and both were right: + + 1. mu should be a SIMILARITY, not a variance estimate. The filter can only + remove what correlates with its input, so the quantity is the cosine + between the error and the filtered reference. It beats the variance + formulation on eleven of twelve cells. + + 2. Testing one similarity function is as incomplete here as it would have + been in the root-finding work. The whole family must be run, and when it + is, the best member is not the cosine. + +And the law of the first domain - that the slope of (1 - S) at the origin +decides, not the shape of S - orders this family too, monotonically and +without exception. That is a prediction made in one domain and confirmed in +another. + +What it did not settle: even the best member loses to a constant tuned per +scenario, on all twelve cells. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from anc.rules import CosineSimilarity, Fixed, Measured +from simroot.pure import PURE_SIMS +from stage20_prediction import FLAT_15, FLAT_30, STEP_25, sig_cabin, sig_tonal, \ + score + +SEEDS = 3 +CELLS = [(sig_tonal, FLAT_30), (sig_tonal, STEP_25), + (sig_cabin, FLAT_15), (sig_cabin, STEP_25)] + + +def make(name): + r = CosineSimilarity() + r.S = None if name is None else PURE_SIMS[name] + return r + + +def mean(rule): + vals = [score(rule, gen, prof, seeds=SEEDS) for gen, prof in CELLS] + return sum(vals) / len(vals) + + +def test_the_similarity_formulation_beats_the_variance_one(): + """Correction 1. mu as 'how much of the error resembles what the filter + can remove' against mu as 'one minus the noise-power fraction'. + + Stated carefully, because the first version of this test was not: what + beats the variance rule on eleven of twelve cells is the best member of + the FAMILY, not the raw cosine. The raw cosine can lose to it - on this + subset it does, 14.04 against 14.32 - which is precisely why correction 2 + (run the whole family) was needed before the claim could be made at all. + """ + best_member = max(mean(make(n)) for n in (None, "ratio", "exp_abs", + "rational", "ratio_soft", + "sqrt", "cbrt")) + assert best_member > mean(Measured()), best_member + + +def test_the_raw_cosine_is_not_the_best_member(): + """Correction 2. A single member is not the family: the identity + S(d) = 1 - d is beaten by members with a steeper approach to 1.""" + raw = mean(make(None)) + best = max(mean(make(n)) for n in ("sqrt", "cbrt", "ratio_soft")) + assert best > raw, (best, raw) + + +def test_two_code_paths_for_the_same_function_agree(): + """S = None takes mu = |cos| directly; S = ratio computes + max(0, 1 - d) with d = 1 - |cos|. They are the same function on [0,1] + and reach it by different code, so they must score identically.""" + a = mean(make(None)) + b = mean(make("ratio")) + assert abs(a - b) < 1e-9, (a, b) + + +def test_the_law_of_the_first_domain_orders_this_family_too(): + """The prediction carried across domains: slope of (1 - S) at 0 decides. + Every slope-1 member must beat every slope-0 member.""" + slope1 = [mean(make(n)) for n in ("ratio", "exp_abs", "rational")] + slope0 = [mean(make(n)) for n in ("rat_sq", "exp_sq", "cosine")] + assert min(slope1) > max(slope0), (slope1, slope0) + + +def test_and_it_still_loses_to_a_tuned_constant(): + """The half that did not work, pinned so the claim is never overstated. + The competitor knows the scenario; no deployable controller does - and it + is still ahead.""" + losses = 0 + for gen, prof in CELLS: + best_member = max(score(make(n), gen, prof, seeds=SEEDS) + for n in (None, "cbrt", "sqrt", "ratio")) + oracle = max(score(Fixed(mu), gen, prof, seeds=SEEDS) + for mu in (0.05, 0.1, 0.2, 0.5, 1.0)) + losses += best_member < oracle + assert losses == len(CELLS), losses diff --git a/tests/test_simroot.py b/tests/test_simroot.py new file mode 100644 index 0000000..eb1bef5 --- /dev/null +++ b/tests/test_simroot.py @@ -0,0 +1,234 @@ +"""Regression suite for the similarity root finders and the baselines. + +Every bug found in a static audit becomes a test here (project rule), so the +four audited defects are pinned first, then the behavioural contracts. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.baselines import (BASELINES, bisection, brent, illinois, itp, + regula_falsi, ridders, toms748) +from simroot.sim import SIMILARITIES, sim_root +from stage0b_pure_similarity import SIMS_01, pure_similarity_step +from stage0d_derived_similarity import FAST_SIMS, derived_step, pure_step + +XTOL = 1e-12 +MAXFEV = 300 + +PROBLEMS = [ + ("x^2-2", lambda x: x * x - 2.0, 0.0, 2.0, math.sqrt(2.0)), + ("cos-x", lambda x: math.cos(x) - x, 0.0, 1.0, 0.7390851332151607), + ("exp-2", lambda x: math.exp(x) - 2.0, 0.0, 2.0, math.log(2.0)), + ("cubic", lambda x: x ** 3 - x - 2.0, 1.0, 2.0, 1.5213797068045676), + ("x^10-1", lambda x: x ** 10 - 1.0, 0.0, 1.3, 1.0), + ("flat", lambda x: math.exp(-x) * (x - 1.0), -1.0, 40.0, 1.0), + ("atan", lambda x: math.atan(x), -1.0, 3.0, 0.0), +] + +GUARDED_SIM = [(s, p) for s in SIMILARITIES for p in ("point", "pair", "pair2d")] + +# Interpolation-only methods: no bisection safeguard, hence no worst-case +# guarantee. They are in the suite as references, not as claims. +NO_GUARANTEE = {"regula_falsi", "pegasus"} + + +# -------------------------------------------------------------------------- +# audited defects, pinned +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("name", sorted(BASELINES)) +def test_bug1_exhausted_budget_is_an_honest_failure(name): + """A budget that runs out on the very first evaluation must return + converged=False, never raise UnboundLocalError.""" + method = BASELINES[name] + for budget in (0, 1, 2): + x, n, conv = method(lambda t: t * t - 2.0, 0.0, 2.0, XTOL, budget) + assert n <= budget + assert math.isfinite(x) + assert conv is False or n <= budget + + +def test_bug2_itp_stops_at_the_same_bracket_as_everyone_else(): + """ITP is natively written against a half-width epsilon. If xtol were fed + in as epsilon, ITP would stop at twice the bracket width of its + competitors and win the benchmark on the stopping rule. The final + accuracy must be comparable to the other methods, not 2x looser.""" + f = lambda t: t * t - 2.0 + root = math.sqrt(2.0) + xtol = 1e-8 + x_itp, _, c1 = itp(f, 0.0, 2.0, xtol, MAXFEV) + x_bis, _, c2 = bisection(f, 0.0, 2.0, xtol, MAXFEV) + assert c1 and c2 + assert abs(x_itp - root) <= xtol + assert abs(x_bis - root) <= xtol + + +def test_bug3_itp_rejects_a_reversed_bracket_loudly(): + with pytest.raises(ValueError): + itp(lambda t: t * t - 2.0, 2.0, 0.0, XTOL, MAXFEV) + + +def test_bug4_stagnation_is_not_reported_as_success(): + """sim_root used to return converged=True when it could no longer split + the bracket, regardless of whether the tolerance had been met. A + tolerance far below what float can represent on this bracket must not + come back as a success.""" + f = lambda t: math.exp(-t) * (t - 1.0) + x, n, conv = sim_root(f, -1.0, 40.0, 1e-300, 400, + similarity="inv", prototypes="pair2d", guard=True) + if not conv: + return # honest failure - fine + assert abs(x - 1.0) <= 1e-8, "claimed success while stagnated" + + +# -------------------------------------------------------------------------- +# behavioural contracts +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("name", sorted(BASELINES)) +@pytest.mark.parametrize("prob", PROBLEMS, ids=[p[0] for p in PROBLEMS]) +def test_baselines_find_the_root(name, prob): + _, f, a, b, root = prob + x, n, conv = BASELINES[name](f, a, b, XTOL, MAXFEV) + if name in NO_GUARANTEE: + # These carry no bisection safeguard and therefore no worst-case + # bound; the literature says so and the flat problem shows it. What + # is required of them is only that they stay honest about it. + assert n <= MAXFEV + assert math.isfinite(x) + if not conv: + return + assert conv, f"{name} did not converge" + assert abs(x - root) <= 1e-8, f"{name} converged to the wrong point" + assert n <= MAXFEV + + +@pytest.mark.parametrize("sim,proto", GUARDED_SIM, + ids=[f"{s}.{p}" for s, p in GUARDED_SIM]) +@pytest.mark.parametrize("prob", PROBLEMS, ids=[p[0] for p in PROBLEMS]) +def test_guarded_sim_never_fails(sim, proto, prob): + """The parameter-free safeguard is the whole reason it exists: with it on, + no similarity function and no prototype level may fail on any problem.""" + _, f, a, b, root = prob + x, n, conv = sim_root(f, a, b, XTOL, MAXFEV, + similarity=sim, prototypes=proto, guard=True) + assert conv, f"SIM.{proto}.{sim} did not converge" + assert abs(x - root) <= 1e-8 + assert n <= MAXFEV + + +@pytest.mark.parametrize("sim,proto", GUARDED_SIM, + ids=[f"{s}.{p}" for s, p in GUARDED_SIM]) +@pytest.mark.parametrize("prob", PROBLEMS, ids=[p[0] for p in PROBLEMS]) +def test_guard_bounds_the_worst_case_by_twice_bisection(sim, proto, prob): + """The safeguard pays back one bisection step for every similarity step + that failed to halve the bracket, so the worst case is bounded by twice + the BISECTION BOUND. + + The comparison must be against the bound ceil(log2(w/xtol)), not against + what bisection happened to spend on this problem: on atan over [-1, 3] + bisection lands exactly on the root in 4 evaluations, which is luck, not + a worst case, and comparing against it asserts something that was never + claimed.""" + _, f, a, b, _ = prob + n_bound = math.ceil(math.log2(abs(b - a) / XTOL)) + _, n_sim, conv = sim_root(f, a, b, XTOL, MAXFEV, + similarity=sim, prototypes=proto, guard=True) + assert conv + assert n_sim <= 2 * n_bound + 4, f"{n_sim} > 2*{n_bound}+4" + + +@pytest.mark.parametrize("prob", PROBLEMS, ids=[p[0] for p in PROBLEMS]) +def test_every_method_stays_inside_the_initial_bracket(prob): + """A bracketing method must never return a point outside the bracket it + was given, converged or not.""" + _, f, a, b, _ = prob + lo, hi = min(a, b), max(a, b) + for name, m in BASELINES.items(): + x, _, _ = m(f, a, b, XTOL, MAXFEV) + assert lo - 1e-9 <= x <= hi + 1e-9, f"{name} left the bracket" + for sim, proto in GUARDED_SIM: + x, _, _ = sim_root(f, a, b, XTOL, MAXFEV, similarity=sim, + prototypes=proto, guard=True) + assert lo - 1e-9 <= x <= hi + 1e-9, f"SIM.{proto}.{sim} left the bracket" + + +def test_the_pure_two_point_similarity_step_is_regula_falsi_exactly(): + """The stage-0 identity, as an executable claim rather than an assertion + in prose: normalising the similarity by the two bracket ends reproduces + the false-position formula bit for bit.""" + for fa, fb in ((-5.436, 1.6e-16), (-1.0, 3.0), (2.5, -0.125), (-1e-9, 7.0)): + a, b = -1.0, 40.0 + s_a = abs(fb) / (abs(fa) + abs(fb)) + s_b = abs(fa) / (abs(fa) + abs(fb)) + x_sim = s_a * a + s_b * b + x_falsi = (a * fb - b * fa) / (fb - fa) + assert abs(x_sim - x_falsi) <= 1e-12 * max(1.0, abs(x_falsi)) + + +def test_similarity_shape_predicts_the_contraction_rate(): + """The stage-0c law: rate = |1 - c*|f'(r)|*D/scale| with c the slope of + (1 - S) at zero. Pinned for the two linear-approach similarities, where + it was measured to four digits.""" + f = lambda t: t * t - 2.0 + root, fp, D, scale = math.sqrt(2.0), 2.0 * math.sqrt(2.0), 2.0 - math.sqrt(2.0), 2.0 + predicted = abs(1.0 - 1.0 * fp * D / scale) + for sim in ("rational", "exp_abs"): + S = SIMS_01[sim] + x, errs = 0.0, [] + for _ in range(14): + x = x + (1.0 - S(abs(f(x)) / scale)) * (2.0 - x) + errs.append(abs(x - root)) + win = [errs[i + 1] / errs[i] for i in range(len(errs) - 1) if errs[i] > 1e-11] + measured = sum(win[-3:]) / len(win[-3:]) + assert abs(measured - predicted) < 1e-3, (sim, measured, predicted) + + +def test_quadratic_approach_similarities_stagnate(): + """The other half of the same law: a similarity reaching 1 quadratically + has c = 0, so the predicted rate is 1 and the iteration must crawl.""" + f = lambda t: t * t - 2.0 + root = math.sqrt(2.0) + for sim in ("rat_sq", "exp_sq", "cosine"): + S = SIMS_01[sim] + x = 0.0 + for _ in range(14): + x = x + (1.0 - S(abs(f(x)) / 2.0)) * (2.0 - x) + assert abs(x - root) > 1e-3, f"{sim} was expected to stagnate" + + +@pytest.mark.parametrize("sim", sorted(FAST_SIMS)) +@pytest.mark.parametrize("prob", PROBLEMS, ids=[p[0] for p in PROBLEMS]) +def test_derived_scale_converges_where_chosen_scale_need_not(sim, prob): + """The data-derived local scale plus the parameter-free safeguard must + always converge; the chosen-scale version carries no such promise and is + only required not to crash.""" + _, f, a, b, root = prob + x, n, conv = derived_step(f, a, b, XTOL, MAXFEV, sim=sim) + assert conv, f"derived.{sim} did not converge" + assert abs(x - root) <= 1e-8 + x2, n2, _ = pure_step(f, a, b, XTOL, MAXFEV, sim) + assert math.isfinite(x2) and n2 <= MAXFEV + + +def test_counter_never_exceeds_the_budget(): + for budget in (3, 7, 25): + for name, m in BASELINES.items(): + _, n, _ = m(lambda t: math.exp(-t) * (t - 1.0), -1.0, 40.0, + XTOL, budget) + assert n <= budget, f"{name} spent {n} of {budget}" + _, n, _ = sim_root(lambda t: math.exp(-t) * (t - 1.0), -1.0, 40.0, + XTOL, budget, prototypes="pair2d", guard=True) + assert n <= budget + + +def test_root_already_at_an_endpoint_costs_two_evaluations(): + for name, m in BASELINES.items(): + x, n, conv = m(lambda t: t - 1.0, 1.0, 5.0, XTOL, MAXFEV) + assert conv and abs(x - 1.0) <= 1e-8, name + assert n <= 3, f"{name} spent {n} on a root sitting on the bracket end" diff --git a/tests/test_three_point.py b/tests/test_three_point.py new file mode 100644 index 0000000..7d375f1 --- /dev/null +++ b/tests/test_three_point.py @@ -0,0 +1,124 @@ +"""Tests for the three-point scale. + +The claim being pinned: a divided difference is a COMPUTATION, not a fitted +coefficient, so `derived3` introduces no parameter; and it must actually lift +the order, otherwise the stage-4 explanation of the endgame deficit is wrong. +""" +from __future__ import annotations + +import math +import os +import sys + +import pytest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from simroot.pure import GUARDS, PURE_SIMS, _slope3, pure_root +from stage5_three_point import PROBLEMS, order_of + +XTOL = 1e-12 +MAXFEV = 300 + + +# -------------------------------------------------------------------------- +# the divided difference itself +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("q", [ + lambda t: 3.0 * t * t - 2.0 * t + 5.0, + lambda t: -1.5 * t * t + 0.25 * t - 7.0, + lambda t: t * t, +]) +def test_slope3_is_exact_on_a_quadratic(q): + """The derivative of the parabola through three points of a quadratic is + that quadratic's derivative, exactly. If this drifts, the order gain is + not what it is claimed to be.""" + h = 1e-3 + for x2 in (-2.0, 0.3, 4.0): + x1, x0 = x2 - h, x2 - 2.0 * h + s = _slope3(x2, q(x2), x1, q(x1), x0, q(x0)) + exact = (q(x2 + 1e-7) - q(x2 - 1e-7)) / 2e-7 + assert s == pytest.approx(exact, rel=1e-6), (x2, s, exact) + + +def test_slope3_is_exact_on_a_line(): + f = lambda t: 4.0 * t - 1.0 + s = _slope3(2.0, f(2.0), 1.0, f(1.0), 0.0, f(0.0)) + assert s == pytest.approx(4.0) + + +def test_slope3_falls_back_to_two_points_when_the_third_is_missing(): + f = lambda t: t * t + two = (f(2.0) - f(1.0)) / (2.0 - 1.0) + assert _slope3(2.0, f(2.0), 1.0, f(1.0), None, None) == pytest.approx(two) + # a repeated node must not divide by zero + assert math.isfinite(_slope3(2.0, f(2.0), 1.0, f(1.0), 1.0, f(1.0))) + assert math.isfinite(_slope3(2.0, f(2.0), 1.0, f(1.0), 2.0, f(2.0))) + + +def test_slope3_never_returns_nan_or_inf_on_degenerate_input(): + for args in [(1.0, 0.0, 1.0, 0.0, 1.0, 0.0), + (1.0, 1e308, 0.5, -1e308, 0.0, 1e308), + (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)]: + s = _slope3(*args) + assert math.isfinite(s) or s == 0.0 + + +# -------------------------------------------------------------------------- +# the method built on it +# -------------------------------------------------------------------------- +@pytest.mark.parametrize("guard", GUARDS) +@pytest.mark.parametrize("prob", PROBLEMS, ids=[p[0] for p in PROBLEMS]) +def test_derived3_converges(prob, guard): + _, f, a, b, root = prob + x, n, conv = pure_root(f, a, b, XTOL, MAXFEV, scale="derived3", guard=guard) + assert conv, f"derived3.{guard} did not converge" + assert abs(x - root) <= 1e-8 + assert n <= MAXFEV + + +@pytest.mark.parametrize("sim", sorted(PURE_SIMS)) +def test_derived3_works_for_every_similarity(sim): + f = lambda t: t * t - 2.0 + x, n, conv = pure_root(f, 0.0, 2.0, XTOL, MAXFEV, similarity=sim, + scale="derived3", guard="both") + assert conv and abs(x - math.sqrt(2.0)) <= 1e-8 + + +def test_three_points_raise_the_order_above_two_points(): + """The whole point of the change. Measured on the problems where an + order can be estimated at all.""" + two, three = [], [] + for _n, f, a, b, root in PROBLEMS: + p2 = order_of(lambda f_, a_, b_, xt, mx: pure_root( + f_, a_, b_, XTOL, MAXFEV, scale="derived", guard="step"), + f, a, b, root) + p3 = order_of(lambda f_, a_, b_, xt, mx: pure_root( + f_, a_, b_, XTOL, MAXFEV, scale="derived3", guard="step"), + f, a, b, root) + if math.isfinite(p2) and math.isfinite(p3): + two.append(p2) + three.append(p3) + assert len(two) >= 5 + m2 = sorted(two)[len(two) // 2] + m3 = sorted(three)[len(three) // 2] + assert 1.4 < m2 < 1.8, m2 # secant + assert m3 > m2 + 0.15, (m2, m3) # a real lift, not noise + + +def test_the_sound_guard_still_costs_the_order(): + """Honest pin of the tension found in stage 5: `both` carries the 2x + bisection bound and, on a method that shrinks the ERROR faster than the + BRACKET, that bound forces a bisection every other step and flattens the + order. This is a property of the guarantee, not a defect - but if + someone later claims high order AND the 2x bound from the same + configuration, this test says otherwise.""" + f = lambda t: t * t - 2.0 + root = math.sqrt(2.0) + p_step = order_of(lambda f_, a_, b_, xt, mx: pure_root( + f_, a_, b_, XTOL, MAXFEV, scale="derived3", guard="step"), + f, 0.0, 2.0, root) + p_both = order_of(lambda f_, a_, b_, xt, mx: pure_root( + f_, a_, b_, XTOL, MAXFEV, scale="derived3", guard="both"), + f, 0.0, 2.0, root) + assert p_step > p_both, (p_step, p_both) diff --git a/verify_article.py b/verify_article.py new file mode 100644 index 0000000..2950f13 --- /dev/null +++ b/verify_article.py @@ -0,0 +1,212 @@ +"""Check every number the paper states against sweep_full.json. + +A paper is a claim about data; transcribing its tables by hand is how a claim +stops matching its data. A failure here means the paper is wrong, not the +test. + +The proposed method is now the CREDIT safeguard - the only configuration with +no free constant. The projection variant is kept in the paper as the other +end of a stated trade (better average, one constant), so both are checked. +""" +from __future__ import annotations + +import json +import sys + +from report_sweep import PROPOSED, head_to_head, place, rank + +FAILS = [] +PROJ = "pure.ratio.derived3.project" + + +def check(label, got, want): + ok = got == want + print(f" {'OK ' if ok else 'BAD'} {label:58s} got {got!r:>16} " + f"want {want!r}") + if not ok: + FAILS.append(label) + + +def row(rows, setname, lbl): + return next(r for r in rows if r["label"] == lbl)[setname] + + +def main(): + with open("sweep_full.json", encoding="utf8") as fh: + rows = json.load(fh) + + # Guard against quoting places from a field that is missing a competitor. + # It has already happened once: before Chandrupatla's own method was + # added, every ranking assertion here passed only because the method that + # beats us was absent. + labels = {r["label"] for r in rows} + missing = {"chandrupatla", "dekker", PROPOSED} - labels + if missing: + print(f" !! THE SWEEP IS STALE: missing {sorted(missing)}. " + "Re-run sweep_full.py.\n") + FAILS.append("sweep is stale") + + check("number of configurations", len(rows), 264) + + # ---- the proposed method: credit safeguard, no free constant ---------- + print("\nThe proposed method (credit safeguard):") + check("its label", PROPOSED, "pure.ratio.derived3.credit") + for setname, pl, tot, sol in (("APS", 29, 3568, 153), + ("CHA", 10, 3020, 40)): + d = row(rows, setname, PROPOSED) + check(f"{setname} place", place(rows, setname, PROPOSED), pl) + check(f"{setname} total", d["total"], tot) + check(f"{setname} solved", d["solved"], sol) + check("both sets", row(rows, "APS", PROPOSED)["total"] + + row(rows, "CHA", PROPOSED)["total"], 6588) + + print("\nHead to head of the proposed method:") + for setname, opp, want in [ + ("APS", "chandrupatla", (79, 3, 71)), + ("APS", "toms748", (77, 9, 67)), + ("APS", "brent", (78, 5, 70)), + ("APS", "itp", (103, 10, 40)), + ("APS", "bisection", (122, 1, 30)), + ("CHA", "chandrupatla", (5, 0, 35)), + ("CHA", "toms748", (24, 0, 16)), + ("CHA", "brent", (18, 0, 20)), + ("CHA", "itp", (12, 20, 8))]: + w, t, l, _ = head_to_head(rows, PROPOSED, opp, setname) + check(f"{setname} vs {opp}", (w, t, l), want) + + # ---- the trade against the projection variant ------------------------- + print("\nThe stated trade: credit against the projection variant:") + check("projection APS", row(rows, "APS", PROJ)["total"], 2806) + check("projection CHA", row(rows, "CHA", PROJ)["total"], 3220) + check("projection both", row(rows, "APS", PROJ)["total"] + + row(rows, "CHA", PROJ)["total"], 6026) + check("credit costs more in total", + (row(rows, "APS", PROPOSED)["total"] + + row(rows, "CHA", PROPOSED)["total"]) + > (row(rows, "APS", PROJ)["total"] + row(rows, "CHA", PROJ)["total"]), + True) + for setname, opp, want in [("APS", "brent", (102, 11, 40)), + ("APS", "toms748", (86, 16, 51))]: + w, t, l, _ = head_to_head(rows, PROJ, opp, setname) + check(f"projection {setname} vs {opp}", (w, t, l), want) + + # ---- what the earlier, order-destroying guards cost -------------------- + print("\nThe guards that replace the step instead of projecting it:") + check("APS unguarded", row(rows, "APS", "pure.ratio.derived3.none")["total"], + 2806) + cha_none = row(rows, "CHA", "pure.ratio.derived3.none") + check("CHA unguarded total", cha_none["total"], 4104) + check("CHA unguarded solved", cha_none["solved"], 35) + check("CHA unguarded bound violations", cha_none["over"], 10) + check("APS bracket-guard", row(rows, "APS", "pure.ratio.derived3.bracket")["total"], + 7260) + check("APS both-guard", row(rows, "APS", "pure.ratio.derived3.both")["total"], + 7239) + + # ---- the field -------------------------------------------------------- + print("\nAlefeld-Potra-Shi:") + check("APS winner", rank(rows, "APS")[0]["label"], "chandrupatla") + for lbl, pl, tot in [("chandrupatla", 1, 2785), ("toms748", 4, 2820), + ("brent", 5, 2889), ("dekker", 12, 3158), + ("itp_oracle", 13, 3260), ("ridders", 20, 3313), + ("itp", 34, 3957), ("illinois", 73, 7045), + ("bisection", 79, 7530), ("regula_falsi", 244, 10560)]: + check(f"APS {lbl} place", place(rows, "APS", lbl), pl) + check(f"APS {lbl} total", row(rows, "APS", lbl)["total"], tot) + check("APS regula falsi solved", row(rows, "APS", "regula_falsi")["solved"], + 127) + + print("\nChandrupatla:") + top = rank(rows, "CHA")[0] + check("CHA rank 1 label", top["label"], "pure.sqrt.bracket.project") + check("CHA rank 1 solves one more than anyone else", top["CHA"]["solved"], 41) + for lbl, pl, tot in [("chandrupatla", 2, 2423), ("itp_oracle", 3, 2611), + ("itp", 6, 2857), ("bisection", 16, 3090), + ("toms748", 164, 4000), ("brent", 226, 4099)]: + check(f"CHA {lbl} place", place(rows, "CHA", lbl), pl) + check(f"CHA {lbl} total", row(rows, "CHA", lbl)["total"], tot) + check("CHA brent solved", row(rows, "CHA", "brent")["solved"], 38) + + ours_both = (row(rows, "APS", PROPOSED)["total"] + + row(rows, "CHA", PROPOSED)["total"]) + cha_both = (row(rows, "APS", "chandrupatla")["total"] + + row(rows, "CHA", "chandrupatla")["total"]) + check("chandrupatla, both sets", cha_both, 5208) + check("Chandrupatla beats us on both sets", cha_both < ours_both, True) + + # ---- the regime findings --------------------------------------------- + print("\nNegative results, the regime claims:") + check("CHA cbrt over the whole set", + row(rows, "CHA", "pure.cbrt.derived3.project")["total"], 4099) + switched = (row(rows, "APS", PROJ)["total"] + + row(rows, "CHA", "pure.cbrt.derived3.project")["total"]) + single = row(rows, "APS", PROJ)["total"] + row(rows, "CHA", PROJ)["total"] + check("single fixed choice, both sets", single, 6026) + check("switch by benchmark set, both sets", switched, 6905) + check("switching is worse than not switching", switched > single, True) + for pid, ours_n, cb_n in (("fun4.1", 89, 32), ("fun4.2", 93, 32), + ("fun4.3", 113, 40), ("fun4.4", 125, 47), + ("fun4.5", 153, 59)): + o = row(rows, "CHA", PROJ)["per"][pid] + c = row(rows, "CHA", "pure.cbrt.derived3.project")["per"][pid] + check(f"{pid} projection variant", o[0], ours_n) + check(f"{pid} cbrt", c[0], cb_n) + + # ---- the law across the grid ------------------------------------------ + print("\nThe law across the grid:") + lin = ("ratio", "rational", "exp_abs") + quad = ("rat_sq", "exp_sq", "cosine") + want = {("derived3", "lin"): 6809, ("derived3", "quad"): 22294, + ("derived", "lin"): 6906, ("derived", "quad"): 22167, + ("bracket", "lin"): 10263, ("bracket", "quad"): 19137, + ("start", "lin"): 16102, ("start", "quad"): 15345} + for scale in ("derived3", "derived", "bracket", "start"): + for group, gname in ((lin, "lin"), (quad, "quad")): + tot = cnt = 0 + for r in rows: + if r["spec"][0] != "pure": + continue + _, sim, sc, gu = r["spec"] + if sc != scale or gu != "step" or sim not in group: + continue + cnt += 1 + tot += r["APS"]["total"] + r["CHA"]["total"] + check(f"mean total, scale={scale}, {gname}", + round(tot / cnt), want[(scale, gname)]) + + best_by_sim, best_by_scale = {}, {} + for r in rows: + if r["spec"][0] != "pure" or r["spec"][3] != "step": + continue + t = r["APS"]["total"] + r["CHA"]["total"] + best_by_sim[r["spec"][1]] = min(best_by_sim.get(r["spec"][1], 10 ** 9), t) + best_by_scale[r["spec"][2]] = min(best_by_scale.get(r["spec"][2], 10 ** 9), t) + check("every c=1 similarity beats every c=0 similarity", + max(best_by_sim[s] for s in lin) < min(best_by_sim[s] for s in quad), + True) + check("similarity ranking", + [s for s, _ in sorted(best_by_sim.items(), key=lambda kv: kv[1])], + ["ratio", "exp_abs", "rational", "ratio_soft", "sqrt", "cbrt", + "exp_sq", "rat_sq", "cosine"]) + for sim, v in [("ratio", 6496), ("exp_abs", 6822), ("rational", 7038), + ("ratio_soft", 9502), ("sqrt", 10497), ("cbrt", 11941), + ("exp_sq", 14314), ("rat_sq", 15102), ("cosine", 16394)]: + check(f"similarity {sim} best", best_by_sim[sim], v) + check("scale ranking", + [s for s, _ in sorted(best_by_scale.items(), key=lambda kv: kv[1])], + ["derived3", "derived", "bracket", "start"]) + for sc, v in [("derived3", 6496), ("derived", 6628), ("bracket", 9081), + ("start", 14540)]: + check(f"scale {sc} best", best_by_scale[sc], v) + + print() + if FAILS: + print(f"{len(FAILS)} STATED NUMBERS DO NOT MATCH THE DATA:") + for f in FAILS: + print(f" {f}") + sys.exit(1) + print("every number stated in the paper matches the sweep data.") + + +if __name__ == "__main__": + main()