task_id stringlengths 21 23 | challenge_id stringlengths 16 16 | proof_assistant stringclasses 1
value | session stringclasses 1
value | repo stringclasses 57
values | revision stringclasses 57
values | file_path stringlengths 13 92 | theory stringlengths 1 48 | variant int64 0 132 | challenge_type stringclasses 1
value | difficulty null | count null | by_centrality bool 1
class | ablation_prob float64 0.5 0.5 | min_depth int64 1 1 | max_depth int64 1 1 | leaves_only bool 1
class | min_size int64 0 0 | max_size stringclasses 1
value | min_centrality int64 0 0 | max_centrality stringclasses 1
value | seed int64 42 42 | n_proofs int64 1 173 | n_ablated int64 1 60 | holes_filled listlengths 1 60 | deleted_lemmas listlengths 1 1 | corollaries listlengths 1 1 | closure_size int64 1 172 | challenge_file_content stringlengths 133 350k | solution_file_content stringlengths 394 351k | solution_diff stringlengths 243 134k | manifest dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ablate_4c529ee26726_5 | 32b5432b127f11bb | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 5 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 4 | [
{
"theorem_name": "isQueryBoundP_run_withPregen",
"depth": 1,
"n_commands": 0,
"n_lines": 8,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases hseed : seed t with\n | nil =>\n rw [withPregen_run_nil _ hseed]\n exact (OracleComp.isQueryB... | [
{
"name": "withPregen_run_nil",
"text": "/-- Seed-miss: `withPregen` falls back to a single call of `so`, threading the seed unchanged. -/\nlemma withPregen_run_nil (so : QueryImpl spec m) {t : spec.Domain}\n {seed : QuerySeed spec} (h : seed t = []) :\n (so.withPregen t).run seed = (·, seed) <$> so t... | [
{
"name": "run_nil",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 3,
"n_lines": 6,
"n_chars": 327,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 1,
"n_structural": 0,
"automation_only": false,
"max_nesting": 2
}... | 2 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -49,6 +49,17 @@
| u :: us => pure (u, Function.update seed t us)
| [] => (·, seed) <$> so t := rfl
+/-- Seed-miss: `withPregen` falls back to a single call of `so`, threading the seed unchanged. -/
+lemma withPregen_run_nil (so : QueryImpl spec m) {t : spec.Domain}
+ {seed : QuerySeed spec} (h : s... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_6 | eac4cbe217d98245 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 6 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"fan_in": 1,
"n_deps_direct": 2,
"n_deps_transitive": 2,
"n_lines": 107,
"n_chars": 5064,
"n_subproofs": 13,
"n_tactics": 103,
"cyclomatic": 6,
"n_automation": 7,
"n_rewrites": 13,
"n_structural": 21,
... | 2 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_7 | 2ba3d07b7bf35703 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 7 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "evalDist_liftComp_uniformSample_bind_simulateQ_run'_addValue",
"fan_in": 1,
"n_deps_direct": 5,
"n_deps_transitive": 5,
"n_lines": 58,
"n_chars": 2710,
"n_subproofs": 1,
"n_tactics": 50,
"cyclomatic": 5,
"n_automation": 4,
"n_rewrites": 9,
"n_structural": 1... | 5 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_8 | da676faa8e3ce91e | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 8 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "evalDist_liftComp_replicate_uniformSample_bind_simulateQ_run'_addValues",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 6,
"n_lines": 33,
"n_chars": 1580,
"n_subproofs": 1,
"n_tactics": 25,
"cyclomatic": 2,
"n_automation": 2,
"n_rewrites": 5,
"n_str... | 6 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_9 | 7cfc24c5759ff56a | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 9 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 2 | [
{
"theorem_name": "probOutput_prependValues_takeAtIndex_tsum_eq_query_mul",
"depth": 1,
"n_commands": 0,
"n_lines": 7,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n simp_rw [probOutput_generateSeed_prependValues spec₀ qc js u _ hcount, mul_assoc]\n ... | [
{
"name": "probOutput_liftComp_generateSeed_bind_simulateQ_run'_takeAtIndex_eq_tsum",
"text": "private lemma probOutput_liftComp_generateSeed_bind_simulateQ_run'_takeAtIndex_eq_tsum\n {ι₀ : Type} {spec₀ : OracleSpec ι₀} [DecidableEq ι₀]\n [∀ i, SampleableType (spec₀.Range i)] [unifSpec ⊂ₒ spec₀]\n ... | [
{
"name": "probOutput_prependValues_takeAtIndex_tsum_eq_query_mul",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 23,
"n_chars": 1276,
"n_subproofs": 0,
"n_tactics": 7,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 3,
"n_structural": 2,
"... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -271,6 +271,21 @@
probOutput_generateSeed_bind_simulateQ_bind (qc := qc) (js := js)
(oa := oa) (ob := fun x => pure (f x)) (y := y)
+private lemma probOutput_liftComp_generateSeed_bind_simulateQ_run'_takeAtIndex_eq_tsum
+ {ι₀ : Type} {spec₀ : OracleSpec ι₀} [DecidableEq ι₀]
+ [∀ i, SampleableType... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_10 | 91648bb0e8434266 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 10 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "tsum_probOutput_generateSeed_weight_takeAtIndex",
"fan_in": 0,
"n_deps_direct": 6,
"n_deps_transitive": 6,
"n_lines": 137,
"n_chars": 7285,
"n_subproofs": 11,
"n_tactics": 136,
"cyclomatic": 4,
"n_automation": 12,
"n_rewrites": 32,
"n_structural": 19,
"... | 6 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_11 | 4d6dfa0c2634883e | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 11 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "isPerIndexQueryBound_run'_of_seedCoverage",
"fan_in": 4,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 68,
"n_chars": 2895,
"n_subproofs": 5,
"n_tactics": 55,
"cyclomatic": 4,
"n_automation": 9,
"n_rewrites": 9,
"n_structural": 9,
"automation_o... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_12 | e8f6cf37197231c3 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 12 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "isPerIndexQueryBound_run'_zero",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 10,
"n_chars": 502,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": true,
... | 2 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_13 | 8ef24ebee4b406cc | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 13 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "isPerIndexQueryBound_run'_takeAtIndex",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 22,
"n_chars": 1071,
"n_subproofs": 0,
"n_tactics": 7,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 2,
"automation_only":... | 2 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_14 | 6033a0ac024384c6 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 14 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "isPerIndexQueryBound_run'_takeAtIndex_addValue",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 22,
"n_chars": 1077,
"n_subproofs": 1,
"n_tactics": 11,
"cyclomatic": 1,
"n_automation": 3,
"n_rewrites": 1,
"n_structural": 2,
"automat... | 2 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_15 | 1845b36d17e930d2 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 15 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 4 | [
{
"theorem_name": "run_nil",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [eq_withPregen, QueryImpl.withPregen_run_nil _ h, QueryImpl.ofLift_apply]",
"n_chars": 82,
"n_subproofs": 0,
"n_tact... | [
{
"name": "eq_withPregen",
"text": "/-- Definitional unfold of `seededOracle` as the pregen handler over the lifting handler. -/\nlemma eq_withPregen :\n (spec.seededOracle : QueryImpl spec (StateT (QuerySeed spec) (OracleComp spec))) =\n (QueryImpl.ofLift spec (OracleComp spec)).withPregen := rfl\n... | [
{
"name": "isTotalQueryBound_run_simulateQ",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 10,
"n_chars": 516,
"n_subproofs": 0,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 1,
"n_structural": 1,
"automation_only": false,... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -165,6 +165,11 @@
namespace seededOracle
+/-- Definitional unfold of `seededOracle` as the pregen handler over the lifting handler. -/
+lemma eq_withPregen :
+ (spec.seededOracle : QueryImpl spec (StateT (QuerySeed spec) (OracleComp spec))) =
+ (QueryImpl.ofLift spec (OracleComp spec)).withPregen := rfl... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_16 | 45ab2140d3f29d80 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 16 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 4 | [
{
"theorem_name": "run_nil",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [eq_withPregen, QueryImpl.withPregen_run_nil _ h, QueryImpl.ofLift_apply]",
"n_chars": 82,
"n_subproofs": 0,
"n_tact... | [
{
"name": "eq_withPregen",
"text": "/-- Definitional unfold of `seededOracle` as the pregen handler over the lifting handler. -/\nlemma eq_withPregen :\n (spec.seededOracle : QueryImpl spec (StateT (QuerySeed spec) (OracleComp spec))) =\n (QueryImpl.ofLift spec (OracleComp spec)).withPregen := rfl\n... | [
{
"name": "isQueryBoundP_run_simulateQ",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 13,
"n_chars": 657,
"n_subproofs": 0,
"n_tactics": 6,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 1,
"n_structural": 1,
"automation_only": false,
... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -165,6 +165,11 @@
namespace seededOracle
+/-- Definitional unfold of `seededOracle` as the pregen handler over the lifting handler. -/
+lemma eq_withPregen :
+ (spec.seededOracle : QueryImpl spec (StateT (QuerySeed spec) (OracleComp spec))) =
+ (QueryImpl.ofLift spec (OracleComp spec)).withPregen := rfl... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_17 | 5b5eb06f39c13877 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 17 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 4 | [
{
"theorem_name": "run_nil",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [eq_withPregen, QueryImpl.withPregen_run_nil _ h, QueryImpl.ofLift_apply]",
"n_chars": 82,
"n_subproofs": 0,
"n_tact... | [
{
"name": "eq_withPregen",
"text": "/-- Definitional unfold of `seededOracle` as the pregen handler over the lifting handler. -/\nlemma eq_withPregen :\n (spec.seededOracle : QueryImpl spec (StateT (QuerySeed spec) (OracleComp spec))) =\n (QueryImpl.ofLift spec (OracleComp spec)).withPregen := rfl\n... | [
{
"name": "isPerIndexQueryBound_run_simulateQ",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 13,
"n_chars": 629,
"n_subproofs": 0,
"n_tactics": 7,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 2,
"n_structural": 3,
"automation_only": fal... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -165,6 +165,11 @@
namespace seededOracle
+/-- Definitional unfold of `seededOracle` as the pregen handler over the lifting handler. -/
+lemma eq_withPregen :
+ (spec.seededOracle : QueryImpl spec (StateT (QuerySeed spec) (OracleComp spec))) =
+ (QueryImpl.ofLift spec (OracleComp spec)).withPregen := rfl... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_18 | 3046c948bd86c21a | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 18 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "isPerIndexQueryBound_run_simulateQ_zero",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 3,
"n_lines": 14,
"n_chars": 791,
"n_subproofs": 1,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 1,
"n_structural": 1,
"automation_only"... | 3 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_4c529ee26726_19 | 81120f2d1063872a | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/OracleComp/QueryTracking/SeededOracle.lean | SeededOracle | 19 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 23 | 5 | [
{
"theorem_name": "evalDist_liftComp_generateSeed_bind_simulateQ_run'",
"depth": 1,
"n_commands": 0,
"n_lines": 95,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n classical\n revert qc js\n induction oa using OracleComp.inductionOn with\n | pure x... | [
{
"name": "run'_bind_query_eq_pop",
"text": "/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,\neither falling back to a fresh `query t` or consuming the popped head. -/\nlemma run'_bind_query_eq_pop {α : Type u}\n (t : spec.Domain) (mx : spec.Range t → Orac... | [
{
"name": "isPerIndexQueryBound_run_simulateQ_of_seedCoverage",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 15,
"n_chars": 857,
"n_subproofs": 1,
"n_tactics": 5,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 1,
"n_structural": 1,
"autom... | 2 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.Constructions.GenerateSeed
import VCVio.OracleComp.QueryTracking.QueryBound
import VCVio.OracleCo... | @@ -92,6 +92,21 @@
cases hst : seed t <;>
simp [seededOracle.apply_eq, StateT.run_bind, QuerySeed.pop, hst]
+/-- `run'` form of `run_bind_query_eq_pop`: querying `t` then continuing splits on `seed.pop t`,
+either falling back to a fresh `query t` or consuming the popped head. -/
+lemma run'_bind_query_eq_pop... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_3758adf9b1c2_0 | e2ef8ae056bdb85a | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | HashSig/SLHDSA/C13/ForsC.lean | ForsC | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 1 | 1 | [
{
"theorem_name": "forsCPkFromSig_forsCSign",
"depth": 1,
"n_commands": 0,
"n_lines": 16,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n unfold forsCPkFromSig forsPkGen\n refine congrArg (prims.Tl pk (forsPkAdrs adrs)) (List.map_congr_left fun i _ =... | [
{
"name": "forsIdx_lt",
"text": "theorem forsIdx_lt (digest i : ℕ) : forsIdx digest i < 2 ^ params.a :=\n Nat.mod_lt _ (by positivity)\n\n",
"fan_in": 1,
"n_lines": 4,
"n_chars": 105,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
... | [
{
"name": "forsCPkFromSig_forsCSign",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 23,
"n_chars": 1245,
"n_subproofs": 3,
"n_tactics": 16,
"cyclomatic": 1,
"n_automation": 5,
"n_rewrites": 4,
"n_structural": 2,
"automation_only": false,
... | 1 | /-
Copyright (c) 2026 Nicolas Consigny. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Nicolas Consigny
-/
import HashSig.SLHDSA.C13.Params
import HashSig.SLHDSA.C13.Primitives
import HashSig.SLHDSA.Xmss
/-!
# FORS+C (C13)
The compact few-time forest of the C-series:... | /-
Copyright (c) 2026 Nicolas Consigny. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Nicolas Consigny
-/
import HashSig.SLHDSA.C13.Params
import HashSig.SLHDSA.C13.Primitives
import HashSig.SLHDSA.Xmss
/-!
# FORS+C (C13)
The compact few-time forest of the C-series:... | @@ -70,6 +70,9 @@
/-- The selected leaf index in tree `i`: the `i`-th `a`-bit LSB-first slice of the digest. -/
def forsIdx (digest i : ℕ) : ℕ := (digest >>> (i * params.a)) % 2 ^ params.a
+theorem forsIdx_lt (digest i : ℕ) : forsIdx digest i < 2 ^ params.a :=
+ Nat.mod_lt _ (by positivity)
+
/-- Verifier-side fo... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_dc20b6ab5495_0 | 743c64a9aa67671e | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | ToMathlib/Data/Vector.lean | Vector | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 1 | 2 | [
{
"theorem_name": "mapM_id_option_map_comm",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [Vector.mapM_map]\n exact Vector.mapM_map_postcomp v (id : Option α → Option α) g",
"n_chars": 94,
"n_s... | [
{
"name": "mapM_map_postcomp",
"text": "/-- `Vector.mapM` commutes with post-composition by a pure map:\nmapping `g` after each monadic action is the same as mapping `g` over the collected vector. -/\nlemma mapM_map_postcomp {m : Type → Type} {α β γ : Type} {n : ℕ}\n [Monad m] [LawfulMonad m]\n (v : V... | [
{
"name": "mapM_id_option_map_comm",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 10,
"n_chars": 470,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 1,
"n_structural": 1,
"automation_only": false,
"ma... | 1 | /-
Copyright (c) 2026 Alexander Hicks. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Alexander Hicks
-/
module
public import ToMathlib.General
/-!
# Lemmas about monadic operations on `Vector`
Commutation lemmas for `Vector.mapM` against pure post-processing maps, ... | /-
Copyright (c) 2026 Alexander Hicks. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Alexander Hicks
-/
module
public import ToMathlib.General
/-!
# Lemmas about monadic operations on `Vector`
Commutation lemmas for `Vector.mapM` against pure post-processing maps, ... | @@ -20,12 +20,34 @@
namespace Vector
+/-- `Vector.mapM` commutes with post-composition by a pure map:
+mapping `g` after each monadic action is the same as mapping `g` over the collected vector. -/
+lemma mapM_map_postcomp {m : Type → Type} {α β γ : Type} {n : ℕ}
+ [Monad m] [LawfulMonad m]
+ (v : Vector α n... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_dc20b6ab5495_1 | 189d21502382b2a0 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | ToMathlib/Data/Vector.lean | Vector | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 1 | 2 | [
{
"theorem_name": "mapM_id_option_map_comm",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [Vector.mapM_map]\n exact Vector.mapM_map_postcomp v (id : Option α → Option α) g",
"n_chars": 94,
"n_s... | [
{
"name": "mapM_map_postcomp",
"text": "/-- `Vector.mapM` commutes with post-composition by a pure map:\nmapping `g` after each monadic action is the same as mapping `g` over the collected vector. -/\nlemma mapM_map_postcomp {m : Type → Type} {α β γ : Type} {n : ℕ}\n [Monad m] [LawfulMonad m]\n (v : V... | [
{
"name": "mapM_bind_map_eq",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 16,
"n_chars": 779,
"n_subproofs": 1,
"n_tactics": 5,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 1,
"n_structural": 2,
"automation_only": false,
"max_nesti... | 1 | /-
Copyright (c) 2026 Alexander Hicks. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Alexander Hicks
-/
module
public import ToMathlib.General
/-!
# Lemmas about monadic operations on `Vector`
Commutation lemmas for `Vector.mapM` against pure post-processing maps, ... | /-
Copyright (c) 2026 Alexander Hicks. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Alexander Hicks
-/
module
public import ToMathlib.General
/-!
# Lemmas about monadic operations on `Vector`
Commutation lemmas for `Vector.mapM` against pure post-processing maps, ... | @@ -20,6 +20,26 @@
namespace Vector
+/-- `Vector.mapM` commutes with post-composition by a pure map:
+mapping `g` after each monadic action is the same as mapping `g` over the collected vector. -/
+lemma mapM_map_postcomp {m : Type → Type} {α β γ : Type} {n : ℕ}
+ [Monad m] [LawfulMonad m]
+ (v : Vector α n)... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_0 | 90fc4f14f3605447 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 2 | [
{
"theorem_name": "IND_CPA_queryImpl'_counted_proj_eq_queryImpl'",
"depth": 1,
"n_commands": 0,
"n_lines": 7,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases t with\n | inl tu => simp [IND_CPA_queryImpl'_counted, IND_CPA_queryImpl', IND_CPA_que... | [
{
"name": "IND_CPA_countedChallengeOracle_proj_eq_cached",
"text": "private lemma IND_CPA_countedChallengeOracle_proj_eq_cached\n (pk : PK)\n (selectCount : ℕ → M × M → M)\n (select : M × M → M)\n (hselect : ∀ n mm, selectCount n mm = select mm)\n (mm : M × M) (st : encAlg'.IND_CPA_CountedSta... | [
{
"name": "IND_CPA_queryImpl'_counted_proj_eq_queryImpl'",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 15,
"n_chars": 757,
"n_subproofs": 0,
"n_tactics": 7,
"cyclomatic": 2,
"n_automation": 2,
"n_rewrites": 0,
"n_structural": 2,
"automation... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -165,6 +165,18 @@
(simulateQ (encAlg'.IND_CPA_queryImpl_hybridLR_counted pk leftUntil) (adversary pk)).run'
(∅, 0)
+private lemma IND_CPA_countedChallengeOracle_proj_eq_cached
+ (pk : PK)
+ (selectCount : ℕ → M × M → M)
+ (select : M × M → M)
+ (hselect : ∀ n mm, selectCount n mm = select mm)
+... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_1 | 68a64f06c0f17a12 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 2 | [
{
"theorem_name": "IND_CPA_queryImpl'_counted_proj_eq_queryImpl'",
"depth": 1,
"n_commands": 0,
"n_lines": 7,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases t with\n | inl tu => simp [IND_CPA_queryImpl'_counted, IND_CPA_queryImpl', IND_CPA_que... | [
{
"name": "IND_CPA_countedChallengeOracle_proj_eq_cached",
"text": "private lemma IND_CPA_countedChallengeOracle_proj_eq_cached\n (pk : PK)\n (selectCount : ℕ → M × M → M)\n (select : M × M → M)\n (hselect : ∀ n mm, selectCount n mm = select mm)\n (mm : M × M) (st : encAlg'.IND_CPA_CountedSta... | [
{
"name": "IND_CPA_queryImpl_hybridLR_counted_proj_eq_queryImpl'_false",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 15,
"n_chars": 756,
"n_subproofs": 0,
"n_tactics": 8,
"cyclomatic": 2,
"n_automation": 2,
"n_rewrites": 0,
"n_structural": 2,
... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -165,6 +165,18 @@
(simulateQ (encAlg'.IND_CPA_queryImpl_hybridLR_counted pk leftUntil) (adversary pk)).run'
(∅, 0)
+private lemma IND_CPA_countedChallengeOracle_proj_eq_cached
+ (pk : PK)
+ (selectCount : ℕ → M × M → M)
+ (select : M × M → M)
+ (hselect : ∀ n mm, selectCount n mm = select mm)
+... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_2 | 938c78211dd733be | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 2 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 1 | [
{
"theorem_name": "IND_CPA_queryImpl'_counted_run_invariant_le",
"depth": 1,
"n_commands": 0,
"n_lines": 15,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases t with\n | inl tu =>\n simp only [IND_CPA_queryImpl'_counted, IND_CPA_queryImplFro... | [
{
"name": "IND_CPA_queryImpl'_counted_counter_le_succ",
"text": "/-- One-step counter monotonicity for the counted real IND-CPA implementation. -/\nlemma IND_CPA_queryImpl'_counted_counter_le_succ\n (pk : PK) (b : Bool)\n (t : encAlg'.IND_CPA_oracleSpec.Domain)\n (st : encAlg'.IND_CPA_CountedState)... | [
{
"name": "IND_CPA_queryImpl'_counted_run_invariant_le",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 27,
"n_chars": 1447,
"n_subproofs": 2,
"n_tactics": 15,
"cyclomatic": 2,
"n_automation": 5,
"n_rewrites": 2,
"n_structural": 2,
"automation... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -165,6 +165,38 @@
(simulateQ (encAlg'.IND_CPA_queryImpl_hybridLR_counted pk leftUntil) (adversary pk)).run'
(∅, 0)
+/-- One-step counter monotonicity for the counted real IND-CPA implementation. -/
+lemma IND_CPA_queryImpl'_counted_counter_le_succ
+ (pk : PK) (b : Bool)
+ (t : encAlg'.IND_CPA_oracleS... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_3 | 19345b99ece94a9d | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 3 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 1 | [
{
"theorem_name": "IND_CPA_run'_evalDist_eq_queryImpl'_of_bounded_eq",
"depth": 1,
"n_commands": 0,
"n_lines": 30,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have hrun :\n 𝒟[(simulateQ (implCounted pk b q) comp).run (cache, n)] =\n 𝒟[... | [
{
"name": "IND_CPA_queryImpl'_counted_run_invariant_le",
"text": "/-- The counted real IND-CPA implementation preserves the budget-indexed invariant\n`st.2 + budget ≤ q`: after answering a query that the structural bound permits, the spent counter\nplus the decremented budget still fits under `q`. This is t... | [
{
"name": "IND_CPA_run'_evalDist_eq_queryImpl'_of_bounded_eq",
"fan_in": 2,
"n_deps_direct": 2,
"n_deps_transitive": 4,
"n_lines": 49,
"n_chars": 2861,
"n_subproofs": 2,
"n_tactics": 32,
"cyclomatic": 4,
"n_automation": 6,
"n_rewrites": 0,
"n_structural": 4,
"auto... | 4 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -223,6 +223,32 @@
(fun _ mm => if b then mm.1 else mm.2) (fun mm => if b then mm.1 else mm.2)
(fun _ _ => rfl) mm st
+/-- The counted real IND-CPA implementation preserves the budget-indexed invariant
+`st.2 + budget ≤ q`: after answering a query that the structural bound permits, the spent count... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_4 | 333d0e0ed2589680 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 4 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 2 | [
{
"theorem_name": "IND_CPA_countedGame_eq_game_of_MakesAtMostQueries",
"depth": 1,
"n_commands": 0,
"n_lines": 9,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n congr 1\n have hinner : ∀ (pk : PK) (b : Bool),\n 𝒟[(simulateQ (implCounted pk b q... | [
{
"name": "IND_CPA_run'_evalDist_eq_queryImpl'_of_bounded_eq",
"text": "/-- If a counted IND-CPA hybrid implementation agrees with the counted real implementation\nthrough the first `q` fresh LR queries, then any adversary making at most `q` LR queries sees\nthe same output distribution as in the real IND-C... | [
{
"name": "IND_CPA_countedGame_eq_game_of_MakesAtMostQueries",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 5,
"n_lines": 29,
"n_chars": 1633,
"n_subproofs": 1,
"n_tactics": 9,
"cyclomatic": 1,
"n_automation": 3,
"n_rewrites": 1,
"n_structural": 1,
"autom... | 5 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -249,6 +249,54 @@
simp only [Sum.isRight, not_true, reduceIte, false_or] at hcan ⊢
omega
+/-- If a counted IND-CPA hybrid implementation agrees with the counted real implementation
+through the first `q` fresh LR queries, then any adversary making at most `q` LR queries sees
+the same output distribu... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_5 | 2b65d42856d7b62a | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 5 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 1 | [
{
"theorem_name": "IND_CPA_LR_hybridGame_zero_evalDist_eq_right",
"depth": 1,
"n_commands": 0,
"n_lines": 10,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n simp only [IND_CPA_LR_hybridGame, IND_CPA_LR_experiment, evalDist_bind]\n congr 1\n funext ... | [
{
"name": "IND_CPA_queryImpl_hybridLR_counted_proj_eq_queryImpl'_false",
"text": "/-- The `leftUntil = 0` left/right hybrid is exactly the all-right endpoint game once the\ncounter is projected away. -/\nlemma IND_CPA_queryImpl_hybridLR_counted_proj_eq_queryImpl'_false\n (pk : PK) (t : encAlg'.IND_CPA_or... | [
{
"name": "IND_CPA_LR_hybridGame_zero_evalDist_eq_right",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 16,
"n_chars": 738,
"n_subproofs": 0,
"n_tactics": 10,
"cyclomatic": 1,
"n_automation": 2,
"n_rewrites": 1,
"n_structural": 1,
"automation... | 2 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -177,6 +177,20 @@
rcases hcache : st.1 mm with _ | c <;>
simp [IND_CPA_countedChallengeOracle, IND_CPA_cachedChallengeOracle, hcache, hselect]
+/-- The `leftUntil = 0` left/right hybrid is exactly the all-right endpoint game once the
+counter is projected away. -/
+lemma IND_CPA_queryImpl_hybridLR_counted_... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_6 | 5b3315eb9b4472c7 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 6 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 2 | [
{
"theorem_name": "IND_CPA_countedGame_eq_game_of_MakesAtMostQueries",
"depth": 1,
"n_commands": 0,
"n_lines": 9,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n congr 1\n have hinner : ∀ (pk : PK) (b : Bool),\n 𝒟[(simulateQ (implCounted pk b q... | [
{
"name": "IND_CPA_run'_evalDist_eq_queryImpl'_of_bounded_eq",
"text": "/-- If a counted IND-CPA hybrid implementation agrees with the counted real implementation\nthrough the first `q` fresh LR queries, then any adversary making at most `q` LR queries sees\nthe same output distribution as in the real IND-C... | [
{
"name": "IND_CPA_LR_hybridGame_q_evalDist_eq_left_of_MakesAtMostQueries",
"fan_in": 1,
"n_deps_direct": 2,
"n_deps_transitive": 6,
"n_lines": 34,
"n_chars": 1625,
"n_subproofs": 1,
"n_tactics": 29,
"cyclomatic": 7,
"n_automation": 6,
"n_rewrites": 1,
"n_structural":... | 6 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -249,6 +249,54 @@
simp only [Sum.isRight, not_true, reduceIte, false_or] at hcan ⊢
omega
+/-- If a counted IND-CPA hybrid implementation agrees with the counted real implementation
+through the first `q` fresh LR queries, then any adversary making at most `q` LR queries sees
+the same output distribu... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_7 | c5e9dd5576ed22bb | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 7 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 1 | [
{
"theorem_name": "IND_CPA_LR_hybridGame_zero_probOutput_eq_right",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": "\n (evalDist_ext_iff.mp\n (IND_CPA_LR_hybridGame_zero_evalDist_eq_right (encAlg' := encAlg') ad... | [
{
"name": "IND_CPA_LR_hybridGame_zero_evalDist_eq_right",
"text": "/-- The `leftUntil = 0` LR-hybrid is the all-right endpoint game. -/\ntheorem IND_CPA_LR_hybridGame_zero_evalDist_eq_right\n (adversary : encAlg'.IND_CPA_adversary) :\n 𝒟[encAlg'.IND_CPA_LR_hybridGame adversary 0] =\n 𝒟[encAlg'.... | [
{
"name": "IND_CPA_LR_hybridGame_zero_probOutput_eq_right",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 3,
"n_lines": 9,
"n_chars": 439,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 0,
"automation... | 3 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -203,11 +203,28 @@
variable [DecidableEq M]
variable {encAlg' : AsymmEncAlg ProbComp M PK SK C}
+/-- The `leftUntil = 0` LR-hybrid is the all-right endpoint game. -/
+theorem IND_CPA_LR_hybridGame_zero_evalDist_eq_right
+ (adversary : encAlg'.IND_CPA_adversary) :
+ 𝒟[encAlg'.IND_CPA_LR_hybridGame adversar... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_8 | 2c9c50a34b7e18ac | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 8 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 2 | [
{
"theorem_name": "IND_CPA_countedGame_eq_game_of_MakesAtMostQueries",
"depth": 1,
"n_commands": 0,
"n_lines": 9,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n congr 1\n have hinner : ∀ (pk : PK) (b : Bool),\n 𝒟[(simulateQ (implCounted pk b q... | [
{
"name": "IND_CPA_run'_evalDist_eq_queryImpl'_of_bounded_eq",
"text": "/-- If a counted IND-CPA hybrid implementation agrees with the counted real implementation\nthrough the first `q` fresh LR queries, then any adversary making at most `q` LR queries sees\nthe same output distribution as in the real IND-C... | [
{
"name": "IND_CPA_LR_hybridGame_q_probOutput_eq_left_of_MakesAtMostQueries",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 7,
"n_lines": 13,
"n_chars": 622,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural":... | 7 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -249,6 +249,54 @@
simp only [Sum.isRight, not_true, reduceIte, false_or] at hcan ⊢
omega
+/-- If a counted IND-CPA hybrid implementation agrees with the counted real implementation
+through the first `q` fresh LR queries, then any adversary making at most `q` LR queries sees
+the same output distribu... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_9 | 5d9ff41cda1ee6a6 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 9 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 1 | [
{
"theorem_name": "IND_CPA_signedAdvantageReal_eq_lrDiff_half",
"depth": 1,
"n_commands": 0,
"n_lines": 6,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n unfold IND_CPA_signedAdvantageReal\n rw [IND_CPA_experiment_probOutput_eq_branch (encAlg' := en... | [
{
"name": "IND_CPA_experiment_probOutput_eq_branch",
"text": "/-- The standard random-bit IND-CPA experiment is the uniform-bit branch over the all-left and\nall-right endpoint games. -/\nprivate lemma IND_CPA_experiment_probOutput_eq_branch\n (adversary : encAlg'.IND_CPA_adversary) :\n Pr[= true | IN... | [
{
"name": "IND_CPA_signedAdvantageReal_eq_lrDiff_half",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 13,
"n_chars": 676,
"n_subproofs": 0,
"n_tactics": 6,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 2,
"n_structural": 1,
"automation_on... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -177,6 +177,20 @@
variable [DecidableEq M]
variable {encAlg' : AsymmEncAlg ProbComp M PK SK C}
+/-- The standard random-bit IND-CPA experiment is the uniform-bit branch over the all-left and
+all-right endpoint games. -/
+private lemma IND_CPA_experiment_probOutput_eq_branch
+ (adversary : encAlg'.IND_CPA_adv... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_10 | 53b5dbb5fe699aa5 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 10 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 1 | [
{
"theorem_name": "IND_CPA_signedAdvantageReal_eq_sum_hybridDiff",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n unfold IND_CPA_signedAdvantageReal\n rw [sum_hybridDiff_eq_trueProb_sub games q]\n linarith... | [
{
"name": "sum_hybridDiff_eq_trueProb_sub",
"text": "/-- Telescoping identity for adjacent hybrid differences over a finite game sequence. -/\nprivate lemma sum_hybridDiff_eq_trueProb_sub (games : ℕ → ProbComp Bool) (q : ℕ) :\n Finset.sum (Finset.range q)\n (fun i => (Pr[= true | games i]).toReal - ... | [
{
"name": "IND_CPA_signedAdvantageReal_eq_sum_hybridDiff",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 16,
"n_chars": 840,
"n_subproofs": 0,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 2,
"n_structural": 0,
"automation... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -181,6 +181,13 @@
noncomputable def IND_CPA_signedAdvantageReal (adversary : encAlg'.IND_CPA_adversary) : ℝ :=
(Pr[= true | IND_CPA_experiment (encAlg := encAlg') adversary]).toReal - 1 / 2
+/-- Telescoping identity for adjacent hybrid differences over a finite game sequence. -/
+private lemma sum_hybridDiff_e... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_11 | 9910ea857c3b9b27 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 11 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 1 | [
{
"theorem_name": "IND_CPA_abs_signedAdvantageReal_le_sum_hybridDiff_abs",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [IND_CPA_signedAdvantageReal_eq_sum_hybridDiff (encAlg' := encAlg') adversary q ga... | [
{
"name": "IND_CPA_signedAdvantageReal_eq_sum_hybridDiff",
"text": "/-- Generic telescoping identity for multi-query game-hopping:\nif `games 0` is the target IND-CPA experiment and `games q` has success probability `1/2`,\nthen the signed IND-CPA advantage is the sum of adjacent hybrid differences. -/\nthe... | [
{
"name": "IND_CPA_abs_signedAdvantageReal_le_sum_hybridDiff_abs",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 14,
"n_chars": 783,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 1,
"n_structural": 1,
"au... | 2 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -188,6 +188,21 @@
(Pr[= true | games 0]).toReal - (Pr[= true | games q]).toReal :=
Finset.sum_range_sub' _ q
+/-- Generic telescoping identity for multi-query game-hopping:
+if `games 0` is the target IND-CPA experiment and `games q` has success probability `1/2`,
+then the signed IND-CPA advantage is th... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_b8000a1791b8_12 | c8937222101d7682 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/CryptoFoundations/AsymmEncAlg/INDCPA/Oracle.lean | Oracle | 12 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 12 | 2 | [
{
"theorem_name": "IND_CPA_LR_hybridGame_q_evalDist_eq_left_of_MakesAtMostQueries",
"depth": 1,
"n_commands": 0,
"n_lines": 26,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n simp only [IND_CPA_LR_hybridGame, IND_CPA_LR_experiment, evalDist_bind]\n ... | [
{
"name": "IND_CPA_countedChallengeOracle_run_eq_of_select_eq",
"text": "private lemma IND_CPA_countedChallengeOracle_run_eq_of_select_eq\n (pk : PK) (select₁ select₂ : ℕ → M × M → M) (mm : M × M)\n (st : encAlg'.IND_CPA_CountedState)\n (h : select₁ st.2 mm = select₂ st.2 mm) :\n (IND_CPA_counte... | [
{
"name": "IND_CPA_hybridLR_counted_run_eq_of_le",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 17,
"n_chars": 727,
"n_subproofs": 0,
"n_tactics": 8,
"cyclomatic": 2,
"n_automation": 4,
"n_rewrites": 2,
"n_structural": 2,
"automation_only": ... | 1 | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | /-
Copyright (c) 2024 Devon Tuma. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Devon Tuma, Quang Dao
-/
import VCVio.CryptoFoundations.AsymmEncAlg.Defs
import VCVio.OracleComp.Coercions.SubSpec
import VCVio.OracleComp.ProbComp
import VCVio.OracleComp.QueryTracking.Qu... | @@ -116,6 +116,14 @@
set (cache', st.2 + 1)
return c
+private lemma IND_CPA_countedChallengeOracle_run_eq_of_select_eq
+ (pk : PK) (select₁ select₂ : ℕ → M × M → M) (mm : M × M)
+ (st : encAlg'.IND_CPA_CountedState)
+ (h : select₁ st.2 mm = select₂ st.2 mm) :
+ (IND_CPA_countedChallengeOracl... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_ee54a7d46fb0_0 | 44aa18d1a385d6cc | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | VCVio/ProgramLogic/Relational/Loom/Probabilistic.lean | Probabilistic | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 1 | 1 | [
{
"theorem_name": "rwpVal_le_one",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": "\n eRelWP_le_one_of_post_le_one oa ob _ (fun a b => (post a b).val_le_one)",
"n_chars": 74,
"n_subproofs": 0,
"n_tactic... | [
{
"name": "eRelWP_le_one_of_post_le_one",
"text": "private lemma eRelWP_le_one_of_post_le_one\n (oa : OracleComp spec₁ α) (ob : OracleComp spec₂ β)\n (post : α → β → ℝ≥0∞) (hpost : ∀ a b, post a b ≤ 1) :\n OracleComp.ProgramLogic.Relational.eRelWP oa ob post ≤ 1 := by\n unfold OracleComp.ProgramLo... | [
{
"name": "rwpVal_le_one",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 5,
"n_chars": 224,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"max_nesting":... | 1 | /-
Copyright (c) 2026 Quang Dao. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Quang Dao
-/
import ToMathlib.Control.Monad.RelWP
import VCVio.ProgramLogic.Unary.Loom.Probabilistic
import VCVio.ProgramLogic.Relational.Quantitative
/-!
# Probabilistic `RelWP` carrier ... | /-
Copyright (c) 2026 Quang Dao. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Quang Dao
-/
import ToMathlib.Control.Monad.RelWP
import VCVio.ProgramLogic.Unary.Loom.Probabilistic
import VCVio.ProgramLogic.Relational.Quantitative
/-!
# Probabilistic `RelWP` carrier ... | @@ -60,6 +60,17 @@
by `1`: any coupling has total mass `≤ 1`, and pointwise the
postcondition is `≤ 1`. -/
+private lemma eRelWP_le_one_of_post_le_one
+ (oa : OracleComp spec₁ α) (ob : OracleComp spec₂ β)
+ (post : α → β → ℝ≥0∞) (hpost : ∀ a b, post a b ≤ 1) :
+ OracleComp.ProgramLogic.Relational.eRelWP oa... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_8aa0c2cea80a_0 | 6dc90e38ae50eef1 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | LatticeCrypto/MLDSA/Concrete/NTT.lean | NTT | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 6 | 3 | [
{
"theorem_name": "ntt_surjective",
"depth": 1,
"n_commands": 0,
"n_lines": 7,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n letI : NeZero modulus := ⟨by norm_num [modulus]⟩\n letI : Fintype Coeff := by\n dsimp [Coeff]\n exact ZMod.fintype mo... | [
{
"name": "ntt_injective",
"text": "private theorem ntt_injective : Function.Injective ntt := by\n intro f g h\n have hInv := congrArg invNTT h\n simpa [invNTT_ntt] using hInv\n\n",
"fan_in": 3,
"n_lines": 6,
"n_chars": 141,
"n_subproofs": 1,
"n_tactics": 4,
"cyclomatic": 1,
"... | [
{
"name": "ntt_surjective",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 9,
"n_chars": 336,
"n_subproofs": 0,
"n_tactics": 7,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 2,
"automation_only": false,
"max_nesting"... | 1 | /-
Copyright (c) 2026 Quang Dao. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Quang Dao
-/
import LatticeCrypto.MLDSA.Arithmetic
import LatticeCrypto.Ring.NTTCert
import Mathlib.Algebra.BigOperators.Ring.Finset
/-!
# Concrete NTT for ML-DSA
Pure-Lean executable ker... | /-
Copyright (c) 2026 Quang Dao. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Quang Dao
-/
import LatticeCrypto.MLDSA.Arithmetic
import LatticeCrypto.Ring.NTTCert
import Mathlib.Algebra.BigOperators.Ring.Finset
/-!
# Concrete NTT for ML-DSA
Pure-Lean executable ker... | @@ -178,8 +178,19 @@
left_inv _ := rfl
right_inv fHat := by cases fHat; rfl
-private theorem ntt_surjective : Function.Surjective ntt := sorry
+private theorem ntt_injective : Function.Injective ntt := by
+ intro f g h
+ have hInv := congrArg invNTT h
+ simpa [invNTT_ntt] using hInv
+private theorem ntt_su... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_8aa0c2cea80a_1 | 50c553bb74abcb51 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | LatticeCrypto/MLDSA/Concrete/NTT.lean | NTT | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 6 | 1 | [
{
"theorem_name": "ntt_add_toRq",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": "\n LatticeCrypto.NTTCert.applyMatrix_add (backend := polyBackend) nttMatrix hadd_rq f g",
"n_chars": 87,
"n_subproofs": 0,
... | [
{
"name": "hadd_rq",
"text": "private theorem hadd_rq (f g : Rq) :\n polyBackend.coeff (f + g) = fun i => polyBackend.coeff f i + polyBackend.coeff g i := by\n funext i\n change ((LatticeCrypto.vectorNegacyclicRing Coeff ringDegree).add f g).get i = f.get i + g.get i\n simp\n\n",
"fan_in": 1,
... | [
{
"name": "ntt_add_toRq",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 5,
"n_chars": 211,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"max_nesting": ... | 1 | /-
Copyright (c) 2026 Quang Dao. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Quang Dao
-/
import LatticeCrypto.MLDSA.Arithmetic
import LatticeCrypto.Ring.NTTCert
import Mathlib.Algebra.BigOperators.Ring.Finset
/-!
# Concrete NTT for ML-DSA
Pure-Lean executable ker... | /-
Copyright (c) 2026 Quang Dao. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Quang Dao
-/
import LatticeCrypto.MLDSA.Arithmetic
import LatticeCrypto.Ring.NTTCert
import Mathlib.Algebra.BigOperators.Ring.Finset
/-!
# Concrete NTT for ML-DSA
Pure-Lean executable ker... | @@ -199,6 +199,12 @@
_ = ntt f := by rw [invNTT_ntt]
_ = fHat := hf
+private theorem hadd_rq (f g : Rq) :
+ polyBackend.coeff (f + g) = fun i => polyBackend.coeff f i + polyBackend.coeff g i := by
+ funext i
+ change ((LatticeCrypto.vectorNegacyclicRing Coeff ringDegree).add f g).get i = f.get i + g.ge... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_8aa0c2cea80a_2 | e8b108670af9e4b0 | lean | lean | github.com/Verified-zkEVM/VCV-io | 24fe01dbaf899b7bb2b19453ae2ada61b49b4255 | LatticeCrypto/MLDSA/Concrete/NTT.lean | NTT | 2 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 6 | 1 | [
{
"theorem_name": "ntt_sub_toRq",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": "\n LatticeCrypto.NTTCert.applyMatrix_sub (backend := polyBackend) nttMatrix hsub_rq f g",
"n_chars": 87,
"n_subproofs": 0,
... | [
{
"name": "hsub_rq",
"text": "private theorem hsub_rq (f g : Rq) :\n polyBackend.coeff (f - g) = fun i => polyBackend.coeff f i - polyBackend.coeff g i := by\n funext i\n change ((LatticeCrypto.vectorNegacyclicRing Coeff ringDegree).sub f g).get i = f.get i - g.get i\n simp\n\n",
"fan_in": 1,
... | [
{
"name": "ntt_sub_toRq",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 5,
"n_chars": 221,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"max_nesting": ... | 1 | /-
Copyright (c) 2026 Quang Dao. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Quang Dao
-/
import LatticeCrypto.MLDSA.Arithmetic
import LatticeCrypto.Ring.NTTCert
import Mathlib.Algebra.BigOperators.Ring.Finset
/-!
# Concrete NTT for ML-DSA
Pure-Lean executable ker... | /-
Copyright (c) 2026 Quang Dao. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Quang Dao
-/
import LatticeCrypto.MLDSA.Arithmetic
import LatticeCrypto.Ring.NTTCert
import Mathlib.Algebra.BigOperators.Ring.Finset
/-!
# Concrete NTT for ML-DSA
Pure-Lean executable ker... | @@ -205,6 +205,12 @@
change ((LatticeCrypto.vectorNegacyclicRing Coeff ringDegree).add f g).get i = f.get i + g.get i
simp
+private theorem hsub_rq (f g : Rq) :
+ polyBackend.coeff (f - g) = fun i => polyBackend.coeff f i - polyBackend.coeff g i := by
+ funext i
+ change ((LatticeCrypto.vectorNegacyclicRin... | {
"repo": "VCV-io",
"git_repo": "github.com/Verified-zkEVM/VCV-io",
"revision": "24fe01dbaf899b7bb2b19453ae2ada61b49b4255",
"lean_toolchain": "leanprover/lean4:v4.30.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-l... |
ablate_90d758f92412_0 | b464691a882d0e3c | lean | lean | github.com/septract/adler-proofs | e500f96af690e90eb185aa39caa798c07d671d82 | lean/Adler/BaseSpecs.lean | BaseSpecs | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "chunks_exact_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 10,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n unfold core.slice.Slice.chunks_exact\n simp [hn, WP.spec_ok]\n refine ⟨?_, ?_, ?_⟩\n · have := List.toChunksExact_fst... | [
{
"name": "List.toChunksExact_fst_length",
"text": "theorem List.toChunksExact_fst_length {α : Type} {n : Nat} (hn : 0 < n) (l : List α) :\n (List.toChunksExact n hn l).1.length = l.length / n := by\n unfold List.toChunksExact\n by_cases h : l.length < n\n · simp [h, Nat.div_eq_of_lt h]\n · simp [h]\... | [
{
"name": "chunks_exact_spec",
"fan_in": 0,
"n_deps_direct": 3,
"n_deps_transitive": 3,
"n_lines": 23,
"n_chars": 1081,
"n_subproofs": 2,
"n_tactics": 10,
"cyclomatic": 1,
"n_automation": 3,
"n_rewrites": 1,
"n_structural": 3,
"automation_only": false,
"max_ne... | 3 | import Adler.Funs
/-! # Base specs for Adler correctness proofs
Shared definitions and **value-tracking** `@[step]`-tagged specs for proofs
about the Aeneas-extracted `Adler32::compute`. Used by `Adler.Correctness`
to prove `compute_refines_compute_pure` (Theorem 1).
## What's here
* `MOD = 65521`, `CHUNK_SIZE = 22... | import Adler.Funs
/-! # Base specs for Adler correctness proofs
Shared definitions and **value-tracking** `@[step]`-tagged specs for proofs
about the Aeneas-extracted `Adler32::compute`. Used by `Adler.Correctness`
to prove `compute_refines_compute_pure` (Theorem 1).
## What's here
* `MOD = 65521`, `CHUNK_SIZE = 22... | @@ -56,6 +56,21 @@
core.slice.Slice.iter s ⦃ iter => iter = ⟨s, 0⟩ ⦄ := by
unfold core.slice.Slice.iter; simp [WP.spec_ok]
+theorem List.toChunksExact_fst_length {α : Type} {n : Nat} (hn : 0 < n) (l : List α) :
+ (List.toChunksExact n hn l).1.length = l.length / n := by
+ unfold List.toChunksExact
+ by_c... | {
"repo": "adler-proofs",
"git_repo": "github.com/septract/adler-proofs",
"revision": "e500f96af690e90eb185aa39caa798c07d671d82",
"lean_toolchain": null,
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemmas-leaves-all... |
ablate_90d758f92412_1 | bb165801ff15e632 | lean | lean | github.com/septract/adler-proofs | e500f96af690e90eb185aa39caa798c07d671d82 | lean/Adler/BaseSpecs.lean | BaseSpecs | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "U32X4_from_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 10,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n unfold algo.U32X4.from\n simp [lift, core.convert.num.FromU32U8.from]\n step\n step\n step\n step\n simp_all [Array.... | [
{
"name": "u32_of_u8_setWidth_val",
"text": "/-- For any `b : U8`, the U32 obtained by widening `b.bv` to 32 bits has `.val = b.val`. -/\nprivate theorem u32_of_u8_setWidth_val (b : Std.U8) :\n ((BitVec.setWidth 32 b.bv : BitVec 32)#uscalar : Std.U32).val = b.val := by\n show (BitVec.setWidth 32 b.bv).t... | [
{
"name": "U32X4_from_spec",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 20,
"n_chars": 706,
"n_subproofs": 0,
"n_tactics": 10,
"cyclomatic": 1,
"n_automation": 2,
"n_rewrites": 1,
"n_structural": 1,
"automation_only": false,
"max_nesti... | 1 | import Adler.Funs
/-! # Base specs for Adler correctness proofs
Shared definitions and **value-tracking** `@[step]`-tagged specs for proofs
about the Aeneas-extracted `Adler32::compute`. Used by `Adler.Correctness`
to prove `compute_refines_compute_pure` (Theorem 1).
## What's here
* `MOD = 65521`, `CHUNK_SIZE = 22... | import Adler.Funs
/-! # Base specs for Adler correctness proofs
Shared definitions and **value-tracking** `@[step]`-tagged specs for proofs
about the Aeneas-extracted `Adler32::compute`. Used by `Adler.Correctness`
to prove `compute_refines_compute_pure` (Theorem 1).
## What's here
* `MOD = 65521`, `CHUNK_SIZE = 22... | @@ -271,6 +271,18 @@
WP.spec_ok]
simp_all [Std.Array.set]
+/-- For any `b : U8`, the U32 obtained by widening `b.bv` to 32 bits has `.val = b.val`. -/
+private theorem u32_of_u8_setWidth_val (b : Std.U8) :
+ ((BitVec.setWidth 32 b.bv : BitVec 32)#uscalar : Std.U32).val = b.val := by
+ show (BitVec.set... | {
"repo": "adler-proofs",
"git_repo": "github.com/septract/adler-proofs",
"revision": "e500f96af690e90eb185aa39caa798c07d671d82",
"lean_toolchain": null,
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemmas-leaves-all... |
ablate_54060d8c7025_0 | 3f2a6e03e2015a5d | lean | lean | github.com/septract/adler-proofs | e500f96af690e90eb185aa39caa798c07d671d82 | lean/Adler/Properties.lean | Properties | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 9 | 1 | [
{
"theorem_name": "from_checksum_checksum",
"depth": 1,
"n_commands": 0,
"n_lines": 15,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n unfold Adler32.from_checksum Adler32.checksum\n simp [lift]\n step*\n -- Lift U32 equality to BitVec equality (U... | [
{
"name": "bv_split_combine",
"text": "/-- Reusable bv-only lemma: combining low and high 16-bit halves reconstructs\n the original 32-bit value. Proven once by bv_decide on a clean goal. -/\nprivate theorem bv_split_combine (sbv : BitVec 32) :\n BitVec.setWidth 32 (BitVec.setWidth 16 (sbv >>> 16)) <<... | [
{
"name": "from_checksum_checksum",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 23,
"n_chars": 950,
"n_subproofs": 0,
"n_tactics": 11,
"cyclomatic": 1,
"n_automation": 2,
"n_rewrites": 2,
"n_structural": 1,
"automation_only": false,
"ma... | 1 | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | @@ -26,12 +26,33 @@
open Aeneas Aeneas.Std Result
+/-- Reusable bv-only lemma: combining low and high 16-bit halves reconstructs
+ the original 32-bit value. Proven once by bv_decide on a clean goal. -/
+private theorem bv_split_combine (sbv : BitVec 32) :
+ BitVec.setWidth 32 (BitVec.setWidth 16 (sbv >>> 16... | {
"repo": "adler-proofs",
"git_repo": "github.com/septract/adler-proofs",
"revision": "e500f96af690e90eb185aa39caa798c07d671d82",
"lean_toolchain": null,
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemmas-leaves-all... |
ablate_54060d8c7025_1 | f296173580eb3c03 | lean | lean | github.com/septract/adler-proofs | e500f96af690e90eb185aa39caa798c07d671d82 | lean/Adler/Properties.lean | Properties | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 9 | 1 | [
{
"theorem_name": "hasher_write_eq_write_slice",
"depth": 1,
"n_commands": 0,
"n_lines": 8,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rfl\n\n#print axioms new_checksum_eq_one\n#print axioms default_eq_new\n#print axioms clone_eq_self\n#print axi... | [
{
"name": "new_checksum_eq_one",
"text": "/-- The initial Adler-32 state has checksum 1, matching RFC 1950 §8. -/\ntheorem new_checksum_eq_one :\n (do let s ← Adler32.new; Adler32.checksum s) = ok 1#u32 := by\n unfold Adler32.new Adler32.Insts.CoreDefaultDefault.default Adler32.checksum\n simp [lift]\n... | [
{
"name": "hasher_write_eq_write_slice",
"fan_in": 0,
"n_deps_direct": 4,
"n_deps_transitive": 4,
"n_lines": 26,
"n_chars": 1029,
"n_subproofs": 0,
"n_tactics": 7,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": true,
... | 4 | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | @@ -26,6 +26,13 @@
open Aeneas Aeneas.Std Result
+/-- The initial Adler-32 state has checksum 1, matching RFC 1950 §8. -/
+theorem new_checksum_eq_one :
+ (do let s ← Adler32.new; Adler32.checksum s) = ok 1#u32 := by
+ unfold Adler32.new Adler32.Insts.CoreDefaultDefault.default Adler32.checksum
+ simp [lift]
... | {
"repo": "adler-proofs",
"git_repo": "github.com/septract/adler-proofs",
"revision": "e500f96af690e90eb185aa39caa798c07d671d82",
"lean_toolchain": null,
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemmas-leaves-all... |
ablate_54060d8c7025_2 | 55f76cf74b0ecefc | lean | lean | github.com/septract/adler-proofs | e500f96af690e90eb185aa39caa798c07d671d82 | lean/Adler/Properties.lean | Properties | 2 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 9 | 1 | [
{
"theorem_name": "compute_loop0_spec_empty",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [compute_loop0_done i iter h a b a_vec b_vec]\n simp [WP.spec_ok]",
"n_chars": 74,
"n_subproofs": 0,
... | [
{
"name": "compute_loop0_done",
"text": "/-- `compute_loop0` on an empty chunks-iter returns its `(b, a_vec, b_vec)` unchanged. -/\ntheorem compute_loop0_done (i : Std.Usize) (iter : core.slice.iter.ChunksExact Std.U8)\n (h : iter.chunks = []) (a b : Std.U32) (a_vec b_vec : algo.U32X4) :\n compute_loo... | [
{
"name": "compute_loop0_spec_empty",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 8,
"n_chars": 327,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 1,
"n_structural": 0,
"automation_only": false,
"ma... | 1 | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | @@ -50,10 +50,24 @@
unfold algo.Adler32.compute_loop0_loop0
simp [core.slice.iter.IteratorChunksExact.next, h]
+/-- `compute_loop0` on an empty chunks-iter returns its `(b, a_vec, b_vec)` unchanged. -/
+theorem compute_loop0_done (i : Std.Usize) (iter : core.slice.iter.ChunksExact Std.U8)
+ (h : iter.chunks ... | {
"repo": "adler-proofs",
"git_repo": "github.com/septract/adler-proofs",
"revision": "e500f96af690e90eb185aa39caa798c07d671d82",
"lean_toolchain": null,
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemmas-leaves-all... |
ablate_54060d8c7025_3 | 050131f00c28a461 | lean | lean | github.com/septract/adler-proofs | e500f96af690e90eb185aa39caa798c07d671d82 | lean/Adler/Properties.lean | Properties | 3 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 9 | 1 | [
{
"theorem_name": "compute_loop0_loop0_spec_empty",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [compute_loop0_loop0_done iter h a_vec b_vec]\n simp [WP.spec_ok]",
"n_chars": 74,
"n_subproofs"... | [
{
"name": "compute_loop0_loop0_done",
"text": "/-- `compute_loop0_loop0` on an empty chunks-iter returns its `(a_vec, b_vec)` unchanged. -/\ntheorem compute_loop0_loop0_done (iter : core.slice.iter.ChunksExact Std.U8)\n (h : iter.chunks = []) (a_vec b_vec : algo.U32X4) :\n compute_loop0_loop0 iter a_v... | [
{
"name": "compute_loop0_loop0_spec_empty",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 8,
"n_chars": 298,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 1,
"n_structural": 0,
"automation_only": false,
... | 1 | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | @@ -43,6 +43,13 @@
unfold algo.Adler32.compute_loop1
simp [core.slice.iter.IteratorChunksExact.next, h]
+/-- `compute_loop0_loop0` on an empty chunks-iter returns its `(a_vec, b_vec)` unchanged. -/
+theorem compute_loop0_loop0_done (iter : core.slice.iter.ChunksExact Std.U8)
+ (h : iter.chunks = []) (a_vec b... | {
"repo": "adler-proofs",
"git_repo": "github.com/septract/adler-proofs",
"revision": "e500f96af690e90eb185aa39caa798c07d671d82",
"lean_toolchain": null,
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemmas-leaves-all... |
ablate_54060d8c7025_4 | e6a51af88d34468e | lean | lean | github.com/septract/adler-proofs | e500f96af690e90eb185aa39caa798c07d671d82 | lean/Adler/Properties.lean | Properties | 4 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 9 | 1 | [
{
"theorem_name": "compute_loop1_spec_empty",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [compute_loop1_done iter h a_vec b_vec]\n simp [WP.spec_ok]",
"n_chars": 68,
"n_subproofs": 0,
"n_... | [
{
"name": "compute_loop1_done",
"text": "/-- `compute_loop1` on an empty chunks-iter returns its `(a_vec, b_vec)` unchanged. -/\ntheorem compute_loop1_done (iter : core.slice.iter.ChunksExact Std.U8)\n (h : iter.chunks = []) (a_vec b_vec : algo.U32X4) :\n compute_loop1 iter a_vec b_vec = ok (a_vec, b_... | [
{
"name": "compute_loop1_spec_empty",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 8,
"n_chars": 280,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 1,
"n_structural": 0,
"automation_only": false,
"ma... | 1 | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | @@ -36,6 +36,13 @@
unfold algo.Adler32.compute_loop4
simp [core.slice.iter.IteratorSliceIter.next, show ¬ iter.i < iter.slice.val.length from Nat.not_lt.mpr h]
+/-- `compute_loop1` on an empty chunks-iter returns its `(a_vec, b_vec)` unchanged. -/
+theorem compute_loop1_done (iter : core.slice.iter.ChunksExact ... | {
"repo": "adler-proofs",
"git_repo": "github.com/septract/adler-proofs",
"revision": "e500f96af690e90eb185aa39caa798c07d671d82",
"lean_toolchain": null,
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemmas-leaves-all... |
ablate_54060d8c7025_5 | fecce8ac31cf9497 | lean | lean | github.com/septract/adler-proofs | e500f96af690e90eb185aa39caa798c07d671d82 | lean/Adler/Properties.lean | Properties | 5 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 9 | 1 | [
{
"theorem_name": "compute_loop4_spec_done",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [compute_loop4_done iter h a b]\n simp [WP.spec_ok]",
"n_chars": 60,
"n_subproofs": 0,
"n_tactics":... | [
{
"name": "compute_loop4_done",
"text": "/-- `compute_loop4` on an iter past-end returns the state unchanged. -/\ntheorem compute_loop4_done (iter : core.slice.iter.Iter Std.U8)\n (h : iter.i ≥ iter.slice.val.length) (a b : Std.U32) :\n compute_loop4 iter a b = ok (a, b) := by\n unfold algo.Adler32.c... | [
{
"name": "compute_loop4_spec_done",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 14,
"n_chars": 607,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 1,
"n_structural": 0,
"automation_only": false,
"ma... | 1 | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | import Adler.Funs
/-! # Easy properties of the extracted `Adler32` API
This file collects the small definitional and roundtrip properties of the
extracted `Adler32` API that don't require any nontrivial loop reasoning.
The substantive theorems (panic-freedom, refinement, spec equality) live in
`PanicFreedom.lean` and... | @@ -29,6 +29,13 @@
open algo.Adler32 (compute_loop0 compute_loop0_loop0 compute_loop1
compute_loop2 compute_loop3 compute_loop4)
+/-- `compute_loop4` on an iter past-end returns the state unchanged. -/
+theorem compute_loop4_done (iter : core.slice.iter.Iter Std.U8)
+ (h : iter.i ≥ iter.slice.... | {
"repo": "adler-proofs",
"git_repo": "github.com/septract/adler-proofs",
"revision": "e500f96af690e90eb185aa39caa798c07d671d82",
"lean_toolchain": null,
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemmas-leaves-all... |
ablate_2de4145e086b_0 | 24ec79d1b38a7deb | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Array.lean | Array | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "getElem!_setSlice!_same",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases h <;> simp_lists [getElem!_setSlice!_prefix, getElem!_setSlice!_suffix]",
"n_chars": 83,
"n_subproofs... | [
{
"name": "getElem!_setSlice!_suffix",
"text": "theorem getElem!_setSlice!_suffix {α} [Inhabited α]\n (s : Array α) (s' : List α) (i j : ℕ) (h : i + s'.length ≤ j) :\n (s.setSlice! i s')[j]! = s[j]! := by\n simp only [setSlice!, ← getElem!_toList]\n simp_lists\n\n",
"fan_in": 1,
"n_lines": 7,
... | [
{
"name": "getElem!_setSlice!_same",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 2,
"n_lines": 7,
"n_chars": 273,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 3,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max... | 2 | import Aeneas.Data.List
import Aeneas.Tactic.Simp.SimpIfs
namespace Array
local macro_rules
| `(tactic| get_elem_tactic) => `(tactic| grind)
attribute [-simp] List.getElem!_eq_getElem?_getD
attribute [scalar_tac_simps, simp_lists_safe] Array.size
def setSlice! {α} (a : Array α) (i : ℕ) (s : List α) : Array α :=
... | import Aeneas.Data.List
import Aeneas.Tactic.Simp.SimpIfs
namespace Array
local macro_rules
| `(tactic| get_elem_tactic) => `(tactic| grind)
attribute [-simp] List.getElem!_eq_getElem?_getD
attribute [scalar_tac_simps, simp_lists_safe] Array.size
def setSlice! {α} (a : Array α) (i : ℕ) (s : List α) : Array α :=
... | @@ -44,10 +44,17 @@
simp only [setSlice!, ← getElem!_toList]
simp_lists
+theorem getElem!_setSlice!_suffix {α} [Inhabited α]
+ (s : Array α) (s' : List α) (i j : ℕ) (h : i + s'.length ≤ j) :
+ (s.setSlice! i s')[j]! = s[j]! := by
+ simp only [setSlice!, ← getElem!_toList]
+ simp_lists
+
@[simp_lists_safe]
... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_2de4145e086b_1 | 7373371ab305977e | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Array.lean | Array | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "getElem_setSlice!_same",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases h.1 <;> simp_lists [getElem_setSlice!_prefix, getElem_setSlice!_suffix]",
"n_chars": 83,
"n_subproofs"... | [
{
"name": "getElem_setSlice!_suffix",
"text": "theorem getElem_setSlice!_suffix {α}\n (s : Array α) (s' : List α) (i j : ℕ) (h : i + s'.length ≤ j ∧ j < s.size) :\n (s.setSlice! i s')[j] = s[j] := by\n simp only [setSlice!, ← getElem_toList]\n simp_lists\n\n",
"fan_in": 1,
"n_lines": 7,
"n_c... | [
{
"name": "getElem_setSlice!_same",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 2,
"n_lines": 7,
"n_chars": 272,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 3,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_... | 2 | import Aeneas.Data.List
import Aeneas.Tactic.Simp.SimpIfs
namespace Array
local macro_rules
| `(tactic| get_elem_tactic) => `(tactic| grind)
attribute [-simp] List.getElem!_eq_getElem?_getD
attribute [scalar_tac_simps, simp_lists_safe] Array.size
def setSlice! {α} (a : Array α) (i : ℕ) (s : List α) : Array α :=
... | import Aeneas.Data.List
import Aeneas.Tactic.Simp.SimpIfs
namespace Array
local macro_rules
| `(tactic| get_elem_tactic) => `(tactic| grind)
attribute [-simp] List.getElem!_eq_getElem?_getD
attribute [scalar_tac_simps, simp_lists_safe] Array.size
def setSlice! {α} (a : Array α) (i : ℕ) (s : List α) : Array α :=
... | @@ -69,10 +69,17 @@
simp only [setSlice!, ← getElem_toList]
simp_lists
+theorem getElem_setSlice!_suffix {α}
+ (s : Array α) (s' : List α) (i j : ℕ) (h : i + s'.length ≤ j ∧ j < s.size) :
+ (s.setSlice! i s')[j] = s[j] := by
+ simp only [setSlice!, ← getElem_toList]
+ simp_lists
+
@[simp_lists_safe]
theor... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_15eee0f0923e_0 | f620f896de8d71c7 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/CoreConvertNum.lean | CoreConvertNum | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 2 | 19 | [
{
"theorem_name": "FromUsizeU8.from_val_eq",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n simp only [FromUsizeU8.from]; apply BitVec.setWidth_toNat_le\n cases System.Platform.numBits_eq <;> simp [*]",
... | [
{
"name": "BitVec.setWidth_toNat_le",
"text": "private theorem BitVec.setWidth_toNat_le (m : Nat) (x : BitVec n) (h : n ≤ m) :\n (x.setWidth m).toNat = x.toNat := by\n have : x.toNat < 2^n := by cases x; simp\n simp only [BitVec.toNat_setWidth]\n have : 2 ^ n ≤ 2 ^m := by apply Nat.pow_le_pow_right <;> ... | [
{
"name": "FromUsizeU8.from_val_eq",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 6,
"n_chars": 257,
"n_subproofs": 0,
"n_tactics": 5,
"cyclomatic": 3,
"n_automation": 2,
"n_rewrites": 0,
"n_structural": 2,
"automation_only": false,
"max... | 1 | import Lean
import Lean.Meta.Tactic.Simp
import Init.Data.List.Basic
import Mathlib.Tactic.Linarith
import Aeneas.Std.Scalar.Core
import Aeneas.Std.Scalar.Notations
import Aeneas.Std.Scalar.Elab
import Aeneas.Std.Scalar.Casts
import Aeneas.Std.Core.Result
import Aeneas.Std.Array.Array
import Aeneas.Tactic.Solver.Scalar... | import Lean
import Lean.Meta.Tactic.Simp
import Init.Data.List.Basic
import Mathlib.Tactic.Linarith
import Aeneas.Std.Scalar.Core
import Aeneas.Std.Scalar.Notations
import Aeneas.Std.Scalar.Elab
import Aeneas.Std.Scalar.Casts
import Aeneas.Std.Core.Result
import Aeneas.Std.Array.Array
import Aeneas.Tactic.Solver.Scalar... | @@ -110,62 +110,93 @@
def FromI128I64.from (x : I64) : I128 := ⟨ x.bv.signExtend _ ⟩
def FromI128I128.from (x : I128) : I128 := ⟨ x.bv.signExtend _ ⟩
+private theorem BitVec.setWidth_toNat_le (m : Nat) (x : BitVec n) (h : n ≤ m) :
+ (x.setWidth m).toNat = x.toNat := by
+ have : x.toNat < 2^n := by cases x; simp
+... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_15eee0f0923e_1 | 4ea3de566b4a7096 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/CoreConvertNum.lean | CoreConvertNum | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 2 | 13 | [
{
"theorem_name": "FromIsizeI8.from_val_eq",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases System.Platform.numBits_eq <;>\n simp only [FromIsizeI8.from, IScalar.val, BitVec.signExtend] <;> simp <;>\n... | [
{
"name": "bmod_pow2_eq_of_inBounds'",
"text": "private theorem bmod_pow2_eq_of_inBounds' (n : ℕ) (x : ℤ) (h : 0 < n ∧ -2 ^ (n - 1) ≤ x ∧ x < 2 ^ (n - 1)) :\n x.bmod (2 ^ n) = x := by\n have hn : n - 1 + 1 = n := by omega\n have := Arith.Int.bmod_pow2_eq_of_inBounds (n - 1) x (by omega) (by simp [*])\n ... | [
{
"name": "FromIsizeI8.from_val_eq",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 7,
"n_chars": 319,
"n_subproofs": 0,
"n_tactics": 7,
"cyclomatic": 5,
"n_automation": 2,
"n_rewrites": 0,
"n_structural": 2,
"automation_only": false,
"max... | 1 | import Lean
import Lean.Meta.Tactic.Simp
import Init.Data.List.Basic
import Mathlib.Tactic.Linarith
import Aeneas.Std.Scalar.Core
import Aeneas.Std.Scalar.Notations
import Aeneas.Std.Scalar.Elab
import Aeneas.Std.Scalar.Casts
import Aeneas.Std.Core.Result
import Aeneas.Std.Array.Array
import Aeneas.Tactic.Solver.Scalar... | import Lean
import Lean.Meta.Tactic.Simp
import Init.Data.List.Basic
import Mathlib.Tactic.Linarith
import Aeneas.Std.Scalar.Core
import Aeneas.Std.Scalar.Notations
import Aeneas.Std.Scalar.Elab
import Aeneas.Std.Scalar.Casts
import Aeneas.Std.Core.Result
import Aeneas.Std.Array.Array
import Aeneas.Tactic.Solver.Scalar... | @@ -239,14 +239,30 @@
@[local simp] private theorem zero_lt_size_num_bits : 0 < System.Platform.numBits := by
cases System.Platform.numBits_eq <;> simp [*]
+private theorem bmod_pow2_eq_of_inBounds' (n : ℕ) (x : ℤ) (h : 0 < n ∧ -2 ^ (n - 1) ≤ x ∧ x < 2 ^ (n - 1)) :
+ x.bmod (2 ^ n) = x := by
+ have hn : n - 1 +... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_538beb2b6fc5_0 | de224f834ac63bc9 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/List/List.lean | List | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "right_length_eq_append_eq",
"depth": 1,
"n_commands": 0,
"n_lines": 10,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have := left_length_eq_append_eq l1 l2 l1' l2'\n constructor <;> intro heq2 <;>\n have : l1.length + l2.length... | [
{
"name": "left_length_eq_append_eq",
"text": "theorem left_length_eq_append_eq (l1 l2 l1' l2' : List α) (heq : l1.length = l1'.length) :\n l1 ++ l2 = l1' ++ l2' ↔ l1 = l1' ∧ l2 = l2' := by\n revert l1'\n induction l1\n . intro l1'; cases l1' <;> simp [*]\n . intro l1'; cases l1' <;> simp_all\n\n",
... | [
{
"name": "right_length_eq_append_eq",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 13,
"n_chars": 476,
"n_subproofs": 3,
"n_tactics": 12,
"cyclomatic": 4,
"n_automation": 5,
"n_rewrites": 0,
"n_structural": 3,
"automation_only": false,
... | 1 | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | @@ -160,8 +160,24 @@
intro i
cases i <;> simp_all
+theorem left_length_eq_append_eq (l1 l2 l1' l2' : List α) (heq : l1.length = l1'.length) :
+ l1 ++ l2 = l1' ++ l2' ↔ l1 = l1' ∧ l2 = l2' := by
+ revert l1'
+ induction l1
+ . intro l1'; cases l1' <;> simp [*]
+ . intro l1'; cases l1' <;> simp_all
+
theore... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_538beb2b6fc5_1 | 65c6eaf0933ac3bc | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/List/List.lean | List | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "length_flatten_set_eq_disj",
"depth": 1,
"n_commands": 0,
"n_lines": 6,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases h: (ls.length ≤ i : Bool) <;> simp_all only [decide_eq_false_iff_not, not_le, decide_eq_true_eq, true_or]\... | [
{
"name": "length_flatten_set_eq",
"text": "theorem length_flatten_set_eq {α : Type u} (ls : List (List α)) (i : Nat) (x : List α)\n (h1 : i < ls.length) :\n (ls.set i x).flatten.length + (ls[i]!).length = ls.flatten.length + x.length := by\n revert i\n induction ls <;> intro i <;> simp_all\n cases i <... | [
{
"name": "length_flatten_set_eq_disj",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 11,
"n_chars": 537,
"n_subproofs": 0,
"n_tactics": 7,
"cyclomatic": 4,
"n_automation": 3,
"n_rewrites": 1,
"n_structural": 1,
"automation_only": false,
... | 1 | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | @@ -339,11 +339,29 @@
:= by
simp [*]
+theorem length_flatten_set_eq {α : Type u} (ls : List (List α)) (i : Nat) (x : List α)
+ (h1 : i < ls.length) :
+ (ls.set i x).flatten.length + (ls[i]!).length = ls.flatten.length + x.length := by
+ revert i
+ induction ls <;> intro i <;> simp_all
+ cases i <;> simp_al... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_538beb2b6fc5_2 | 018d78a6f71d5b1d | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/List/List.lean | List | 2 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "getElem!_range",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n simp only [List.range_eq_range']\n rw [getElem!_range']\n simp only [zero_add]",
"n_chars": 84,
"n_subproofs": 0,
... | [
{
"name": "getElem!_range'",
"text": "theorem getElem!_range' (i start n: ℕ) :\n (List.range' start n)[i]! = if i < n then start + i else 0 := by\n have := List.getElem?_range'_if i start n\n simp_all\n split <;> simp\n\n",
"fan_in": 1,
"n_lines": 7,
"n_chars": 183,
"n_subproofs": 1,
... | [
{
"name": "getElem!_range",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 7,
"n_chars": 170,
"n_subproofs": 0,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 2,
"n_rewrites": 1,
"n_structural": 0,
"automation_only": false,
"max_nesting"... | 1 | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | @@ -443,6 +443,12 @@
simp_all
ring_nf
+theorem getElem!_range' (i start n: ℕ) :
+ (List.range' start n)[i]! = if i < n then start + i else 0 := by
+ have := List.getElem?_range'_if i start n
+ simp_all
+ split <;> simp
+
@[simp] theorem getElem!_range'_lt (i start n: ℕ) (h : i < n) :
(List.range... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_538beb2b6fc5_3 | 501cc719dc7d6605 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/List/List.lean | List | 3 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 2 | [
{
"theorem_name": "eq_iff_forall_eq_getElem!",
"depth": 1,
"n_commands": 0,
"n_lines": 14,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n constructor\n . simp +contextual only [getElem!_eq_getElem?_getD, getElem?_eq_getElem, Option.getD_some,\n i... | [
{
"name": "eq_iff_forall_eq_getElem?",
"text": "theorem eq_iff_forall_eq_getElem? {α} (l0 l1 : List α) :\n l0 = l1 ↔ ∀ (i : Nat), l0[i]? = l1[i]? := by\n revert l1\n induction l0 <;> intro l1\n . constructor\n . simp +contextual\n . intro hi\n have := hi 0\n simp at this\n rw [this]... | [
{
"name": "eq_iff_forall_eq_getElem!",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 2,
"n_lines": 17,
"n_chars": 648,
"n_subproofs": 0,
"n_tactics": 14,
"cyclomatic": 2,
"n_automation": 6,
"n_rewrites": 1,
"n_structural": 3,
"automation_only": false,
... | 1 | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | @@ -463,12 +463,48 @@
end
+theorem eq_iff_forall_eq_getElem? {α} (l0 l1 : List α) :
+ l0 = l1 ↔ ∀ (i : Nat), l0[i]? = l1[i]? := by
+ revert l1
+ induction l0 <;> intro l1
+ . constructor
+ . simp +contextual
+ . intro hi
+ have := hi 0
+ simp at this
+ rw [this]
+ . rename_i hd l0 hind
+ ... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_538beb2b6fc5_4 | 2275f603ff0e4e32 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/List/List.lean | List | 4 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 2 | [
{
"theorem_name": "eq_iff_forall_eq_getElem!",
"depth": 1,
"n_commands": 0,
"n_lines": 14,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n constructor\n . simp +contextual only [getElem!_eq_getElem?_getD, getElem?_eq_getElem, Option.getD_some,\n i... | [
{
"name": "eq_iff_forall_eq_getElem?",
"text": "theorem eq_iff_forall_eq_getElem? {α} (l0 l1 : List α) :\n l0 = l1 ↔ ∀ (i : Nat), l0[i]? = l1[i]? := by\n revert l1\n induction l0 <;> intro l1\n . constructor\n . simp +contextual\n . intro hi\n have := hi 0\n simp at this\n rw [this]... | [
{
"name": "setSlice!_drop",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 10,
"n_chars": 284,
"n_subproofs": 0,
"n_tactics": 8,
"cyclomatic": 3,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_nesting... | 1 | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | /- Complementary functions and lemmas for the `List` type -/
import Mathlib.Data.List.GetD
import Aeneas.Tactic.Solver.ScalarTac
import AeneasMeta.Utils
import Aeneas.Tactic.Simp.SimpLemmas
import Aeneas.Data.Nat
import Aeneas.Tactic.Simp.SimpLists.Init
import Aeneas.Std.Primitives
import Aeneas.Tactic.Simp.SimpLists.... | @@ -463,6 +463,33 @@
end
+theorem eq_iff_forall_eq_getElem? {α} (l0 l1 : List α) :
+ l0 = l1 ↔ ∀ (i : Nat), l0[i]? = l1[i]? := by
+ revert l1
+ induction l0 <;> intro l1
+ . constructor
+ . simp +contextual
+ . intro hi
+ have := hi 0
+ simp at this
+ rw [this]
+ . rename_i hd l0 hind
+ ... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_4ab90ff8b902_0 | 6b00789eae8528db | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Simp/SimpScalar/Lemmas.lean | Lemmas | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 2 | 1 | [
{
"theorem_name": "Nat.pow_mod_pow_eq_self'",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n apply Nat.pow_mod_pow_eq_self <;> grind",
"n_chars": 45,
"n_subproofs": 0,
"n_tactics": 3,
"cyclom... | [
{
"name": "Nat.pow_mod_pow_eq_self",
"text": "theorem Nat.pow_mod_pow_eq_self (a n m : Nat) (ha : 1 < a) (h : n < m) :\n a ^ n % a ^ m = a ^ n := by\n have : a ^ n < a ^ m := by simp_scalar\n simp_scalar\n\n",
"fan_in": 1,
"n_lines": 6,
"n_chars": 159,
"n_subproofs": 1,
"n_tactics": 3... | [
{
"name": "Nat.pow_mod_pow_eq_self'",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 6,
"n_chars": 164,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 2,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"ma... | 1 | import Aeneas.Tactic.Simp.SimpScalar.SimpScalar
import Aeneas.Tactic.Simproc.ReduceNat
section
open Aeneas Utils Lean Meta
initialize registerTraceClass `ReduceLog2
-- TODO: the pattern `Nat.log2 (@OfNat.ofNat _ _ _)` doesn't work
simproc Nat.reduceLog2 (Nat.log2 _) := fun e => do
match e.consumeMData.g... | import Aeneas.Tactic.Simp.SimpScalar.SimpScalar
import Aeneas.Tactic.Simproc.ReduceNat
section
open Aeneas Utils Lean Meta
initialize registerTraceClass `ReduceLog2
-- TODO: the pattern `Nat.log2 (@OfNat.ofNat _ _ _)` doesn't work
simproc Nat.reduceLog2 (Nat.log2 _) := fun e => do
match e.consumeMData.g... | @@ -54,9 +54,15 @@
have : a < a ^ n := by simp_scalar
simp_scalar
+theorem Nat.pow_mod_pow_eq_self (a n m : Nat) (ha : 1 < a) (h : n < m) :
+ a ^ n % a ^ m = a ^ n := by
+ have : a ^ n < a ^ m := by simp_scalar
+ simp_scalar
+
@[simp_scalar_safe]
theorem Nat.pow_mod_pow_eq_self' (a n m : Nat) (h : 1 < a ∧ ... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_4ab90ff8b902_1 | ed8d0c70082d8121 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Simp/SimpScalar/Lemmas.lean | Lemmas | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 2 | 1 | [
{
"theorem_name": "Nat.one_mod_pow_eq_one'",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n apply Nat.one_mod_pow_eq_one <;> omega",
"n_chars": 44,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomat... | [
{
"name": "Nat.one_mod_pow_eq_one",
"text": "theorem Nat.one_mod_pow_eq_one {a n : Nat} (ha : 1 < a) (hn : 1 ≤ n) : 1 % a^n = 1 := by\n have : 1 < a ^n := by simp_scalar\n simp_scalar\n\n",
"fan_in": 1,
"n_lines": 5,
"n_chars": 142,
"n_subproofs": 1,
"n_tactics": 3,
"cyclomatic": 1... | [
{
"name": "Nat.one_mod_pow_eq_one'",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 13,
"n_chars": 376,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 2,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"ma... | 1 | import Aeneas.Tactic.Simp.SimpScalar.SimpScalar
import Aeneas.Tactic.Simproc.ReduceNat
section
open Aeneas Utils Lean Meta
initialize registerTraceClass `ReduceLog2
-- TODO: the pattern `Nat.log2 (@OfNat.ofNat _ _ _)` doesn't work
simproc Nat.reduceLog2 (Nat.log2 _) := fun e => do
match e.consumeMData.g... | import Aeneas.Tactic.Simp.SimpScalar.SimpScalar
import Aeneas.Tactic.Simproc.ReduceNat
section
open Aeneas Utils Lean Meta
initialize registerTraceClass `ReduceLog2
-- TODO: the pattern `Nat.log2 (@OfNat.ofNat _ _ _)` doesn't work
simproc Nat.reduceLog2 (Nat.log2 _) := fun e => do
match e.consumeMData.g... | @@ -113,8 +113,13 @@
theorem Nat.one_lt_pow'' {a n : Nat} (h : 1 < a ∧ 1 ≤ n) : 1 < a^n := by
apply Nat.one_lt_pow <;> omega
+theorem Nat.one_mod_pow_eq_one {a n : Nat} (ha : 1 < a) (hn : 1 ≤ n) : 1 % a^n = 1 := by
+ have : 1 < a ^n := by simp_scalar
+ simp_scalar
+
@[simp_scalar_safe]
-theorem Nat.one_mod_pow... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_0 | 788b38a1630507e1 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 1 | [
{
"theorem_name": "Int.gcd_mod_same",
"depth": 1,
"n_commands": 0,
"n_lines": 11,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have h1 : a % b = a - b * (a / b) := by\n have heq := Int.mul_ediv_add_emod a b\n linarith\n have h2 := Int.gcd_ad... | [
{
"name": "Int.gcd_add_mul_self",
"text": "theorem Int.gcd_add_mul_self (a b k : ℤ) :\n Int.gcd a (b + k * a) = Int.gcd a b := by\n apply Eq.symm\n have h := @Int.gcd_greatest a (b + k * a) (Int.gcd a b) (by simp)\n simp only [Nat.cast_inj] at h\n apply h\n . apply Int.gcd_dvd_left\n . apply dvd_add\... | [
{
"name": "Int.gcd_mod_same",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 14,
"n_chars": 368,
"n_subproofs": 3,
"n_tactics": 13,
"cyclomatic": 1,
"n_automation": 3,
"n_rewrites": 5,
"n_structural": 0,
"automation_only": false,
"max_nest... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -73,8 +73,46 @@
end
+theorem Int.gcd_add_mul_self (a b k : ℤ) :
+ Int.gcd a (b + k * a) = Int.gcd a b := by
+ apply Eq.symm
+ have h := @Int.gcd_greatest a (b + k * a) (Int.gcd a b) (by simp)
+ simp only [Nat.cast_inj] at h
+ apply h
+ . apply Int.gcd_dvd_left
+ . apply dvd_add
+ . apply Int.gcd_dvd_r... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_1 | 020a66bb99ca9fb8 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 3 | [
{
"theorem_name": "cancel_right_div_gcd_pos",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have heq := Int.ModEq.cancel_right_div_gcd hm h\n simp only [hgcd, Nat.cast_one, EuclideanDomain.div_one] at heq\... | [
{
"name": "cancel_right_div_gcd",
"text": "theorem cancel_right_div_gcd {m : ℤ} (a b c : Int) (hgcd : Int.gcd c m = 1)\n (h : (a * c) % m = (b * c) % m) :\n a % m = b % m := by\n rw [Int.gcd_comm] at hgcd\n if hm : m = 0 then\n simp_all only [Int.gcd_zero_left, EuclideanDomain.mod_zero, mul_eq_mul_ri... | [
{
"name": "cancel_right_div_gcd_pos",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 9,
"n_chars": 283,
"n_subproofs": 1,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"ma... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -76,8 +76,32 @@
theorem cancel_right_div_gcd_pos {m a b : ℤ}
(c : Int) (hm : 0 < m) (hgcd : Int.gcd m c = 1)
(h : (a * c) % m = (b * c) % m) :
- a % m = b % m := sorry
+ a % m = b % m := by
+ have heq := Int.ModEq.cancel_right_div_gcd hm h
+ simp only [hgcd, Nat.cast_one, EuclideanDomain.div_one] at heq
+... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_2 | 5ff4af1935cbd225 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 2 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 1 | [
{
"theorem_name": "cancel_right_div_gcd",
"depth": 1,
"n_commands": 0,
"n_lines": 18,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [Int.gcd_comm] at hgcd\n if hm : m = 0 then\n simp_all only [Int.gcd_zero_left, EuclideanDomain.mod_zero, mul_... | [
{
"name": "cancel_right_div_gcd_pos",
"text": "theorem cancel_right_div_gcd_pos {m a b : ℤ}\n (c : Int) (hm : 0 < m) (hgcd : Int.gcd m c = 1)\n (h : (a * c) % m = (b * c) % m) :\n a % m = b % m := by\n have heq := Int.ModEq.cancel_right_div_gcd hm h\n simp only [hgcd, Nat.cast_one, EuclideanDomain.div_... | [
{
"name": "cancel_right_div_gcd",
"fan_in": 3,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 22,
"n_chars": 749,
"n_subproofs": 5,
"n_tactics": 19,
"cyclomatic": 2,
"n_automation": 7,
"n_rewrites": 1,
"n_structural": 2,
"automation_only": false,
"max_... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -73,9 +73,34 @@
end
+theorem cancel_right_div_gcd_pos {m a b : ℤ}
+ (c : Int) (hm : 0 < m) (hgcd : Int.gcd m c = 1)
+ (h : (a * c) % m = (b * c) % m) :
+ a % m = b % m := by
+ have heq := Int.ModEq.cancel_right_div_gcd hm h
+ simp only [hgcd, Nat.cast_one, EuclideanDomain.div_one] at heq
+ apply heq
+
th... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_3 | e733937edbd85ae9 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 3 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 3 | [
{
"theorem_name": "cancel_right_div_gcd_pos",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have heq := Int.ModEq.cancel_right_div_gcd hm h\n simp only [hgcd, Nat.cast_one, EuclideanDomain.div_one] at heq\... | [
{
"name": "cancel_right_div_gcd",
"text": "theorem cancel_right_div_gcd {m : ℤ} (a b c : Int) (hgcd : Int.gcd c m = 1)\n (h : (a * c) % m = (b * c) % m) :\n a % m = b % m := by\n rw [Int.gcd_comm] at hgcd\n if hm : m = 0 then\n simp_all only [Int.gcd_zero_left, EuclideanDomain.mod_zero, mul_eq_mul_ri... | [
{
"name": "cancel_left_div_gcd",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 9,
"n_chars": 219,
"n_subproofs": 1,
"n_tactics": 5,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 2,
"automation_only": false,
"max_nes... | 2 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -76,11 +76,39 @@
theorem cancel_right_div_gcd_pos {m a b : ℤ}
(c : Int) (hm : 0 < m) (hgcd : Int.gcd m c = 1)
(h : (a * c) % m = (b * c) % m) :
- a % m = b % m := sorry
+ a % m = b % m := by
+ have heq := Int.ModEq.cancel_right_div_gcd hm h
+ simp only [hgcd, Nat.cast_one, EuclideanDomain.div_one] at heq
... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_4 | d031e4a216b47ac2 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 4 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 3 | [
{
"theorem_name": "cancel_right_div_gcd_pos",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have heq := Int.ModEq.cancel_right_div_gcd hm h\n simp only [hgcd, Nat.cast_one, EuclideanDomain.div_one] at heq\... | [
{
"name": "cancel_right_div_gcd",
"text": "theorem cancel_right_div_gcd {m : ℤ} (a b c : Int) (hgcd : Int.gcd c m = 1)\n (h : (a * c) % m = (b * c) % m) :\n a % m = b % m := by\n rw [Int.gcd_comm] at hgcd\n if hm : m = 0 then\n simp_all only [Int.gcd_zero_left, EuclideanDomain.mod_zero, mul_eq_mul_ri... | [
{
"name": "times_mod_imp_div_mod",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 13,
"n_chars": 381,
"n_subproofs": 0,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 1,
"n_structural": 2,
"automation_only": false,
"max_... | 2 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -76,13 +76,43 @@
theorem cancel_right_div_gcd_pos {m a b : ℤ}
(c : Int) (hm : 0 < m) (hgcd : Int.gcd m c = 1)
(h : (a * c) % m = (b * c) % m) :
- a % m = b % m := sorry
+ a % m = b % m := by
+ have heq := Int.ModEq.cancel_right_div_gcd hm h
+ simp only [hgcd, Nat.cast_one, EuclideanDomain.div_one] at heq
... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_5 | 805e319b6253d10a | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 5 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 4 | [
{
"theorem_name": "ZMod_nat_cast_eq_nat_cast_iff",
"depth": 1,
"n_commands": 0,
"n_lines": 5,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n zify\n have := ZMod_int_cast_eq_int_cast_iff n a b\n simp at this\n apply this",
"n_chars": 84,
"n... | [
{
"name": "ZMod_int_cast_eq_int_cast_iff",
"text": "/-!\nSome theorems to reason about equalities of the shape: `a % n = b % n`.\n\nWhen encoutering such an equality a good proof strategy is to simply cast the integers into\n`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp the... | [
{
"name": "ZMod_nat_cast_eq_nat_cast_iff",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 8,
"n_chars": 202,
"n_subproofs": 1,
"n_tactics": 5,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -73,8 +73,23 @@
end
+/-!
+Some theorems to reason about equalities of the shape: `a % n = b % n`.
+
+When encoutering such an equality a good proof strategy is to simply cast the integers into
+`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp theorems which
+are necessary for this... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_6 | 4d2e9aa4879e3605 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 6 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 4 | [
{
"theorem_name": "ZMod_nat_cast_eq_nat_cast_iff",
"depth": 1,
"n_commands": 0,
"n_lines": 5,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n zify\n have := ZMod_int_cast_eq_int_cast_iff n a b\n simp at this\n apply this",
"n_chars": 84,
"n... | [
{
"name": "ZMod_int_cast_eq_int_cast_iff",
"text": "/-!\nSome theorems to reason about equalities of the shape: `a % n = b % n`.\n\nWhen encoutering such an equality a good proof strategy is to simply cast the integers into\n`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp the... | [
{
"name": "ZMod_eq_imp_mod_eq",
"fan_in": 2,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 7,
"n_chars": 275,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"max_nest... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -73,6 +73,17 @@
end
+/-!
+Some theorems to reason about equalities of the shape: `a % n = b % n`.
+
+When encoutering such an equality a good proof strategy is to simply cast the integers into
+`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp theorems which
+are necessary for this... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_7 | ca30c6d191985996 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 7 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 4 | [
{
"theorem_name": "ZMod_nat_cast_eq_nat_cast_iff",
"depth": 1,
"n_commands": 0,
"n_lines": 5,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n zify\n have := ZMod_int_cast_eq_int_cast_iff n a b\n simp at this\n apply this",
"n_chars": 84,
"n... | [
{
"name": "ZMod_int_cast_eq_int_cast_iff",
"text": "/-!\nSome theorems to reason about equalities of the shape: `a % n = b % n`.\n\nWhen encoutering such an equality a good proof strategy is to simply cast the integers into\n`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp the... | [
{
"name": "ZMod_nat_eq_imp_mod_eq",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 7,
"n_chars": 157,
"n_subproofs": 0,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_... | 2 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -73,6 +73,17 @@
end
+/-!
+Some theorems to reason about equalities of the shape: `a % n = b % n`.
+
+When encoutering such an equality a good proof strategy is to simply cast the integers into
+`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp theorems which
+are necessary for this... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_8 | 52c54854cecdab30 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 8 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 4 | [
{
"theorem_name": "ZMod_nat_cast_eq_nat_cast_iff",
"depth": 1,
"n_commands": 0,
"n_lines": 5,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n zify\n have := ZMod_int_cast_eq_int_cast_iff n a b\n simp at this\n apply this",
"n_chars": 84,
"n... | [
{
"name": "ZMod_int_cast_eq_int_cast_iff",
"text": "/-!\nSome theorems to reason about equalities of the shape: `a % n = b % n`.\n\nWhen encoutering such an equality a good proof strategy is to simply cast the integers into\n`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp the... | [
{
"name": "Int.mod_eq_imp_ZMod_eq",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 6,
"n_chars": 158,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"max_... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -73,6 +73,17 @@
end
+/-!
+Some theorems to reason about equalities of the shape: `a % n = b % n`.
+
+When encoutering such an equality a good proof strategy is to simply cast the integers into
+`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp theorems which
+are necessary for this... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_9 | 2b66d80314c7d507 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 9 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 1 | [
{
"theorem_name": "ZMod.mul_inv_eq_int_gcd",
"depth": 1,
"n_commands": 0,
"n_lines": 24,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n if hn : n = 0 then\n simp only [hn, CharP.cast_eq_zero, Int.gcd_zero_right]\n rw [ZMod.mul_inv_eq_gcd]\n ... | [
{
"name": "Int.gcd_mod_same",
"text": "theorem Int.gcd_mod_same {a b : ℤ} :\n Int.gcd (a % b) b = Int.gcd a b := by\n have h1 : a % b = a - b * (a / b) := by\n have heq := Int.mul_ediv_add_emod a b\n linarith\n have h2 := Int.gcd_add_mul_self b a (- (a / b))\n rw [h1]\n simp only [neg_mul] at h2\... | [
{
"name": "ZMod.mul_inv_eq_int_gcd",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 27,
"n_chars": 975,
"n_subproofs": 3,
"n_tactics": 23,
"cyclomatic": 3,
"n_automation": 7,
"n_rewrites": 8,
"n_structural": 1,
"automation_only": false,
"m... | 2 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -101,6 +101,19 @@
apply Int.dvd_coe_gcd <;> assumption
-- TODO: this should be in mathlib
+theorem Int.gcd_mod_same {a b : ℤ} :
+ Int.gcd (a % b) b = Int.gcd a b := by
+ have h1 : a % b = a - b * (a / b) := by
+ have heq := Int.mul_ediv_add_emod a b
+ linarith
+ have h2 := Int.gcd_add_mul_self b a (... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_10 | a81cb43f56308c18 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 10 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 4 | [
{
"theorem_name": "ZMod_nat_cast_eq_nat_cast_iff",
"depth": 1,
"n_commands": 0,
"n_lines": 5,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n zify\n have := ZMod_int_cast_eq_int_cast_iff n a b\n simp at this\n apply this",
"n_chars": 84,
"n... | [
{
"name": "ZMod_int_cast_eq_int_cast_iff",
"text": "/-!\nSome theorems to reason about equalities of the shape: `a % n = b % n`.\n\nWhen encoutering such an equality a good proof strategy is to simply cast the integers into\n`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp the... | [
{
"name": "div_to_ZMod",
"fan_in": 0,
"n_deps_direct": 4,
"n_deps_transitive": 9,
"n_lines": 26,
"n_chars": 863,
"n_subproofs": 4,
"n_tactics": 21,
"cyclomatic": 1,
"n_automation": 6,
"n_rewrites": 8,
"n_structural": 3,
"automation_only": false,
"max_nesting":... | 9 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -155,6 +155,17 @@
-- End of the proof
apply heq
+/-!
+Some theorems to reason about equalities of the shape: `a % n = b % n`.
+
+When encoutering such an equality a good proof strategy is to simply cast the integers into
+`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp theorem... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_11 | 12d08e113c5e03a7 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 11 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 4 | [
{
"theorem_name": "ZMod_nat_cast_eq_nat_cast_iff",
"depth": 1,
"n_commands": 0,
"n_lines": 5,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n zify\n have := ZMod_int_cast_eq_int_cast_iff n a b\n simp at this\n apply this",
"n_chars": 84,
"n... | [
{
"name": "ZMod_int_cast_eq_int_cast_iff",
"text": "/-!\nSome theorems to reason about equalities of the shape: `a % n = b % n`.\n\nWhen encoutering such an equality a good proof strategy is to simply cast the integers into\n`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp the... | [
{
"name": "ZMod_int_cast_eq_int_cast_bmod_iff",
"fan_in": 1,
"n_deps_direct": 2,
"n_deps_transitive": 2,
"n_lines": 7,
"n_chars": 224,
"n_subproofs": 0,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 3,
"automation_only": fals... | 2 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -73,6 +73,17 @@
end
+/-!
+Some theorems to reason about equalities of the shape: `a % n = b % n`.
+
+When encoutering such an equality a good proof strategy is to simply cast the integers into
+`ZMod` which, being a ring, is convenient to work in. Below, we list a few simp theorems which
+are necessary for this... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_12 | ebed791eb5868229 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 12 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 2 | [
{
"theorem_name": "ZMod_int_cast_eq_int_cast_bmod_iff",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n apply Iff.trans\n apply ZMod_int_cast_eq_int_cast_iff\n apply bmod_eq_emod_eq_iff",
"n_chars": 87,... | [
{
"name": "bmod_eq_emod_eq_iff",
"text": "theorem bmod_eq_emod_eq_iff (n: ℕ) (a b: ℤ) :\n (a % n = b % n) ↔ (Int.bmod a n = Int.bmod b n) := by\n simp only [Int.bmod]\n apply Iff.intro <;> intro h\n . rw [h]\n . if h_a: a % n < (n + 1) / 2 then\n if h_b: b % n < (n + 1) / 2 then\n simp only... | [
{
"name": "ZMod_eq_imp_bmod_eq",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 3,
"n_lines": 7,
"n_chars": 174,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"max_nes... | 3 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -98,8 +98,39 @@
a = b :=
ZMod.val_injective n h
+theorem bmod_eq_emod_eq_iff (n: ℕ) (a b: ℤ) :
+ (a % n = b % n) ↔ (Int.bmod a n = Int.bmod b n) := by
+ simp only [Int.bmod]
+ apply Iff.intro <;> intro h
+ . rw [h]
+ . if h_a: a % n < (n + 1) / 2 then
+ if h_b: b % n < (n + 1) / 2 then
+ sim... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_13 | 5e6a9737a9c4996f | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 13 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 1 | [
{
"theorem_name": "ZMod.eq_iff_mod",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n constructor\n . simp +contextual\n . apply ZMod_val_injective",
"n_chars": 67,
"n_subproofs": 0,
"n_tactics":... | [
{
"name": "ZMod_val_injective",
"text": "theorem ZMod_val_injective {n : ℕ} [NeZero n] {a b : ZMod n} (h : a.val = b.val) :\n a = b :=\n ZMod.val_injective n h\n\n",
"fan_in": 1,
"n_lines": 5,
"n_chars": 122,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,... | [
{
"name": "ZMod.eq_iff_mod",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 7,
"n_chars": 159,
"n_subproofs": 0,
"n_tactics": 4,
"cyclomatic": 2,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 2,
"automation_only": false,
"max_nesting... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -83,6 +83,10 @@
rw [ZMod.intCast_eq_intCast_iff a b n]
tauto
+theorem ZMod_val_injective {n : ℕ} [NeZero n] {a b : ZMod n} (h : a.val = b.val) :
+ a = b :=
+ ZMod.val_injective n h
+
theorem ZMod.castInt_val_sub {n : ℕ} [inst: NeZero n] {a b : ZMod n} :
(a - b).val = (a.val - (b.val : Int)) % n := by
... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_14 | c179ddaf3509f158 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 14 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 2 | [
{
"theorem_name": "Int.bmod_pow2_eq_of_inBounds'",
"depth": 1,
"n_commands": 0,
"n_lines": 5,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have h := Int.bmod_pow2_eq_of_inBounds (n - 1) x\n have : n - 1 + 1 = n := by omega\n simp [this] at h\n a... | [
{
"name": "Int.bmod_pow2_eq_of_inBounds",
"text": "theorem Int.bmod_pow2_eq_of_inBounds (n : ℕ) (x : Int)\n (h0 : - 2 ^ n ≤ x)\n (h1 : x < 2 ^ n) :\n Int.bmod x (2 ^ (n + 1)) = x := by\n rw [Int.bmod]\n have hPowEq : (2^(n+1) : Int) = 2* (2^n) := by rw [Int.pow_succ']\n have : (2^(n + 1) + 1) / 2 = (2... | [
{
"name": "Int.bmod_pow2_eq_of_inBounds'",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 11,
"n_chars": 288,
"n_subproofs": 2,
"n_tactics": 6,
"cyclomatic": 2,
"n_automation": 3,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -146,11 +146,46 @@
attribute [zify_simps] ZMod.eq_iff_mod ZMod.val_intCast ZMod.val_add ZMod.val_sub ZMod.val_mul
ZMod.castInt_val_sub
+theorem Int.bmod_pow2_eq_of_inBounds (n : ℕ) (x : Int)
+ (h0 : - 2 ^ n ≤ x)
+ (h1 : x < 2 ^ n) :
+ Int.bmod x (2 ^ (n + 1)) = x := by
+ rw [Int.bmod]
... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_15 | 10d7c4ab25390b4b | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 15 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 1 | [
{
"theorem_name": "BitVec.bounds",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [BitVec.toInt_eq_toNat_bmod]\n apply Int.bmod_pow2_bounds",
"n_chars": 66,
"n_subproofs": 0,
"n_tactics": 3,
... | [
{
"name": "Int.bmod_pow2_bounds",
"text": "theorem Int.bmod_pow2_bounds (n : ℕ) (x : Int) :\n - 2^(n-1) ≤ Int.bmod x (2^n) ∧ Int.bmod x (2^n) < 2^(n-1) := by\n have h0 : 0 < 2^n := by simp\n\n have := @Int.le_bmod x (2^n) h0\n have hbmod := @Int.bmod_lt x (2^n) h0\n simp only [Nat.cast_pow, Nat.cast_of... | [
{
"name": "BitVec.bounds",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 7,
"n_chars": 166,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 1,
"n_structural": 1,
"automation_only": false,
"max_nesting":... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -146,8 +146,36 @@
attribute [zify_simps] ZMod.eq_iff_mod ZMod.val_intCast ZMod.val_add ZMod.val_sub ZMod.val_mul
ZMod.castInt_val_sub
+theorem Int.bmod_pow2_bounds (n : ℕ) (x : Int) :
+ - 2^(n-1) ≤ Int.bmod x (2^n) ∧ Int.bmod x (2^n) < 2^(n-1) := by
+ have h0 : 0 < 2^n := by simp
+
+ ha... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_16 | a7e1bfeeb9420e99 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 16 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 1 | [
{
"theorem_name": "BitVec.bounds",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n rw [BitVec.toInt_eq_toNat_bmod]\n apply Int.bmod_pow2_bounds",
"n_chars": 66,
"n_subproofs": 0,
"n_tactics": 3,
... | [
{
"name": "Int.bmod_pow2_bounds",
"text": "theorem Int.bmod_pow2_bounds (n : ℕ) (x : Int) :\n - 2^(n-1) ≤ Int.bmod x (2^n) ∧ Int.bmod x (2^n) < 2^(n-1) := by\n have h0 : 0 < 2^n := by simp\n\n have := @Int.le_bmod x (2^n) h0\n have hbmod := @Int.bmod_lt x (2^n) h0\n simp only [Nat.cast_pow, Nat.cast_of... | [
{
"name": "BitVec.toInt_neg_of_pos_eq_neg",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 4,
"n_lines": 49,
"n_chars": 1361,
"n_subproofs": 14,
"n_tactics": 37,
"cyclomatic": 1,
"n_automation": 17,
"n_rewrites": 10,
"n_structural": 1,
"automation_only": fa... | 3 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -177,8 +177,36 @@
simp [this]
omega
+theorem Int.bmod_pow2_bounds (n : ℕ) (x : Int) :
+ - 2^(n-1) ≤ Int.bmod x (2^n) ∧ Int.bmod x (2^n) < 2^(n-1) := by
+ have h0 : 0 < 2^n := by simp
+
+ have := @Int.le_bmod x (2^n) h0
+ have hbmod := @Int.bmod_lt x (2^n) h0
+ simp only [Nat.cast_pow, Nat.cast_ofNat... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_63778cf3dd3e_17 | c59817dd14d2eb89 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/Arith/Lemmas.lean | Lemmas | 17 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 16 | 2 | [
{
"theorem_name": "ZMod_int_cast_eq_int_cast_bmod_iff",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n apply Iff.trans\n apply ZMod_int_cast_eq_int_cast_iff\n apply bmod_eq_emod_eq_iff",
"n_chars": 87,... | [
{
"name": "bmod_eq_emod_eq_iff",
"text": "theorem bmod_eq_emod_eq_iff (n: ℕ) (a b: ℤ) :\n (a % n = b % n) ↔ (Int.bmod a n = Int.bmod b n) := by\n simp only [Int.bmod]\n apply Iff.intro <;> intro h\n . rw [h]\n . if h_a: a % n < (n + 1) / 2 then\n if h_b: b % n < (n + 1) / 2 then\n simp only... | [
{
"name": "Int.bmod_bmod_of_dvd",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 18,
"n_chars": 501,
"n_subproofs": 2,
"n_tactics": 17,
"cyclomatic": 1,
"n_automation": 4,
"n_rewrites": 4,
"n_structural": 4,
"automation_only": false,
"max_... | 1 | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Mathlib.Algebra.Algebra.ZMod
import Mathlib.RingTheory.Int.Basic
import Init.Data.BitVec.Lemmas
namespace Aeneas.Arith
/-- Small helper
We used to use this for the list definitions, as some definitions like `index` used to
manipulate integers and not nat... | @@ -87,6 +87,34 @@
a = b :=
ZMod.val_injective n h
+theorem bmod_eq_emod_eq_iff (n: ℕ) (a b: ℤ) :
+ (a % n = b % n) ↔ (Int.bmod a n = Int.bmod b n) := by
+ simp only [Int.bmod]
+ apply Iff.intro <;> intro h
+ . rw [h]
+ . if h_a: a % n < (n + 1) / 2 then
+ if h_b: b % n < (n + 1) / 2 then
+ sim... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_533152a7098c_0 | 7e2d3e150406ece7 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/WP.lean | WP | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 7 | 2 | [
{
"theorem_name": "spec_imp_exists",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n exact (spec_equiv_exists m P).1",
"n_chars": 37,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_... | [
{
"name": "spec_equiv_exists",
"text": "theorem spec_equiv_exists (m:Result α) (P:Post α) :\n spec m P ↔ (∃ y, m = ok y ∧ P y) := by\n cases m <;> simp [spec, theta, wp_return]\n\n",
"fan_in": 2,
"n_lines": 5,
"n_chars": 146,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 3,
"... | [
{
"name": "spec_imp_exists",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 5,
"n_chars": 134,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_nesting... | 1 | import Aeneas.Std.Primitives
import Aeneas.Std.Delab
import Std.Do
import Aeneas.Tactic.Solver.Grind.Init
import Aeneas.Std.Spec
namespace Aeneas.Std.WP
open Std Result
def Post α := (α -> Prop)
def Pre := Prop
def Wp α := Post α → Pre
def wp_return (x:α) : Wp α := fun p => p x
def theta (m:Result α) : Wp α :=
... | import Aeneas.Std.Primitives
import Aeneas.Std.Delab
import Std.Do
import Aeneas.Tactic.Solver.Grind.Init
import Aeneas.Std.Spec
namespace Aeneas.Std.WP
open Std Result
def Post α := (α -> Prop)
def Pre := Prop
def Wp α := Post α → Pre
def wp_return (x:α) : Wp α := fun p => p x
def theta (m:Result α) : Wp α :=
... | @@ -170,8 +170,13 @@
qimp_spec (fun x => ∃ y, P y x) k Q ↔ ∀ x, qimp_spec (P x) k Q := by
simp only [qimp_spec, forall_exists_index]; grind
+theorem spec_equiv_exists (m:Result α) (P:Post α) :
+ spec m P ↔ (∃ y, m = ok y ∧ P y) := by
+ cases m <;> simp [spec, theta, wp_return]
+
theorem spec_imp_exists {m:Re... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_533152a7098c_1 | b3df3216ca53c6fd | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/WP.lean | WP | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 7 | 2 | [
{
"theorem_name": "spec_imp_exists",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n exact (spec_equiv_exists m P).1",
"n_chars": 37,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_... | [
{
"name": "spec_equiv_exists",
"text": "theorem spec_equiv_exists (m:Result α) (P:Post α) :\n spec m P ↔ (∃ y, m = ok y ∧ P y) := by\n cases m <;> simp [spec, theta, wp_return]\n\n",
"fan_in": 2,
"n_lines": 5,
"n_chars": 146,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 3,
"... | [
{
"name": "exists_imp_spec",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 6,
"n_chars": 154,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_nesting... | 1 | import Aeneas.Std.Primitives
import Aeneas.Std.Delab
import Std.Do
import Aeneas.Tactic.Solver.Grind.Init
import Aeneas.Std.Spec
namespace Aeneas.Std.WP
open Std Result
def Post α := (α -> Prop)
def Pre := Prop
def Wp α := Post α → Pre
def wp_return (x:α) : Wp α := fun p => p x
def theta (m:Result α) : Wp α :=
... | import Aeneas.Std.Primitives
import Aeneas.Std.Delab
import Std.Do
import Aeneas.Tactic.Solver.Grind.Init
import Aeneas.Std.Spec
namespace Aeneas.Std.WP
open Std Result
def Post α := (α -> Prop)
def Pre := Prop
def Wp α := Post α → Pre
def wp_return (x:α) : Wp α := fun p => p x
def theta (m:Result α) : Wp α :=
... | @@ -170,8 +170,13 @@
qimp_spec (fun x => ∃ y, P y x) k Q ↔ ∀ x, qimp_spec (P x) k Q := by
simp only [qimp_spec, forall_exists_index]; grind
+theorem spec_equiv_exists (m:Result α) (P:Post α) :
+ spec m P ↔ (∃ y, m = ok y ∧ P y) := by
+ cases m <;> simp [spec, theta, wp_return]
+
theorem exists_imp_spec {m:Re... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_533152a7098c_2 | 10d7b383a78fd1de | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/WP.lean | WP | 2 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 7 | 1 | [
{
"theorem_name": "spec_to_mvcgen",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n obtain ⟨v, hx, hQv⟩ := spec_imp_exists h\n subst hx\n simp [Triple, WP.wp, PredTrans.apply, hQv]",
"n_chars": 106,
... | [
{
"name": "spec_imp_exists",
"text": "theorem spec_imp_exists {m:Result α} {P:Post α} :\n spec m P → (∃ y, m = ok y ∧ P y) := by\n exact (spec_equiv_exists m P).1\n\n",
"fan_in": 1,
"n_lines": 5,
"n_chars": 134,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_automation":... | [
{
"name": "spec_to_mvcgen",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 9,
"n_chars": 324,
"n_subproofs": 1,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 1,
"n_structural": 1,
"automation_only": false,
"max_nesting"... | 2 | import Aeneas.Std.Primitives
import Aeneas.Std.Delab
import Std.Do
import Aeneas.Tactic.Solver.Grind.Init
import Aeneas.Std.Spec
namespace Aeneas.Std.WP
open Std Result
def Post α := (α -> Prop)
def Pre := Prop
def Wp α := Post α → Pre
def wp_return (x:α) : Wp α := fun p => p x
def theta (m:Result α) : Wp α :=
... | import Aeneas.Std.Primitives
import Aeneas.Std.Delab
import Std.Do
import Aeneas.Tactic.Solver.Grind.Init
import Aeneas.Std.Spec
namespace Aeneas.Std.WP
open Std Result
def Post α := (α -> Prop)
def Pre := Prop
def Wp α := Post α → Pre
def wp_return (x:α) : Wp α := fun p => p x
def theta (m:Result α) : Wp α :=
... | @@ -174,6 +174,10 @@
spec m P ↔ (∃ y, m = ok y ∧ P y) := by
cases m <;> simp [spec, theta, wp_return]
+theorem spec_imp_exists {m:Result α} {P:Post α} :
+ spec m P → (∃ y, m = ok y ∧ P y) := by
+ exact (spec_equiv_exists m P).1
+
/-- Implication of a `dspec` predicate with quantifier -/
def qimp_dspec {α β}... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_533152a7098c_3 | f79ea8424fa4e5e1 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/WP.lean | WP | 3 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 7 | 1 | [
{
"theorem_name": "forall_unit",
"depth": 1,
"n_commands": 0,
"n_lines": 54,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by simp\n\n-- registers the spec info for use in the step tactic, see Spec.lean\n#register_spec_info {\n spec_name := ``Std.WP.sp... | [
{
"name": "dspec_to_mvcgen",
"text": "theorem dspec_to_mvcgen {α : Type u} {x : Result α} {Q : α → Prop}\n (h : dspec x Q) :\n ⦃ ⌜ ¬ x = .div ⌝ ⦄ x ⦃ ⇓ r => ⌜ Q r ⌝ ⦄ := by\n simp [Triple, WP.wp, PredTrans.apply, SPred.pure]\n cases x <;> simp [*, dspec] at * <;> trivial\n\n",
"fan_in": 1,
"... | [
{
"name": "forall_unit",
"fan_in": 0,
"n_deps_direct": 18,
"n_deps_transitive": 20,
"n_lines": 57,
"n_chars": 1918,
"n_subproofs": 0,
"n_tactics": 51,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": true,
"max_nesting... | 7 | import Aeneas.Std.Primitives
import Aeneas.Std.Delab
import Std.Do
import Aeneas.Tactic.Solver.Grind.Init
import Aeneas.Std.Spec
namespace Aeneas.Std.WP
open Std Result
def Post α := (α -> Prop)
def Pre := Prop
def Wp α := Post α → Pre
def wp_return (x:α) : Wp α := fun p => p x
def theta (m:Result α) : Wp α :=
... | import Aeneas.Std.Primitives
import Aeneas.Std.Delab
import Std.Do
import Aeneas.Tactic.Solver.Grind.Init
import Aeneas.Std.Spec
namespace Aeneas.Std.WP
open Std Result
def Post α := (α -> Prop)
def Pre := Prop
def Wp α := Post α → Pre
def wp_return (x:α) : Wp α := fun p => p x
def theta (m:Result α) : Wp α :=
... | @@ -805,6 +805,12 @@
subst hx
simp [Triple, WP.wp, PredTrans.apply, hQv]
+theorem dspec_to_mvcgen {α : Type u} {x : Result α} {Q : α → Prop}
+ (h : dspec x Q) :
+ ⦃ ⌜ ¬ x = .div ⌝ ⦄ x ⦃ ⇓ r => ⌜ Q r ⌝ ⦄ := by
+ simp [Triple, WP.wp, PredTrans.apply, SPred.pure]
+ cases x <;> simp [*, dspec] at * <;> triv... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_57a31cef70a8_0 | d2f49a736bcd6e50 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Vector.lean | Vector | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "getElem!_setSlice!_same",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases h <;> simp_lists [getElem!_setSlice!_prefix, getElem!_setSlice!_suffix]",
"n_chars": 83,
"n_subproofs... | [
{
"name": "getElem!_setSlice!_prefix",
"text": "theorem getElem!_setSlice!_prefix {α} {n} [Inhabited α]\n (s : Vector α n) (s' : List α) (i j : ℕ) (h : j < i) :\n (s.setSlice! i s')[j]! = s[j]! := by\n simp only [getElem!_eq_toArray_getElem!, setSlice!]\n simp_lists\n\n",
"fan_in": 1,
"n_lines":... | [
{
"name": "getElem!_setSlice!_same",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 3,
"n_lines": 7,
"n_chars": 280,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 3,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max... | 2 | import Aeneas.Data.Array
namespace Vector
attribute [scalar_tac self.toArray] Vector.size_toArray
@[scalar_tac xs.toList]
theorem toList_length {α : Type u} {n : ℕ} (xs : Vector α n) :
xs.toList.length = n := by
simp only [length_toList]
def setSlice! {α} {n} (a : Vector α n) (i : ℕ) (s : List α) : Vector α n :... | import Aeneas.Data.Array
namespace Vector
attribute [scalar_tac self.toArray] Vector.size_toArray
@[scalar_tac xs.toList]
theorem toList_length {α : Type u} {n : ℕ} (xs : Vector α n) :
xs.toList.length = n := by
simp only [length_toList]
def setSlice! {α} {n} (a : Vector α n) (i : ℕ) (s : List α) : Vector α n :... | @@ -34,6 +34,12 @@
attribute [simp_lists_safe, scalar_tac_simps] Vector.size_toArray
+theorem getElem!_setSlice!_prefix {α} {n} [Inhabited α]
+ (s : Vector α n) (s' : List α) (i j : ℕ) (h : j < i) :
+ (s.setSlice! i s')[j]! = s[j]! := by
+ simp only [getElem!_eq_toArray_getElem!, setSlice!]
+ simp_lists
+
@[s... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_57a31cef70a8_1 | e92c7933c646349f | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Vector.lean | Vector | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "getElem_setSlice!_same",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases h.1 <;> simp_lists [getElem_setSlice!_prefix, getElem_setSlice!_suffix]",
"n_chars": 83,
"n_subproofs"... | [
{
"name": "getElem_setSlice!_prefix",
"text": "theorem getElem_setSlice!_prefix {α} {n} [Inhabited α]\n (s : Vector α n) (s' : List α) (i j : ℕ) (h : j < i ∧ j < s.size) :\n (s.setSlice! i s')[j] = s[j] := by\n simp only [setSlice!, getElem_eq_toArray_getElem]\n simp_lists\n\n",
"fan_in": 1,
"n_... | [
{
"name": "getElem_setSlice!_same",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 3,
"n_lines": 7,
"n_chars": 289,
"n_subproofs": 0,
"n_tactics": 3,
"cyclomatic": 3,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_... | 2 | import Aeneas.Data.Array
namespace Vector
attribute [scalar_tac self.toArray] Vector.size_toArray
@[scalar_tac xs.toList]
theorem toList_length {α : Type u} {n : ℕ} (xs : Vector α n) :
xs.toList.length = n := by
simp only [length_toList]
def setSlice! {α} {n} (a : Vector α n) (i : ℕ) (s : List α) : Vector α n :... | import Aeneas.Data.Array
namespace Vector
attribute [scalar_tac self.toArray] Vector.size_toArray
@[scalar_tac xs.toList]
theorem toList_length {α : Type u} {n : ℕ} (xs : Vector α n) :
xs.toList.length = n := by
simp only [length_toList]
def setSlice! {α} {n} (a : Vector α n) (i : ℕ) (s : List α) : Vector α n :... | @@ -59,6 +59,12 @@
(s.setSlice! i s')[j]! = s[j]! := by
cases h <;> simp_lists [getElem!_setSlice!_prefix, getElem!_setSlice!_suffix]
+theorem getElem_setSlice!_prefix {α} {n} [Inhabited α]
+ (s : Vector α n) (s' : List α) (i j : ℕ) (h : j < i ∧ j < s.size) :
+ (s.setSlice! i s')[j] = s[j] := by
+ simp only ... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_7c6c88f30aae_0 | 7a42e710bf5e16e4 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Array/ArraySlice.lean | ArraySlice | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 2 | 1 | [
{
"theorem_name": "core.slice.cmp.PartialEqSlice.eq_homo_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 18,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n unfold core.slice.cmp.PartialEqSlice.eq\n by_cases hlen : s1.length = s2.length\n · simp only... | [
{
"name": "core.slice.cmp.allM_pairs_eq_spec",
"text": "/-- Helper -/\nprivate theorem core.slice.cmp.allM_pairs_eq_spec {α} (p : α → α → Result Bool)\n (hp : ∀ x y, p x y ⦃ b => b ↔ x = y ⦄) :\n ∀ (l1 l2 : List α), l1.length = l2.length →\n WP.spec (List.allM (fun (xy : α × α) => p xy.1 xy.2) (Lis... | [
{
"name": "core.slice.cmp.PartialEqSlice.eq_homo_spec",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 24,
"n_chars": 884,
"n_subproofs": 1,
"n_tactics": 21,
"cyclomatic": 3,
"n_automation": 5,
"n_rewrites": 3,
"n_structural": 7,
"automation_o... | 1 | import Aeneas.Std.Core.Fmt
import Aeneas.Std.Array.Array
import Aeneas.Std.Slice
import Aeneas.Std.Range
import Aeneas.Data.List.List
import Aeneas.Std.Core.Convert
import Aeneas.Std.Core.Cmp
/-! Array definitions which mention slices -/
namespace Aeneas.Std
open Result Error core.ops.range WP
attribute [-simp] Lis... | import Aeneas.Std.Core.Fmt
import Aeneas.Std.Array.Array
import Aeneas.Std.Slice
import Aeneas.Std.Range
import Aeneas.Data.List.List
import Aeneas.Std.Core.Convert
import Aeneas.Std.Core.Cmp
/-! Array definitions which mention slices -/
namespace Aeneas.Std
open Result Error core.ops.range WP
attribute [-simp] Lis... | @@ -158,6 +158,41 @@
List.allM (fun (x, y) => do let b ← partialEqInst.ne x y; ok (¬ b)) (List.zip s0.val s1.val)
else .ok false
+/-- Helper -/
+private theorem core.slice.cmp.allM_pairs_eq_spec {α} (p : α → α → Result Bool)
+ (hp : ∀ x y, p x y ⦃ b => b ↔ x = y ⦄) :
+ ∀ (l1 l2 : List α), l1.length = l2... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_7c6c88f30aae_1 | 1fc83ba4f192d6c7 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Array/ArraySlice.lean | ArraySlice | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 2 | 1 | [
{
"theorem_name": "core.slice.cmp.PartialEqSlice.ne_homo_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 10,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n unfold core.slice.cmp.PartialEqSlice.ne\n by_cases hlen : s1.length = s2.length\n · simp only... | [
{
"name": "core.slice.cmp.anyM_pairs_ne_spec",
"text": "/-- Helper -/\nprivate theorem core.slice.cmp.anyM_pairs_ne_spec {α} (p : α → α → Result Bool)\n (hp : ∀ x y, p x y ⦃ b => b ↔ ¬ (x = y) ⦄) :\n ∀ (l1 l2 : List α), l1.length = l2.length →\n WP.spec (List.anyM (fun (xy : α × α) => p xy.1 xy.2) ... | [
{
"name": "core.slice.cmp.PartialEqSlice.ne_homo_spec",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 16,
"n_chars": 701,
"n_subproofs": 1,
"n_tactics": 11,
"cyclomatic": 1,
"n_automation": 3,
"n_rewrites": 3,
"n_structural": 3,
"automation_o... | 1 | import Aeneas.Std.Core.Fmt
import Aeneas.Std.Array.Array
import Aeneas.Std.Slice
import Aeneas.Std.Range
import Aeneas.Data.List.List
import Aeneas.Std.Core.Convert
import Aeneas.Std.Core.Cmp
/-! Array definitions which mention slices -/
namespace Aeneas.Std
open Result Error core.ops.range WP
attribute [-simp] Lis... | import Aeneas.Std.Core.Fmt
import Aeneas.Std.Array.Array
import Aeneas.Std.Slice
import Aeneas.Std.Range
import Aeneas.Data.List.List
import Aeneas.Std.Core.Convert
import Aeneas.Std.Core.Cmp
/-! Array definitions which mention slices -/
namespace Aeneas.Std
open Result Error core.ops.range WP
attribute [-simp] Lis... | @@ -167,6 +167,41 @@
List.anyM (fun (x, y) => partialEqInst.ne x y) (List.zip s0.val s1.val)
else .ok true
+/-- Helper -/
+private theorem core.slice.cmp.anyM_pairs_ne_spec {α} (p : α → α → Result Bool)
+ (hp : ∀ x y, p x y ⦃ b => b ↔ ¬ (x = y) ⦄) :
+ ∀ (l1 l2 : List α), l1.length = l2.length →
+ WP.... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_8c04c73ff7b3_0 | 8c932f76470a94da | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Range/SRRange/Lemmas.lean | Lemmas | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 2 | 1 | [
{
"theorem_name": "forIn'_loop_eq_forIn'_range'",
"depth": 1,
"n_commands": 0,
"n_lines": 23,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have w := r.step_pos\n revert init i\n induction maxSteps <;> intros init i w₁ w₂ hMaxSteps\n . rw [forIn'... | [
{
"name": "size_eq",
"text": "private theorem size_eq (r : SRRange) (h : i < r.stop) :\n (r.stop - i + r.step - 1) / r.step =\n (r.stop - (i + r.step) + r.step - 1) / r.step + 1 := by\n have w := r.step_pos\n if i + r.step < r.stop then -- Not sure this case split is strictly necessary.\n rw [N... | [
{
"name": "forIn'_loop_eq_forIn'_range'",
"fan_in": 1,
"n_deps_direct": 4,
"n_deps_transitive": 2,
"n_lines": 30,
"n_chars": 1051,
"n_subproofs": 4,
"n_tactics": 26,
"cyclomatic": 7,
"n_automation": 9,
"n_rewrites": 5,
"n_structural": 3,
"automation_only": false,
... | 1 | import Mathlib.Tactic.Ring.RingNF
import Mathlib.Algebra.Order.Sub.Basic
import Aeneas.Data.Range.SRRange.Basic
import Aeneas.Data.List.List
namespace Aeneas
namespace SRRange
/-!
# Lemmas about `SRRange`
We provide lemmas rewriting for loops over `SRRange` in terms of `List.range'`.
Remark: the lemmas below are ad... | import Mathlib.Tactic.Ring.RingNF
import Mathlib.Algebra.Order.Sub.Basic
import Aeneas.Data.Range.SRRange.Basic
import Aeneas.Data.List.List
namespace Aeneas
namespace SRRange
/-!
# Lemmas about `SRRange`
We provide lemmas rewriting for loops over `SRRange` in terms of `List.range'`.
Remark: the lemmas below are ad... | @@ -29,6 +29,26 @@
unfold size at h
apply mem_of_mem_range'_aux (by simp) (by simp) h
+private theorem size_eq (r : SRRange) (h : i < r.stop) :
+ (r.stop - i + r.step - 1) / r.step =
+ (r.stop - (i + r.step) + r.step - 1) / r.step + 1 := by
+ have w := r.step_pos
+ if i + r.step < r.stop then -- Not s... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_dac1833d3fe5_0 | d025d0bb9b1725d9 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Range/MulRange/Lemmas.lean | Lemmas | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 3 | [
{
"theorem_name": "pow_ineq'",
"depth": 1,
"n_commands": 0,
"n_lines": 5,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have := pow_ineq stop mul hMul\n have := @Nat.le_mul_of_pos_right start (mul ^ (stop + 1)) hStart\n rw [Nat.mul_comm] at this\n... | [
{
"name": "pow_ineq",
"text": "private theorem pow_ineq (r: MulRange) :\n r.stop ≤ r.start * r.mul ^ (r.stop + 1) := by\n apply pow_ineq' r.stop r.mul r.start r.mul_pos r.start_pos\n\n",
"fan_in": 3,
"n_lines": 5,
"n_chars": 153,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
... | [
{
"name": "pow_ineq'",
"fan_in": 1,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 8,
"n_chars": 259,
"n_subproofs": 2,
"n_tactics": 5,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 1,
"n_structural": 0,
"automation_only": false,
"max_nesting": 2
... | 1 | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Ring.Canonical
import Mathlib.Tactic.Ring.RingNF
import Aeneas.Data.Range.MulRange.Basic
import Aeneas.Data.Range.DivRange.Lemmas
namespace Aeneas
-- Auxiliary lemma
theorem pow_ineq' (stop mul start : Nat) (hMul : 1 < mul) (hStart : 0 < start) :
stop ≤ start... | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Ring.Canonical
import Mathlib.Tactic.Ring.RingNF
import Aeneas.Data.Range.MulRange.Basic
import Aeneas.Data.Range.DivRange.Lemmas
namespace Aeneas
-- Auxiliary lemma
theorem pow_ineq' (stop mul start : Nat) (hMul : 1 < mul) (hStart : 0 < start) :
stop ≤ start... | @@ -8,7 +8,11 @@
-- Auxiliary lemma
theorem pow_ineq' (stop mul start : Nat) (hMul : 1 < mul) (hStart : 0 < start) :
- stop ≤ start * mul ^ (stop + 1):= sorry
+ stop ≤ start * mul ^ (stop + 1):= by
+ have := pow_ineq stop mul hMul
+ have := @Nat.le_mul_of_pos_right start (mul ^ (stop + 1)) hStart
+ rw [Nat.mul... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_dac1833d3fe5_1 | 907e6a7833c18c5b | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Range/MulRange/Lemmas.lean | Lemmas | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 2 | [
{
"theorem_name": "mem_of_mem_MulRange",
"depth": 1,
"n_commands": 0,
"n_lines": 6,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n apply mem_of_mem_MulRange_aux r.stop r.mul r.start r.mul_pos r.start\n (by\n simp [r.start_pos]\n exists 0... | [
{
"name": "mem_of_mem_MulRange_aux",
"text": "private theorem mem_of_mem_MulRange_aux\n (stop mul start : Nat) (hMul : 1 < mul) (i : Nat) (hi : 0 < i ∧ ∃ k, i = start * mul ^ k)\n (a : Nat) :\n a ∈ mulRange stop mul hMul i hi.left →\n start ≤ a ∧ a < stop ∧ ∃ k, a = start * mul ^ k\n := by\n unfold mu... | [
{
"name": "mem_of_mem_MulRange",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 9,
"n_chars": 278,
"n_subproofs": 0,
"n_tactics": 7,
"cyclomatic": 1,
"n_automation": 2,
"n_rewrites": 0,
"n_structural": 2,
"automation_only": false,
"max_nes... | 1 | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Ring.Canonical
import Mathlib.Tactic.Ring.RingNF
import Aeneas.Data.Range.MulRange.Basic
import Aeneas.Data.Range.DivRange.Lemmas
namespace Aeneas
-- Auxiliary lemma
theorem pow_ineq' (stop mul start : Nat) (hMul : 1 < mul) (hStart : 0 < start) :
stop ≤ start... | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Ring.Canonical
import Mathlib.Tactic.Ring.RingNF
import Aeneas.Data.Range.MulRange.Basic
import Aeneas.Data.Range.DivRange.Lemmas
namespace Aeneas
-- Auxiliary lemma
theorem pow_ineq' (stop mul start : Nat) (hMul : 1 < mul) (hStart : 0 < start) :
stop ≤ start... | @@ -16,8 +16,44 @@
namespace MulRange
+private theorem mem_of_mem_MulRange_aux
+ (stop mul start : Nat) (hMul : 1 < mul) (i : Nat) (hi : 0 < i ∧ ∃ k, i = start * mul ^ k)
+ (a : Nat) :
+ a ∈ mulRange stop mul hMul i hi.left →
+ start ≤ a ∧ a < stop ∧ ∃ k, a = start * mul ^ k
+ := by
+ unfold mulRange
+ dcas... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_dac1833d3fe5_2 | 3b5f39fc2338f10f | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Range/MulRange/Lemmas.lean | Lemmas | 2 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 4 | 1 | [
{
"theorem_name": "pow_ineq",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n apply pow_ineq' r.stop r.mul r.start r.mul_pos r.start_pos",
"n_chars": 64,
"n_subproofs": 0,
"n_tactics": 2,
"cyc... | [
{
"name": "pow_ineq'",
"text": "theorem pow_ineq' (stop mul start : Nat) (hMul : 1 < mul) (hStart : 0 < start) :\n stop ≤ start * mul ^ (stop + 1):= by\n have := pow_ineq stop mul hMul\n have := @Nat.le_mul_of_pos_right start (mul ^ (stop + 1)) hStart\n rw [Nat.mul_comm] at this\n omega\n\n",
"fan_... | [
{
"name": "pow_ineq",
"fan_in": 3,
"n_deps_direct": 1,
"n_deps_transitive": 2,
"n_lines": 5,
"n_chars": 153,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_nesting": 2
... | 1 | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Ring.Canonical
import Mathlib.Tactic.Ring.RingNF
import Aeneas.Data.Range.MulRange.Basic
import Aeneas.Data.Range.DivRange.Lemmas
namespace Aeneas
-- Auxiliary lemma
namespace MulRange
private theorem mem_of_mem_MulRange_aux
(stop mul start : Nat) (hMul : 1 ... | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Ring.Canonical
import Mathlib.Tactic.Ring.RingNF
import Aeneas.Data.Range.MulRange.Basic
import Aeneas.Data.Range.DivRange.Lemmas
namespace Aeneas
-- Auxiliary lemma
theorem pow_ineq' (stop mul start : Nat) (hMul : 1 < mul) (hStart : 0 < start) :
stop ≤ start... | @@ -7,6 +7,13 @@
namespace Aeneas
-- Auxiliary lemma
+theorem pow_ineq' (stop mul start : Nat) (hMul : 1 < mul) (hStart : 0 < start) :
+ stop ≤ start * mul ^ (stop + 1):= by
+ have := pow_ineq stop mul hMul
+ have := @Nat.le_mul_of_pos_right start (mul ^ (stop + 1)) hStart
+ rw [Nat.mul_comm] at this
+ omega
+... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_0c54acaa8e7b_0 | 7fe6ac91cb371ea1 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/RangeIter.lean | RangeIter | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 8 | 2 | [
{
"theorem_name": "core.iter.range.IteratorRange.next_UScalar_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 13,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n by_cases h : range.start.val < range.end.val\n · simp only [h, ↓reduceIte]\n apply spe... | [
{
"name": "core.iter.range.IteratorRange.next_UScalar_none_spec",
"text": "/-- Generic `IteratorRange.next` on `Range (UScalar ty)`, none case\n (`start ≥ end`): yields `none`, leaves the range unchanged. -/\ntheorem core.iter.range.IteratorRange.next_UScalar_none_spec {ty : UScalarTy}\n {cloneInst : ... | [
{
"name": "core.iter.range.IteratorRange.next_UScalar_spec",
"fan_in": 2,
"n_deps_direct": 2,
"n_deps_transitive": 2,
"n_lines": 30,
"n_chars": 1442,
"n_subproofs": 0,
"n_tactics": 13,
"cyclomatic": 3,
"n_automation": 7,
"n_rewrites": 0,
"n_structural": 5,
"automa... | 2 | /- Step specs for Range/StepBy iterators on Usize.
These use WP.spec_bind directly to avoid importing the step tactic. -/
import Aeneas.Std.Core.Iter
import Aeneas.Std.Scalar
import Aeneas.Std.SliceIter
namespace Aeneas.Std
open Result core.ops.range WP ScalarElab
-- ==============================================... | /- Step specs for Range/StepBy iterators on Usize.
These use WP.spec_bind directly to avoid importing the step tactic. -/
import Aeneas.Std.Core.Iter
import Aeneas.Std.Scalar
import Aeneas.Std.SliceIter
namespace Aeneas.Std
open Result core.ops.range WP ScalarElab
-- ==============================================... | @@ -34,6 +34,24 @@
simp only [hfwd, ↓reduceDIte, bind_tc_ok, spec_ok]
simp [UScalar.ofNatCore_val_eq]
+/-- Generic `IteratorRange.next` on `Range (UScalar ty)`, none case
+ (`start ≥ end`): yields `none`, leaves the range unchanged. -/
+theorem core.iter.range.IteratorRange.next_UScalar_none_spec {ty : UScal... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_0c54acaa8e7b_1 | 1b4ffe6b77c08924 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/RangeIter.lean | RangeIter | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 8 | 5 | [
{
"theorem_name": "core.iter.range.IteratorRange.next_UScalar_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 13,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n by_cases h : range.start.val < range.end.val\n · simp only [h, ↓reduceIte]\n apply spe... | [
{
"name": "core.iter.range.IteratorRange.next_UScalar_some_spec",
"text": "/-- Generic `IteratorRange.next` on `Range (UScalar ty)`, some case\n (`start < end`): yields `some start` and advances by one. -/\ntheorem core.iter.range.IteratorRange.next_UScalar_some_spec {ty : UScalarTy}\n {cloneInst : co... | [
{
"name": "core.iter.adapters.step_by.skipN_Range_UScalar_spec",
"fan_in": 3,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 45,
"n_chars": 2060,
"n_subproofs": 1,
"n_tactics": 30,
"cyclomatic": 4,
"n_automation": 7,
"n_rewrites": 5,
"n_structural": 6,
"au... | 1 | /- Step specs for Range/StepBy iterators on Usize.
These use WP.spec_bind directly to avoid importing the step tactic. -/
import Aeneas.Std.Core.Iter
import Aeneas.Std.Scalar
import Aeneas.Std.SliceIter
namespace Aeneas.Std
open Result core.ops.range WP ScalarElab
-- ==============================================... | /- Step specs for Range/StepBy iterators on Usize.
These use WP.spec_bind directly to avoid importing the step tactic. -/
import Aeneas.Std.Core.Iter
import Aeneas.Std.Scalar
import Aeneas.Std.SliceIter
namespace Aeneas.Std
open Result core.ops.range WP ScalarElab
-- ==============================================... | @@ -12,6 +12,28 @@
-- Generic UScalar Range/StepBy iterator specs
-- ============================================================================
+/-- Generic `IteratorRange.next` on `Range (UScalar ty)`, some case
+ (`start < end`): yields `some start` and advances by one. -/
+theorem core.iter.range.IteratorRa... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_0c54acaa8e7b_3 | 29ab9dc7f18fae55 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/RangeIter.lean | RangeIter | 3 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 8 | 2 | [
{
"theorem_name": "core.iter.adapters.step_by.IteratorStepBy.next_Range_UScalar_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 29,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n by_cases h : it.iter.start.val < it.iter.end.val\n · simp only [h, ↓red... | [
{
"name": "core.iter.adapters.step_by.IteratorStepBy.next_Range_UScalar_none_spec",
"text": "/-- Generic `IteratorStepBy.next` on `Range (UScalar ty)`, none case\n (`start ≥ end`): yields `none`, leaves the iterator unchanged. -/\ntheorem core.iter.adapters.step_by.IteratorStepBy.next_Range_UScalar_none_... | [
{
"name": "core.iter.adapters.step_by.IteratorStepBy.next_Range_UScalar_spec",
"fan_in": 1,
"n_deps_direct": 3,
"n_deps_transitive": 3,
"n_lines": 51,
"n_chars": 2406,
"n_subproofs": 0,
"n_tactics": 25,
"cyclomatic": 3,
"n_automation": 11,
"n_rewrites": 3,
"n_structur... | 3 | /- Step specs for Range/StepBy iterators on Usize.
These use WP.spec_bind directly to avoid importing the step tactic. -/
import Aeneas.Std.Core.Iter
import Aeneas.Std.Scalar
import Aeneas.Std.SliceIter
namespace Aeneas.Std
open Result core.ops.range WP ScalarElab
-- ==============================================... | /- Step specs for Range/StepBy iterators on Usize.
These use WP.spec_bind directly to avoid importing the step tactic. -/
import Aeneas.Std.Core.Iter
import Aeneas.Std.Scalar
import Aeneas.Std.SliceIter
namespace Aeneas.Std
open Result core.ops.range WP ScalarElab
-- ==============================================... | @@ -125,6 +125,30 @@
decide_false, Bool.false_eq_true, ↓reduceIte, spec_ok, Nat.min_def]
simp_all [Nat.min_def]
+/-- Generic `IteratorStepBy.next` on `Range (UScalar ty)`, none case
+ (`start ≥ end`): yields `none`, leaves the iterator unchanged. -/
+theorem core.iter.adapters.step_by.IteratorStepB... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_0c54acaa8e7b_9 | 4d55074b045f75e3 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/RangeIter.lean | RangeIter | 9 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 8 | 1 | [
{
"theorem_name": "core.iter.adapters.enumerate.IteratorEnumerate.next_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 16,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n cases o with\n | some a =>\n apply spec_mono\n (core.iter.adapters.enume... | [
{
"name": "core.iter.adapters.enumerate.IteratorEnumerate.next_none_spec",
"text": "/-- `Enumerate.next` — none case. No `@[step]` — see the merged `next_spec`.\n When the inner iterator yields `none`, enumerate propagates none. -/\ntheorem core.iter.adapters.enumerate.IteratorEnumerate.next_none_spec\n... | [
{
"name": "core.iter.adapters.enumerate.IteratorEnumerate.next_spec",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 2,
"n_lines": 40,
"n_chars": 1740,
"n_subproofs": 0,
"n_tactics": 16,
"cyclomatic": 4,
"n_automation": 2,
"n_rewrites": 0,
"n_structural": 7,
... | 2 | /- Step specs for Range/StepBy iterators on Usize.
These use WP.spec_bind directly to avoid importing the step tactic. -/
import Aeneas.Std.Core.Iter
import Aeneas.Std.Scalar
import Aeneas.Std.SliceIter
namespace Aeneas.Std
open Result core.ops.range WP ScalarElab
-- ==============================================... | /- Step specs for Range/StepBy iterators on Usize.
These use WP.spec_bind directly to avoid importing the step tactic. -/
import Aeneas.Std.Core.Iter
import Aeneas.Std.Scalar
import Aeneas.Std.SliceIter
namespace Aeneas.Std
open Result core.ops.range WP ScalarElab
-- ==============================================... | @@ -277,6 +277,26 @@
· exfalso; simp [UScalar.inBounds] at hadd; scalar_tac
· exact hadd.elim
+/-- `Enumerate.next` — none case. No `@[step]` — see the merged `next_spec`.
+ When the inner iterator yields `none`, enumerate propagates none. -/
+theorem core.iter.adapters.enumerate.IteratorEnumerate.next_none... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_69e9a0e72df1_0 | 3ad723e045ae17a5 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/Ops/Div.lean | Div | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 2 | 1 | [
{
"theorem_name": "IScalar.div_bv_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 259,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n conv => congr; ext; lhs; simp only [HDiv.hDiv]\n simp only [div, bne_iff_ne, ne_eq, hzero, not_false_eq_true, ↓reduc... | [
{
"name": "IScalar.neg_imp_neg_val_toNat_mod_pow_eq_neg_val",
"text": "theorem IScalar.neg_imp_neg_val_toNat_mod_pow_eq_neg_val {ty} (x : IScalar ty)\n (hNeg : x.bv.toInt < 0) :\n ((-x.val).toNat : Int) % 2^ty.numBits = -(x.val : Int) := by\n have hmsb : x.bv.msb = true := by\n have := @BitVec.msb_eq_... | [
{
"name": "IScalar.div_bv_spec",
"fan_in": 2,
"n_deps_direct": 3,
"n_deps_transitive": 3,
"n_lines": 268,
"n_chars": 10868,
"n_subproofs": 84,
"n_tactics": 249,
"cyclomatic": 9,
"n_automation": 107,
"n_rewrites": 52,
"n_structural": 12,
"automation_only": false,
... | 2 | import Aeneas.Std.Scalar.Core
import Aeneas.Std.Scalar.Misc
import Aeneas.Std.Scalar.Elab
import Aeneas.Tactic.Solver.ScalarTac
import Mathlib.Data.BitVec
namespace Aeneas.Std
open Result Error Arith ScalarElab WP
/-!
# Division: Definitions
-/
def UScalar.div {ty : UScalarTy} (x y : UScalar ty) : Result (UScalar t... | import Aeneas.Std.Scalar.Core
import Aeneas.Std.Scalar.Misc
import Aeneas.Std.Scalar.Elab
import Aeneas.Tactic.Solver.ScalarTac
import Mathlib.Data.BitVec
namespace Aeneas.Std
open Result Error Arith ScalarElab WP
/-!
# Division: Definitions
-/
def UScalar.div {ty : UScalarTy} (x y : UScalar ty) : Result (UScalar t... | @@ -97,6 +97,41 @@
have := System.Platform.numBits_eq
cases this <;> simp [*]
+theorem IScalar.neg_imp_neg_val_toNat_mod_pow_eq_neg_val {ty} (x : IScalar ty)
+ (hNeg : x.bv.toInt < 0) :
+ ((-x.val).toNat : Int) % 2^ty.numBits = -(x.val : Int) := by
+ have hmsb : x.bv.msb = true := by
+ have := @BitVec.msb... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_69e9a0e72df1_1 | 38024635814ca9c0 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/Ops/Div.lean | Div | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 2 | 1 | [
{
"theorem_name": "IScalar.div_bv_spec",
"depth": 1,
"n_commands": 0,
"n_lines": 259,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n conv => congr; ext; lhs; simp only [HDiv.hDiv]\n simp only [div, bne_iff_ne, ne_eq, hzero, not_false_eq_true, ↓reduc... | [
{
"name": "IScalar.neg_imp_neg_val_toNat_mod_pow_eq_neg_val",
"text": "theorem IScalar.neg_imp_neg_val_toNat_mod_pow_eq_neg_val {ty} (x : IScalar ty)\n (hNeg : x.bv.toInt < 0) :\n ((-x.val).toNat : Int) % 2^ty.numBits = -(x.val : Int) := by\n have hmsb : x.bv.msb = true := by\n have := @BitVec.msb_eq_... | [
{
"name": "IScalar.div_spec",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 5,
"n_lines": 18,
"n_chars": 776,
"n_subproofs": 1,
"n_tactics": 10,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"max_nest... | 2 | import Aeneas.Std.Scalar.Core
import Aeneas.Std.Scalar.Misc
import Aeneas.Std.Scalar.Elab
import Aeneas.Tactic.Solver.ScalarTac
import Mathlib.Data.BitVec
namespace Aeneas.Std
open Result Error Arith ScalarElab WP
/-!
# Division: Definitions
-/
def UScalar.div {ty : UScalarTy} (x y : UScalar ty) : Result (UScalar t... | import Aeneas.Std.Scalar.Core
import Aeneas.Std.Scalar.Misc
import Aeneas.Std.Scalar.Elab
import Aeneas.Tactic.Solver.ScalarTac
import Mathlib.Data.BitVec
namespace Aeneas.Std
open Result Error Arith ScalarElab WP
/-!
# Division: Definitions
-/
def UScalar.div {ty : UScalarTy} (x y : UScalar ty) : Result (UScalar t... | @@ -97,6 +97,41 @@
have := System.Platform.numBits_eq
cases this <;> simp [*]
+theorem IScalar.neg_imp_neg_val_toNat_mod_pow_eq_neg_val {ty} (x : IScalar ty)
+ (hNeg : x.bv.toInt < 0) :
+ ((-x.val).toNat : Int) % 2^ty.numBits = -(x.val : Int) := by
+ have hmsb : x.bv.msb = true := by
+ have := @BitVec.msb... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_60f4b1e46632_0 | d3b5edd9767890ab | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/Core.lean | Core | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 5 | 2 | [
{
"theorem_name": "IScalar.rMin_eq_min",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n apply (IScalar.rbound_eq_bound ty).left",
"n_chars": 45,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic"... | [
{
"name": "IScalar.rbound_eq_bound",
"text": "theorem IScalar.rbound_eq_bound (ty : IScalarTy) :\n IScalar.rMin ty = IScalar.min ty ∧ IScalar.rMax ty = IScalar.max ty := by\n cases ty <;> split_conjs <;>\n simp_bounds\n\n",
"fan_in": 2,
"n_lines": 6,
"n_chars": 175,
"n_subproofs": 0,
... | [
{
"name": "IScalar.rMin_eq_min",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 4,
"n_chars": 129,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_nes... | 1 | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | @@ -292,8 +292,14 @@
I8.numBits, I16.numBits, I32.numBits, I64.numBits, I128.numBits, Isize.numBits,
IScalar.size, I8.size, I16.size, I32.size, I64.size, I128.size, Isize.size])
-theorem IScalar.rMin_eq_min (ty : IScalarTy) : IScalar.rMin ty = IScalar.min ty := sorry
+theorem IScalar.rbound_eq_bound (ty... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_60f4b1e46632_1 | 89a243da7a474f39 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/Core.lean | Core | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 5 | 2 | [
{
"theorem_name": "IScalar.rMin_eq_min",
"depth": 1,
"n_commands": 0,
"n_lines": 2,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n apply (IScalar.rbound_eq_bound ty).left",
"n_chars": 45,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic"... | [
{
"name": "IScalar.rbound_eq_bound",
"text": "theorem IScalar.rbound_eq_bound (ty : IScalarTy) :\n IScalar.rMin ty = IScalar.min ty ∧ IScalar.rMax ty = IScalar.max ty := by\n cases ty <;> split_conjs <;>\n simp_bounds\n\n",
"fan_in": 2,
"n_lines": 6,
"n_chars": 175,
"n_subproofs": 0,
... | [
{
"name": "IScalar.rMax_eq_max",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 16,
"n_chars": 572,
"n_subproofs": 0,
"n_tactics": 2,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_ne... | 1 | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | @@ -296,8 +296,14 @@
cases ty <;>
simp_bounds
-theorem IScalar.rMax_eq_max (ty : IScalarTy) : IScalar.rMax ty = IScalar.max ty := sorry
+theorem IScalar.rbound_eq_bound (ty : IScalarTy) :
+ IScalar.rMin ty = IScalar.min ty ∧ IScalar.rMax ty = IScalar.max ty := by
+ cases ty <;> split_conjs <;>
+ simp_bounds
... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_60f4b1e46632_2 | fbcdc0f6e5ab7754 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/Core.lean | Core | 2 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 5 | 6 | [
{
"theorem_name": "U8.ofNat_bv",
"depth": 1,
"n_commands": 0,
"n_lines": 1,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by apply UScalar.ofNatCore_bv",
"n_chars": 30,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation":... | [
{
"name": "UScalar.ofNatCore_bv",
"text": "theorem UScalar.ofNatCore_bv {ty : UScalarTy} (x : Nat) h :\n (@UScalar.ofNatCore ty x h).bv = BitVec.ofNat _ x := by\n simp only [ofNatCore, BitVec.ofNat, Fin.Internal.ofNat, Nat.mod_eq_of_lt h]\n\n",
"fan_in": 6,
"n_lines": 5,
"n_chars": 197,
"n... | [
{
"name": "U8.ofNat_bv",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 2,
"n_chars": 174,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_nesting": 1... | 1 | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | @@ -664,13 +664,17 @@
@[ext, grind ext, agrind ext] theorem U128.bv_eq_imp_eq (x y : U128) : x.bv = y.bv → x = y := by simp [UScalar.eq_equiv_bv_eq]
@[ext, grind ext, agrind ext] theorem Usize.bv_eq_imp_eq (x y : Usize) : x.bv = y.bv → x = y := by simp [UScalar.eq_equiv_bv_eq]
-@[simp, scalar_tac_simps, simp_scalar... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_60f4b1e46632_3 | 176cf82ece7668dc | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/Core.lean | Core | 3 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 5 | 6 | [
{
"theorem_name": "I8.ofInt_bv",
"depth": 1,
"n_commands": 0,
"n_lines": 1,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by apply IScalar.ofIntCore_bv",
"n_chars": 30,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation":... | [
{
"name": "IScalar.ofIntCore_bv",
"text": "theorem IScalar.ofIntCore_bv {ty : IScalarTy} (x : Int) h :\n (@IScalar.ofIntCore ty x h).bv = BitVec.ofInt _ x := by\n simp only [ofIntCore, BitVec.ofInt, Int.ofNat_eq_natCast, Nat.cast_pow, Nat.cast_ofNat]\n congr\n\n",
"fan_in": 6,
"n_lines": 6,
"... | [
{
"name": "I8.ofInt_bv",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 2,
"n_chars": 174,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_nesting": 1... | 1 | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | @@ -693,13 +693,18 @@
@[ext, grind ext, agrind ext] theorem I128.bv_eq_imp_eq (x y : I128) : x.bv = y.bv → x = y := by simp[IScalar.eq_equiv_bv_eq]
@[ext, grind ext, agrind ext] theorem Isize.bv_eq_imp_eq (x y : Isize) : x.bv = y.bv → x = y := by simp[IScalar.eq_equiv_bv_eq]
-@[simp, scalar_tac_simps, simp_scalar_s... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_60f4b1e46632_4 | af968a54eb3cd248 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/Core.lean | Core | 4 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 5 | 1 | [
{
"theorem_name": "IScalar.min_le_max",
"depth": 1,
"n_commands": 0,
"n_lines": 3,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have := IScalar.min_lt_max ty\n scalar_tac",
"n_chars": 48,
"n_subproofs": 1,
"n_tactics": 3,
"cyclomat... | [
{
"name": "IScalar.min_lt_max",
"text": "theorem IScalar.min_lt_max (ty : IScalarTy) : IScalar.min ty < IScalar.max ty := by\n cases ty <;> simp [IScalar.min, IScalar.max] <;> (try simp_bounds)\n have : (0 : Int) < 2 ^ (System.Platform.numBits - 1) := by simp\n omega\n\n",
"fan_in": 1,
"n_lines":... | [
{
"name": "IScalar.min_le_max",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 5,
"n_chars": 132,
"n_subproofs": 1,
"n_tactics": 3,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"max_nest... | 1 | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | @@ -719,8 +719,15 @@
theorem UScalar.default_bv {ty} : (default : UScalar ty).bv = 0 := by
simp only [default]; cases ty <;> simp
-theorem IScalar.min_le_max (ty : IScalarTy) : IScalar.min ty ≤ IScalar.max ty := sorry
+theorem IScalar.min_lt_max (ty : IScalarTy) : IScalar.min ty < IScalar.max ty := by
+ cases ty... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_60f4b1e46632_5 | 6c89a92bf48f668a | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Std/Scalar/Core.lean | Core | 5 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 5 | 2 | [
{
"theorem_name": "UScalar.max_left_zero_eq",
"depth": 1,
"n_commands": 0,
"n_lines": 1,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " max_eq_right (UScalar.zero_le x)",
"n_chars": 33,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
... | [
{
"name": "UScalar.zero_le",
"text": "theorem UScalar.zero_le {ty} (x: UScalar ty): UScalar.ofNat 0 (by simp) ≤ x := by simp\n\n",
"fan_in": 2,
"n_lines": 3,
"n_chars": 90,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 0,
"n_structura... | [
{
"name": "UScalar.max_left_zero_eq",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 5,
"n_chars": 144,
"n_subproofs": 0,
"n_tactics": 1,
"cyclomatic": 1,
"n_automation": 0,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"ma... | 1 | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | import Lean
import Lean.Meta.Tactic.Simp
import Aeneas.Std.Core.Core
import Aeneas.Tactic.Step.Init
import Aeneas.Tactic.Solver.ScalarTac.ScalarTac
import Aeneas.Tactic.Conv.Bvify.Init
import Aeneas.Data.Nat
import Aeneas.Data.Int
import Aeneas.Tactic.Simp.SimpLists.Init
import AeneasMeta.BvEnumToBitVec
namespace Aene... | @@ -947,13 +947,15 @@
/-! Max theory -/
-- TODO: do the min theory later on.
+theorem UScalar.zero_le {ty} (x: UScalar ty): UScalar.ofNat 0 (by simp) ≤ x := by simp
+
@[simp]
theorem UScalar.max_left_zero_eq {ty} (x: UScalar ty):
- Max.max (UScalar.ofNat 0 (by simp)) x = x := sorry
+ Max.max (UScalar.ofNat 0 (b... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_c313e7a8816c_0 | 97c9420128261334 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Tactic/Solver/ScalarTac/Core.lean | Core | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 1 | 1 | [
{
"theorem_name": "ne_is_lt_or_gt",
"depth": 1,
"n_commands": 0,
"n_lines": 10,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have hne : x - y ≠ 0 := by\n simp\n intro h\n have: x = y := by omega\n simp_all\n have h := ne_zero_is_lt_or_... | [
{
"name": "ne_zero_is_lt_or_gt",
"text": "theorem ne_zero_is_lt_or_gt {x : Int} (hne : x ≠ 0) : x < 0 ∨ x > 0 := by\n cases h: x <;>\n simp_all only [Int.ofNat_eq_natCast, Int.natCast_eq_zero, Int.natCast_pos,\n ne_eq, Int.negSucc_ne_zero, not_false_eq_true, Int.negSucc_lt_zero,\n gt_iff_lt, Int.neg... | [
{
"name": "ne_is_lt_or_gt",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 13,
"n_chars": 288,
"n_subproofs": 3,
"n_tactics": 12,
"cyclomatic": 2,
"n_automation": 5,
"n_rewrites": 0,
"n_structural": 1,
"automation_only": false,
"max_nestin... | 1 | import Lean
import Mathlib.Tactic.Linarith -- Introduces a lot of useful lemmas
namespace Aeneas
namespace ScalarTac
open Lean Elab Term Meta
-- TODO: move?
theorem ne_is_lt_or_gt {x y : Int} (hne : x ≠ y) : x < y ∨ x > y := sorry
-- TODO: move?
theorem Nat.le_imp_le_equiv_eq (i j : Nat) (h0 : i ≤ j) : j ≤ i ↔ i =... | import Lean
import Mathlib.Tactic.Linarith -- Introduces a lot of useful lemmas
namespace Aeneas
namespace ScalarTac
open Lean Elab Term Meta
-- TODO: move?
theorem ne_zero_is_lt_or_gt {x : Int} (hne : x ≠ 0) : x < 0 ∨ x > 0 := by
cases h: x <;>
simp_all only [Int.ofNat_eq_natCast, Int.natCast_eq_zero, Int.natC... | @@ -8,9 +8,27 @@
open Lean Elab Term Meta
-- TODO: move?
-theorem ne_is_lt_or_gt {x y : Int} (hne : x ≠ y) : x < y ∨ x > y := sorry
+theorem ne_zero_is_lt_or_gt {x : Int} (hne : x ≠ 0) : x < 0 ∨ x > 0 := by
+ cases h: x <;>
+ simp_all only [Int.ofNat_eq_natCast, Int.natCast_eq_zero, Int.natCast_pos,
+ ne_eq, I... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_55078fa06512_0 | 2210d56706f57c60 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Range/DivRange/Lemmas.lean | Lemmas | 0 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 3 | 2 | [
{
"theorem_name": "mem_of_mem_divRange",
"depth": 1,
"n_commands": 0,
"n_lines": 13,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n have hDiv := r.divisor_pos\n have h0 := Nat.log_le_self r.divisor r.start\n have h1 : r.start < r.divisor ^ (Nat.log... | [
{
"name": "mem_of_mem_divRange_loop_aux",
"text": "private theorem mem_of_mem_divRange_loop_aux\n (fuel : Nat) :\n ∀ (start stop divisor a : Nat),\n 1 < divisor →\n start ≤ divisor ^ fuel →\n a ∈ divRange.loop stop divisor fuel start →\n stop < a ∧ a ≤ start ∧ ∃ k, a = start / divisor ^ k\n := by\n ... | [
{
"name": "mem_of_mem_divRange",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 16,
"n_chars": 760,
"n_subproofs": 8,
"n_tactics": 12,
"cyclomatic": 1,
"n_automation": 6,
"n_rewrites": 0,
"n_structural": 0,
"automation_only": false,
"max_n... | 1 | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Sub.Defs
import Aeneas.Data.Range.DivRange.Basic
namespace Aeneas
-- Auxiliary lemma - TODO: move?
theorem pow_ineq (start divisor : Nat) (hDiv : 1 < divisor) :
start ≤ divisor ^ (start + 1) := by
have h0 := Nat.log_le_self divisor start
have h1 : start <... | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Sub.Defs
import Aeneas.Data.Range.DivRange.Basic
namespace Aeneas
-- Auxiliary lemma - TODO: move?
theorem pow_ineq (start divisor : Nat) (hDiv : 1 < divisor) :
start ≤ divisor ^ (start + 1) := by
have h0 := Nat.log_le_self divisor start
have h1 : start <... | @@ -27,16 +27,70 @@
divRange.loop stop divisor fuel 0 = [] := by
cases fuel <;> simp [divRange.loop]
+private theorem mem_of_mem_divRange_loop_aux
+ (fuel : Nat) :
+ ∀ (start stop divisor a : Nat),
+ 1 < divisor →
+ start ≤ divisor ^ fuel →
+ a ∈ divRange.loop stop divisor fuel start →
+ stop < a ∧ a ≤ st... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_55078fa06512_1 | 617ed00bb9cef74f | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Range/DivRange/Lemmas.lean | Lemmas | 1 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 3 | 2 | [
{
"theorem_name": "forIn_eq_forIn_divRange",
"depth": 1,
"n_commands": 0,
"n_lines": 5,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n simp only [forIn, forIn', divRange, DivRange.forIn']\n rw [forIn'_loop_eq_forIn'_divRange]\n . simp\n . apply po... | [
{
"name": "forIn'_loop_eq_forIn'_divRange",
"text": "private theorem forIn'_loop_eq_forIn'_divRange [Monad m] (r : DivRange)\n (fuel : Nat) (init : β) (f : (a : Nat) → a ∈ r → β → m (ForInStep β)) (i) (hk : ∃ k, i = r.start / r.divisor ^ k)\n (hStart : i ≤ r.start) (hFuel : i ≤ r.divisor ^ fuel) :\n ... | [
{
"name": "forIn_eq_forIn_divRange",
"fan_in": 0,
"n_deps_direct": 2,
"n_deps_transitive": 4,
"n_lines": 9,
"n_chars": 320,
"n_subproofs": 0,
"n_tactics": 5,
"cyclomatic": 1,
"n_automation": 2,
"n_rewrites": 1,
"n_structural": 1,
"automation_only": false,
"max... | 2 | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Sub.Defs
import Aeneas.Data.Range.DivRange.Basic
namespace Aeneas
-- Auxiliary lemma - TODO: move?
theorem pow_ineq (start divisor : Nat) (hDiv : 1 < divisor) :
start ≤ divisor ^ (start + 1) := by
have h0 := Nat.log_le_self divisor start
have h1 : start <... | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Sub.Defs
import Aeneas.Data.Range.DivRange.Basic
namespace Aeneas
-- Auxiliary lemma - TODO: move?
theorem pow_ineq (start divisor : Nat) (hDiv : 1 < divisor) :
start ≤ divisor ^ (start + 1) := by
have h0 := Nat.log_le_self divisor start
have h1 : start <... | @@ -92,19 +92,66 @@
exists (k + k')
simp [*, Nat.div_div_eq_div_mul, Nat.pow_add]
+private theorem forIn'_loop_eq_forIn'_divRange [Monad m] (r : DivRange)
+ (fuel : Nat) (init : β) (f : (a : Nat) → a ∈ r → β → m (ForInStep β)) (i) (hk : ∃ k, i = r.start / r.divisor ^ k)
+ (hStart : i ≤ r.start) (hFuel... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
ablate_55078fa06512_2 | 400f213328e34242 | lean | lean | github.com/AeneasVerif/aeneas | 483333f74278333101795c4e55dbf09e50763f37 | Aeneas/Data/Range/DivRange/Lemmas.lean | Lemmas | 2 | lemma_delete | null | null | false | 0.5 | 1 | 1 | false | 0 | inf | 0 | inf | 42 | 3 | 1 | [
{
"theorem_name": "foldl_divRange_foldWhile",
"depth": 1,
"n_commands": 0,
"n_lines": 4,
"is_leaf": true,
"centrality": 0,
"method": "deleted-dep",
"proof_text": " by\n unfold divRange\n rw [foldl_divRange_loop_foldWhile]\n simp",
"n_chars": 65,
"n_subproofs": 0,
"n_ta... | [
{
"name": "foldl_divRange_loop_foldWhile",
"text": "private theorem foldl_divRange_loop_foldWhile (start stop div maxSteps : Nat) (hMaxSteps : start + 1 ≤ maxSteps)\n (hDiv : 1 < div) (f : α → Nat → α) (init : α) :\n List.foldl f init (divRange.loop stop div maxSteps start) = foldWhile stop div hDiv f sta... | [
{
"name": "foldl_divRange_foldWhile",
"fan_in": 0,
"n_deps_direct": 1,
"n_deps_transitive": 1,
"n_lines": 8,
"n_chars": 273,
"n_subproofs": 0,
"n_tactics": 4,
"cyclomatic": 1,
"n_automation": 1,
"n_rewrites": 2,
"n_structural": 0,
"automation_only": false,
"ma... | 1 | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Sub.Defs
import Aeneas.Data.Range.DivRange.Basic
namespace Aeneas
-- Auxiliary lemma - TODO: move?
theorem pow_ineq (start divisor : Nat) (hDiv : 1 < divisor) :
start ≤ divisor ^ (start + 1) := by
have h0 := Nat.log_le_self divisor start
have h1 : start <... | import Mathlib.Data.Nat.Log
import Mathlib.Algebra.Order.Sub.Defs
import Aeneas.Data.Range.DivRange.Basic
namespace Aeneas
-- Auxiliary lemma - TODO: move?
theorem pow_ineq (start divisor : Nat) (hDiv : 1 < divisor) :
start ≤ divisor ^ (start + 1) := by
have h0 := Nat.log_le_self divisor start
have h1 : start <... | @@ -192,9 +192,26 @@
conv => lhs; unfold foldWhile
simp [*]
+private theorem foldl_divRange_loop_foldWhile (start stop div maxSteps : Nat) (hMaxSteps : start + 1 ≤ maxSteps)
+ (hDiv : 1 < div) (f : α → Nat → α) (init : α) :
+ List.foldl f init (divRange.loop stop div maxSteps start) = foldWhile stop div hDiv ... | {
"repo": "aeneas",
"git_repo": "github.com/AeneasVerif/aeneas",
"revision": "483333f74278333101795c4e55dbf09e50763f37",
"lean_toolchain": "leanprover/lean4:v4.31.0",
"proof_assistant": "lean",
"ablator": "ablators/lean (corollary-delete-lemmas-leaves-all)",
"ablator_flags": [
"--corollary-delete-lemm... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.