From b50cf8b632b4c0bf55060af8c2294823ee074ba0 Mon Sep 17 00:00:00 2001 From: Will Cook <46428721+wcook04@users.noreply.github.com> Date: Mon, 16 Nov 2026 02:11:58 +0000 Subject: [PATCH 1/2] Add a one-off CI run that compiles the PCP modules and reads their dependencies The local build guard caps a build at 25 minutes; these 71 modules need hours. This runs only on its own branch and uploads the generated reports for review. Co-Authored-By: Claude Fable 5.2 --- .github/workflows/pcp-extract.yml | 66 +++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 .github/workflows/pcp-extract.yml diff --git a/.github/workflows/pcp-extract.yml b/.github/workflows/pcp-extract.yml new file mode 100644 index 0000000..4af5efe --- /dev/null +++ b/.github/workflows/pcp-extract.yml @@ -0,0 +1,66 @@ +# One-off: compile the PCP modules the three explanatory papers use, at the authors' +# toolchain, and read each declaration's dependencies and axioms from the compiled files. +# Runs only on its own branch; the generated reports are uploaded for review, not published. +name: Extract PCP dependencies from Lean +on: + push: + branches: [claude/pcp-lean-extraction-20261116] + paths: ['.github/workflows/pcp-extract.yml'] +permissions: + contents: read +jobs: + extract: + runs-on: ubuntu-24.04 + timeout-minutes: 350 + env: + PROJECT: papers/pcp-full-argument/lean + MODULES: "PCP.Algebraic.BLR PCP.Algebraic.BerlekampWelchCertificate PCP.Algebraic.BinaryDifferenceConsistency PCP.Algebraic.BinaryLocalCorrection PCP.Algebraic.BinaryLocalCorrectionSoundness PCP.Algebraic.BinaryLocalRowDecoding PCP.Algebraic.BinaryStandardLocalCorrection PCP.Algebraic.BinaryZeroOnGridCorrection PCP.Algebraic.BinaryZeroOnGridSoundness PCP.Algebraic.BivariateAgreement PCP.Algebraic.BivariateAgreementBoost PCP.Algebraic.BivariateAgreementFromRectangle PCP.Algebraic.BivariateCleanRectangle PCP.Algebraic.BivariateColumnSelection PCP.Algebraic.BivariateCrossingSoundness PCP.Algebraic.CandidateCrossing PCP.Algebraic.DerivedZeroOnGridSoundness PCP.Algebraic.EncodedLineLowDegreeSoundness PCP.Algebraic.EncodedLineLowDegreeTest PCP.Algebraic.GeneratorLowDegreeTest PCP.Algebraic.GridInterpolation PCP.Algebraic.GridVanishing PCP.Algebraic.Hadamard PCP.Algebraic.HadamardComposition PCP.Algebraic.HadamardCorrection PCP.Algebraic.HadamardDerivedOracle PCP.Algebraic.HadamardRowDecoding PCP.Algebraic.HadamardSoundness PCP.Algebraic.HadamardTest PCP.Algebraic.LineTableLocalCorrection PCP.Algebraic.PointLineConstant PCP.Algebraic.PointLineConstants PCP.Algebraic.PointLineCorrection PCP.Algebraic.PointLineCrossing PCP.Algebraic.PointLineEndpointConsistency PCP.Algebraic.PointLineParameterError PCP.Algebraic.PointLineSoundness PCP.Algebraic.PolynomialDistance PCP.Algebraic.PolynomialLineCharacterization PCP.Algebraic.RuledSurfaceRigidity PCP.Algebraic.SetMultilinear PCP.Algebraic.StandardLocalCorrection PCP.Algebraic.ThreeColorAlgebra PCP.Algebraic.ThreeColorAmplifiedVerifier PCP.Algebraic.ThreeColorBinaryVerifier PCP.Algebraic.ThreeColorCanonicalVerifier PCP.Algebraic.ThreeColorFields PCP.Algebraic.ThreeColorFinalAssembly PCP.Algebraic.ThreeColorFullFieldSampling PCP.Algebraic.ThreeColorGrid PCP.Algebraic.ThreeColorParameterChoice PCP.Algebraic.ThreeColorVerifier PCP.Algebraic.ThreeColorVerifierCompleteness PCP.Algebraic.ThreeColorVerifierSoundness PCP.Algebraic.VanishingCertificate PCP.Algebraic.WeightedConstraintSoundness PCP.Complexity.CostModel PCP.Complexity.Machine PCP.Complexity.NP PCP.Complexity.NPTableau PCP.Complexity.ReferenceNPConverse PCP.Complexity.TableauCells PCP.Complexity.ThreeColorRuntime PCP.Reduction.FiniteBooleanConstraints PCP.Reduction.FiniteDomainConstraints PCP.Reduction.NAEThreeColor PCP.Reduction.NPThreeColorRuntime PCP.ReverseConcrete PCP.Theorem PCP.Verifier.Definition PCP.Verifier.ReductionResources" + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 + with: + python-version: '3.12' + - name: Install elan and the project's Lean toolchain + run: | + curl -sSfL https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh | sh -s -- -y --default-toolchain none + echo "$HOME/.elan/bin" >> "$GITHUB_PATH" + - name: Restore an earlier build of this project, if one was saved + uses: actions/cache/restore@v4 + with: + path: papers/pcp-full-argument/lean/.lake + key: pcp-lake-${{ hashFiles('papers/pcp-full-argument/lean/lake-manifest.json', 'papers/pcp-full-argument/lean/lean-toolchain') }}-${{ github.run_id }} + restore-keys: pcp-lake-${{ hashFiles('papers/pcp-full-argument/lean/lake-manifest.json', 'papers/pcp-full-argument/lean/lean-toolchain') }}- + - name: Fetch Mathlib's compiled files (never built from source here) + working-directory: papers/pcp-full-argument/lean + run: lake exe cache get + - name: Compile the PCP modules + working-directory: papers/pcp-full-argument/lean + run: | + set -o pipefail + lake build $MODULES 2>&1 | tee "$RUNNER_TEMP/build.log" | { grep -v '^✔' || true; } + - name: Save the build so a rerun does not repeat it + if: always() + uses: actions/cache/save@v4 + with: + path: papers/pcp-full-argument/lean/.lake + key: pcp-lake-${{ hashFiles('papers/pcp-full-argument/lean/lake-manifest.json', 'papers/pcp-full-argument/lean/lean-toolchain') }}-${{ github.run_id }} + - name: The paper's Lean copy is unchanged by the build + run: git status --short papers/ && (git diff --quiet -- papers/ || echo "::warning::tracked files under papers/ changed during the build") + - name: Read dependencies and axioms from the compiled modules + run: | + for slug in pcp-exposition pcp-full-argument pcp-specialist; do + echo "== $slug" + python3 tools/extract_built.py "$slug" --project "$PROJECT" 2>&1 | tee "$RUNNER_TEMP/extract-$slug.log" || echo "extract $slug failed" >> "$RUNNER_TEMP/failed" + done + mkdir -p "$RUNNER_TEMP/out" + for slug in pcp-exposition pcp-full-argument pcp-specialist; do + mkdir -p "$RUNNER_TEMP/out/$slug" && cp "papers/$slug/generated/lean.json" "$RUNNER_TEMP/out/$slug/" && cp "$RUNNER_TEMP/extract-$slug.log" "$RUNNER_TEMP/out/$slug/" + done + cp "$RUNNER_TEMP/build.log" "$RUNNER_TEMP/out/" + git diff --stat -- papers/ | tail -5 + - uses: actions/upload-artifact@v4 + if: always() + with: + name: pcp-lean-reports + path: ${{ runner.temp }}/out + - run: test ! -e "$RUNNER_TEMP/failed" From 8c3ba9fe09f158a98286a8343f72d0a79173109c Mon Sep 17 00:00:00 2001 From: Will Cook <46428721+wcook04@users.noreply.github.com> Date: Mon, 16 Nov 2026 02:55:26 +0000 Subject: [PATCH 2/2] Show Lean's own dependencies and axiom reports for the three PCP papers Lean 4.35.0-rc2 compiled the 71 PCP modules these papers use in a GitHub Actions run (43790700983), and tools/extract_built.py read each declaration's statement, dependencies and axioms from the compiled files. Every declaration on the three pages now has Lean provenance, the headline theorem's proof included, so a result's graph shows what it uses instead of one card. Lean reports only propext, Classical.choice and Quot.sound. The real dependencies bring 213 more declarations onto the pages; each has a plain title written from its Lean, made with AI and not reviewed by the authors. Scope notes, the source review, the README and the journey test say what was run. The workflow stays, to be run by hand. Co-Authored-By: Claude Fable 5.2 --- .github/workflows/pcp-extract.yml | 11 +- README.md | 8 +- papers/pcp-exposition/generated/lean.json | 46094 +++++++-- papers/pcp-exposition/links.json | 86 +- papers/pcp-exposition/paper.toml | 2 +- papers/pcp-full-argument/generated/lean.json | 88173 +++++++++++++++-- papers/pcp-full-argument/links.json | 193 +- papers/pcp-full-argument/paper.toml | 2 +- papers/pcp-full-argument/source-review.md | 12 +- papers/pcp-specialist/generated/lean.json | 43855 ++++++-- papers/pcp-specialist/links.json | 49 +- papers/pcp-specialist/paper.toml | 2 +- tests/journey.py | 4 +- 13 files changed, 154887 insertions(+), 23604 deletions(-) diff --git a/.github/workflows/pcp-extract.yml b/.github/workflows/pcp-extract.yml index 4af5efe..6356f1f 100644 --- a/.github/workflows/pcp-extract.yml +++ b/.github/workflows/pcp-extract.yml @@ -1,11 +1,10 @@ -# One-off: compile the PCP modules the three explanatory papers use, at the authors' -# toolchain, and read each declaration's dependencies and axioms from the compiled files. -# Runs only on its own branch; the generated reports are uploaded for review, not published. +# Compile the PCP modules the three explanatory papers use, at the authors' toolchain, +# and read each declaration's dependencies and axioms from the compiled files. Run by +# hand; the generated reports are uploaded for review, not published. +# papers/pcp-full-argument/source-review.md records the run whose reports are committed. name: Extract PCP dependencies from Lean on: - push: - branches: [claude/pcp-lean-extraction-20261116] - paths: ['.github/workflows/pcp-extract.yml'] + workflow_dispatch: permissions: contents: read jobs: diff --git a/README.md b/README.md index 10703b2..99e21a3 100644 --- a/README.md +++ b/README.md @@ -48,10 +48,10 @@ comparisons are marked as AI-made and not reviewed by the authors. Comparisons c where one cites a Lean check written for the page, the check and its reported axioms are shown. Evidence differs by page. Some declaration data comes from Lean's report on compiled modules. -The PCP companions reuse the original guide's retained interface extraction, including a -statement-only compilation of the headline theorem. Their other selected declarations are -source-read: proof-use dependencies and axiom reports have not been extracted for those -declarations, and comparisons are held. The [source review](papers/pcp-full-argument/source-review.md) +For the three PCP companions, Lean compiled the listed modules of the authors' project in a +GitHub Actions run, and every declaration's dependencies and axiom report is Lean's output from +that run. The original guide's page keeps its earlier extraction, with a statement-only +compilation of the headline theorem. Comparisons of statements with their Lean are held. The [source review](papers/pcp-full-argument/source-review.md) records the source pin and hashes. Neither a source link nor a correspondence check establishes that the prose and Lean have the same meaning. diff --git a/papers/pcp-exposition/generated/lean.json b/papers/pcp-exposition/generated/lean.json index 1df6530..aa7de5b 100644 --- a/papers/pcp-exposition/generated/lean.json +++ b/papers/pcp-exposition/generated/lean.json @@ -1,7672 +1,38428 @@ { - "modules": [ - "PCP.Algebraic.BLR", - "PCP.Algebraic.BinaryLocalCorrection", - "PCP.Algebraic.BinaryLocalCorrectionSoundness", - "PCP.Algebraic.BinaryZeroOnGridSoundness", - "PCP.Algebraic.EncodedLineLowDegreeSoundness", - "PCP.Algebraic.EncodedLineLowDegreeTest", - "PCP.Algebraic.GeneratorLowDegreeTest", - "PCP.Algebraic.GridVanishing", - "PCP.Algebraic.Hadamard", - "PCP.Algebraic.HadamardSoundness", - "PCP.Algebraic.HadamardTest", + "declarations": [ + { + "axioms": [ + "propext" + ], + "doc": "Reading the first `N` bits of an oracle back out reproduces it below `N`. ", + "end_line": 219, + "is_class": false, + "kind": "theorem", + "line": 216, + "module": "PCP.Verifier.Definition", + "name": "PCP.oracleOfWitness_prefix", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (π : PCP.ProofOracle) (N : ℕ) {j : ℕ}, j < N → PCP.oracleOfWitness (List.map π (List.range N)) j = π j", + "type_dependencies": [ + "PCP.ProofOracle", + "Nat", + "LT.lt", + "instLTNat", + "Eq", + "Bool", + "PCP.oracleOfWitness", + "List.map", + "List.range" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every honest encoding passes every check, for every possible random choice. ", + "end_line": 150, + "is_class": false, + "kind": "theorem", + "line": 141, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testAccepts_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (x : Fin t → ZMod 2) (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n PCP.Algebraic.Hadamard.testAccepts hr (⇑(PCP.Algebraic.Hadamard.encode r x)) s", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.Hadamard.testAccepts", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "A proof oracle is an infinite Boolean string; `π a` is the bit at address `a`. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Verifier.Definition", + "name": "PCP.ProofOracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "Nat", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_C", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (a : R),\n (PCP.Algebraic.SetMultilinear.encode m c) (Polynomial.C a) = a • PCP.Algebraic.SetMultilinear.digitMonomial m c 0", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "RingHom", + "RingHom.instFunLike", + "Polynomial.C", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The independent inner test's average rejection is visible in actual rejection. ", + "end_line": 162, + "is_class": false, + "kind": "theorem", + "line": 137, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.average_inner_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (Finset.univ.expect fun b => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate ⋯ ρ nodes (H b)) ≤\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "LE.le", + "Rat", + "Rat.instLE", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "Pi.instFintype", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.SetMultilinear.Variables", + "instFintypeProd", + "Fin.fintype", + "instDecidableEqProd", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_prod._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),\n ∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a", + "type_dependencies": [ + "DivisionSemiring", + "Finset", + "Eq", + "Finset.sum", + "Semiring.toAddCommMonoid", + "DivisionSemiring.toSemiring", + "HDiv.hDiv", + "instHDiv", + "DivInvMonoid.toDiv", + "GroupWithZero.toDivInvMonoid", + "DivisionSemiring.toGroupWithZero" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodePair.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : List Bool × List Bool),\n PCP.Machine.encodePair p = PCP.Machine.ofBits p.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits p.2", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Logarithmic randomness as an upper bound: at most `a * ⌈log₂ (n + 2)⌉ + b` fair bits on\ninputs of length `n`.\n\n**This is too weak to be an efficiency hypothesis on its own.** An upper bound does not make\n`randomness` computable, and `Verifier.randomness` is an unrestricted function `ℕ → ℕ`. Take\n`randomness n = if f n then 1 else 0` for arbitrary `f`: the\nbound `LogRandomness 0 1` holds, yet the budget smuggles in an arbitrary Boolean function of the\ninput length, which an algorithm recovers just by measuring the length of the random string it is\nhanded. Use `CanonicalRandomness` wherever efficiency is at stake. ", + "end_line": 146, + "is_class": false, + "kind": "definition", + "line": 136, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.LogRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ → ℕ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "LE.le", + "instLENat", + "PCP.Verifier.randomness", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 48, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.fraction_shared_fst", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (E : W × S → Prop),\n (PCP.Algebraic.AffineLineSampling.fraction fun s => E (s.1, s.2.1)) = PCP.Algebraic.AffineLineSampling.fraction E", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.AffineLineSampling.fraction", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → ℕ → Type (max (max u_3 u_4) u_4 u_3)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every finite field has the full multiplicative generator required by the test. ", + "end_line": 149, + "is_class": false, + "kind": "theorem", + "line": 144, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_generator", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F], ∃ ζ, IsPrimitiveRoot ζ (Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Fintype", + "Exists", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "Nat", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.clauses._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {k : ℕ}, NeZero (k + 1)", + "type_dependencies": [ + "Nat", + "NeZero", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s =\n (List.ofFn fun i => PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i (s i)).flatten", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Eq", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.queries", + "List.flatten", + "List.ofFn", + "PCP.Algebraic.ThreeColorVerifier.branchQueries" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "theorem", + "line": 29, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "0 < PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "type_dependencies": [ + "LT.lt", + "Nat", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.decodedTable._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c : ℕ} [NeZero m]\n (Q : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F),\n (∀ (uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ), (Q uv).totalDegree ≤ c) →\n ∀ (uv : (σ → F) × (σ → F)), ((PCP.Algebraic.SetMultilinear.decode m c) (Q uv)).natDegree ≤ c * m ^ c", + "type_dependencies": [ + "Field", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Prod", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "constructor", + "line": 79, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.CostModel" + ], + "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 36, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.auxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} → PCP.Algebraic.Hadamard.TestRandomness t r → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Prod.fst", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.linearQuery.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n PCP.Algebraic.Hadamard.TestRandomness.linearQuery hr s = (PCP.Algebraic.BinaryPolynomialSpace.embed hr) s.linear", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Eq", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.Hadamard.TestRandomness.linearQuery", + "DFunLike.coe", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.embed", + "PCP.Algebraic.Hadamard.TestRandomness.linear" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 374, + "is_class": false, + "kind": "definition", + "line": 374, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A verifier algorithm is polynomial-time when some `FinTM2` machine computes its step function\nwithin a polynomial number of steps in the encoded input length. ", + "end_line": 73, + "is_class": false, + "kind": "definition", + "line": 69, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.PolyTimeAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.VerifierAlg → Prop", + "type_dependencies": [ + "PCP.VerifierAlg" + ], + "value_dependencies": [ + "PCP.VerifierAlg", + "Nonempty", + "Turing.TM2ComputableInPolyTime", + "Prod", + "List", + "Bool", + "Sum", + "Nat", + "PCP.Machine.Sym", + "PCP.Machine.encodeTriple", + "PCP.Machine.encodeAnswer", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Distinct messages have exactly one-half relative distance. ", + "end_line": 96, + "is_class": false, + "kind": "theorem", + "line": 87, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ},\n 1 ≤ r →\n ∀ (x y : Fin t → ZMod 2),\n x ≠ y →\n PCP.Algebraic.relativeDistance ⇑(PCP.Algebraic.Hadamard.encode r x) ⇑(PCP.Algebraic.Hadamard.encode r y) = 1 / 2", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Ne", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 388, + "is_class": false, + "kind": "theorem", + "line": 388, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyGridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t k : ℕ}, Nonempty (PCP.Algebraic.DerivedZeroOnGrid.GridRandomness F k m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] → [(a : List Bool) → SizeOf (L a)] → PCP.NPCertificate P L → ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "PCP.NPCertificate", + "Nat" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "PCP.NPCertificate", + "PCP.NPCertificate.rec", + "Nat", + "Polynomial", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "Polynomial._sizeOf_inst", + "instSizeOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨0, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 3 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 18 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "Decidable.byContradiction", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "If the oracles agree on every address the tree can reach, the tree cannot tell them apart. ", + "end_line": 77, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (T : PCP.QueryTree d) {π π' : PCP.ProofOracle}, (∀ a ∈ T.addresses, π a = π' a) → T.eval π = T.eval π'", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each concrete branch has the claimed count, including fresh derived-read seeds. ", + "end_line": 359, + "is_class": false, + "kind": "theorem", + "line": 322, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (i : Fin 7)\n (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i),\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i s).length ≤\n PCP.Algebraic.ThreeColorVerifier.branchQueryBound c i", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "PCP.Algebraic.ThreeColorVerifier.branchQueryBound" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.brecOn.go", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t ×' PCP.QueryTree.below t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PProd" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.QueryTree.rec", + "PProd", + "Bool", + "PProd.mk", + "PCP.QueryTree.leaf", + "PUnit", + "PUnit.unit", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ] + }, + { + "axioms": [], + "doc": "A flag after each of the `k` comparison bits, including the empty prefix. ", + "end_line": 68, + "is_class": false, + "kind": "definition", + "line": 67, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.Aux", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_4 → ℕ → Type (max u_4 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 1 →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Polynomial bound on witness length. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.witnessBound", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 481, + "is_class": false, + "kind": "theorem", + "line": 471, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_six", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 6 =\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate ⋯ π.color π.difference", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "Fin.fintype", + "instDecidableEqFin", + "Decidable.byContradiction", + "LE.le", + "instLENat", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 389, + "is_class": false, + "kind": "theorem", + "line": 389, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyTestSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t k r : ℕ}, Nonempty (PCP.Algebraic.DerivedZeroOnGrid.TestSample F k m c t r)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "A language over the binary alphabet: inputs are bit strings. ", + "end_line": 15, + "is_class": false, + "kind": "definition", + "line": 14, + "module": "PCP.Complexity.NP", + "name": "PCP.Language", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "List", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (d : ℕ) (f t : PCP.QueryTree d),\n (f.addresses ∪ t.addresses).card ≤ f.addresses.card + t.addresses.card →\n ¬(f.addresses ∪ t.addresses).card + 1 ≤ 1 + (f.addresses.card + t.addresses.card) → False", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "LE.le", + "instLENat", + "Finset.card", + "Union.union", + "Finset", + "Finset.instUnion", + "instDecidableEqNat", + "PCP.QueryTree.addresses", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instReprSym.repr", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym → ℕ → Format", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "Std.Format" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "PCP.Machine.instFintypeSym.match_5", + "Std.Format", + "Bool", + "Repr.addAppParen", + "Std.Format.group", + "Std.Format.nest", + "ite", + "Int", + "GE.ge", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.decLe", + "instOfNat", + "HAppend.hAppend", + "instHAppendOfAppend", + "Std.Format.instAppend", + "Std.Format.text", + "Std.Format.line", + "reprArg", + "instReprBool", + "Std.Format.FlattenBehavior.allOrNone", + "Unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A failed comparison also forces rejection, regardless of the inner test's outcome. ", + "end_line": 178, + "is_class": false, + "kind": "theorem", + "line": 164, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.comparison_error_le_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H fun z => ↑z) fun s =>\n f (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2.1) ((PCP.Algebraic.Hadamard.homogeneousIndex ⋯) s.2.2.1.2)) ≤\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The degree-one query viewed in the full oracle domain. ", + "end_line": 46, + "is_class": false, + "kind": "definition", + "line": 44, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.linearQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} → 1 ≤ r → PCP.Algebraic.Hadamard.TestRandomness t r → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "DFunLike.coe", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.embed", + "PCP.Algebraic.Hadamard.TestRandomness.linear" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Vertex", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Observation 3.8's second identity, sampling homogeneous linear queries. ", + "end_line": 194, + "is_class": false, + "kind": "theorem", + "line": 182, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_homogeneous_queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} {ι : Type u_1} [inst : Fintype ι] (hr : 1 ≤ r) (f g : ι → Fin t → ZMod 2),\n (PCP.Algebraic.relativeDistance\n (fun p => (PCP.Algebraic.Hadamard.encode r (f p.1)) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2)) fun p =>\n (PCP.Algebraic.Hadamard.encode r (g p.1)) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2)) =\n 1 / 2 * PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "Prod.fst", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Prod.snd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Fintype.decidablePiFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → ℕ", + "type_dependencies": [ + "PCP.CostModel", + "Nat" + ], + "value_dependencies": [ + "PCP.CostModel", + "PCP.CostModel.rec", + "Nat", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Verifier algorithms running in polynomial time. ", + "end_line": 83, + "is_class": false, + "kind": "definition", + "line": 83, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.PolyTimeAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → PCP.VerifierAlg → Prop", + "type_dependencies": [ + "PCP.CostModel", + "PCP.VerifierAlg" + ], + "value_dependencies": [ + "PCP.CostModel" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeTest.0.PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p)) →\n ((p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr" + ], + "value_dependencies": [ + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk", + "PCP.NPCertificate.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval._sunfold", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "PCP.QueryTree.eval.match_1", + "Bool", + "ite", + "Eq", + "Bool.true", + "instDecidableEqBool", + "PCP.QueryTree.eval" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.test_soundness._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {r : ℕ}, 2 ≤ r → ¬1 + (r - 1) ≤ r → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "The `k`-bit binary expansion of a random string index, least significant bit first. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Complexity.CostModel", + "name": "PCP.bitsOfFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → Fin (2 ^ k) → List Bool", + "type_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List", + "Bool" + ], + "value_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.map", + "Bool", + "Nat.testBit", + "Fin.val", + "List.range" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨3, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 1 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 14 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {color : PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t}\n {validLines differenceLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t}\n {properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t}\n {color_1 :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {validCert_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {difference_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {properCert_1 :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {colorLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t}\n {validLines_1 differenceLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t}\n {properLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t},\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines } =\n { color := color_1, validCert := validCert_1, difference := difference_1, properCert := properCert_1,\n colorLines := colorLines_1, validLines := validLines_1, differenceLines := differenceLines_1,\n properLines := properLines_1 } →\n color = color_1 ∧\n validCert = validCert_1 ∧\n difference = difference_1 ∧\n properCert = properCert_1 ∧\n colorLines = colorLines_1 ∧\n validLines = validLines_1 ∧ differenceLines = differenceLines_1 ∧ properLines = properLines_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "theorem", + "line": 123, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_eq_zero_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c → ((PCP.Algebraic.SetMultilinear.encode m c) P = 0 ↔ P = 0)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Iff", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Polynomial.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.BLR.sign 1 = -1", + "type_dependencies": [ + "Eq", + "Rat", + "PCP.Algebraic.BLR.sign", + "OfNat.ofNat", + "ZMod", + "Nat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Neg.neg", + "Rat.instNeg", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.edgeValue.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (x : Fin (n + n) → F),\n PCP.Algebraic.ThreeColorVerifier.edgeValue H G x =\n (MvPolynomial.eval (x ∘ ⇑(PCP.Algebraic.ThreeColorVerifier.flatten n)))\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Function.comp", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_mul_left", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (c : ℚ) (f : α → ℚ),\n (PCP.Algebraic.BLR.average fun x => c * f x) = c * PCP.Algebraic.BLR.average f", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 53, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.coe_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} (H : Finset F) (a b : σ → ↥H),\n (fun i => ↑(Sum.elim a b i)) = Sum.elim (fun i => ↑(a i)) fun i => ↑(b i)", + "type_dependencies": [ + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "Sum", + "Subtype.val", + "Sum.elim" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.difference" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d), (PCP.QueryTree.query a f t).addresses = insert a (f.addresses ∪ t.addresses)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "Finset", + "PCP.QueryTree.addresses", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 56, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodeTriple", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (t : List Bool × List Bool × List Bool),\n (PCP.Machine.encodeTriple t).length = t.1.length + t.2.1.length + t.2.2.length + 2", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "Nat", + "List.length", + "PCP.Machine.Sym", + "PCP.Machine.encodeTriple", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(P : (List Bool → List Bool → Bool) → Prop) →\n (L : PCP.Language) →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] →\n [(a : List Bool) → SizeOf (L a)] → SizeOf (PCP.NPCertificate P L)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "SizeOf.mk", + "PCP.NPCertificate", + "PCP.NPCertificate._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n 0 ≤ PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "LE.le", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 32, + "is_class": false, + "kind": "theorem", + "line": 31, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_variableCoeff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (x : Fin t → ZMod 2) (hr : 1 ≤ r) (i : Fin t),\n (PCP.Algebraic.Hadamard.encode r x) (PCP.Algebraic.BinaryPolynomialSpace.variableCoeff hr i) = x i", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness against an honestly encoded outer polynomial. The distance on\nthe left counts both `none` and an incorrect returned bit as failures. The inner\npolynomials are decoded from arbitrary received rows without a small-error premise. ", + "end_line": 313, + "is_class": false, + "kind": "theorem", + "line": 219, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {D : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) {δ : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) ≤\n δ →\n ∀ (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a)\n fun s =>\n some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2.2.1.2)) ≤\n PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a +\n δ +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "PCP.Algebraic.Hadamard.linearEncode", + "Prod.snd", + "Prod.fst", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.negate.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_1} (motive : PCP.Reduction.NAEThreeColor.Literal W → Sort u_2) (b : Bool)\n (h_1 : (b : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const b))\n (h_2 : (v : W) → (b : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var v b)),\n (match PCP.Reduction.NAEThreeColor.Literal.const b with\n | PCP.Reduction.NAEThreeColor.Literal.const b => h_1 b\n | PCP.Reduction.NAEThreeColor.Literal.var v b => h_2 v b) =\n h_1 b", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Eq", + "PCP.Reduction.FiniteBooleanConstraints.negate.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Acceptance probability, as an exact rational: the fraction of the `2 ^ randomness` equally\nlikely random strings on which `V` accepts. ", + "end_line": 104, + "is_class": false, + "kind": "definition", + "line": 101, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → PCP.ProofOracle → ℚ", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Rat" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.acceptingRandomness", + "Rat.instPowNat", + "Rat.instOfNat" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} → ℕ → Sort (max 1 u)", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "cond", + "Nat.ble", + "PULift", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 126, + "is_class": false, + "kind": "definition", + "line": 126, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.validCert a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness for every seed of the actual seven-branch conjunction. ", + "end_line": 98, + "is_class": false, + "kind": "theorem", + "line": 82, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.test_honestProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (P : MvPolynomial (Fin n) F)\n (MVal : MvPolynomial (Fin n ⊕ Fin n) F) (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n P.totalDegree < m ^ c →\n MVal.totalDegree < m ^ c →\n MProp.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal →\n PCP.Algebraic.GridVanishing.IsCertificate H\n ((MvPolynomial.rename ⇑(PCP.Algebraic.ThreeColorVerifier.flatten n))\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)))\n MProp →\n ∀ (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G\n (PCP.Algebraic.ThreeColorVerifier.honestProof ρ P MVal MProp) s =\n true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "DFunLike.coe", + "AlgHom", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "PCP.Algebraic.ThreeColorVerifier.honestProof", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.completeAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CompleteAt x", + "type_dependencies": [ + "List", + "Bool", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Verifier.CompleteAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness with an explicit upper bound on the rejection probability. ", + "end_line": 325, + "is_class": false, + "kind": "theorem", + "line": 320, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.exists_linearMap_distance_le_of_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (H : (ι → ZMod 2) → ZMod 2) {ε : ℚ},\n PCP.Algebraic.BLR.rejectionProbability H ≤ ε → ∃ L, PCP.Algebraic.relativeDistance H ⇑L ≤ ε", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.BLR.rejectionProbability", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Exists", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.relativeDistance", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap.instFunLike" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness at `x`: some proof is accepted with probability 1. ", + "end_line": 131, + "is_class": false, + "kind": "definition", + "line": 130, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CompleteAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → Prop", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Exists", + "PCP.ProofOracle", + "Eq", + "Rat", + "PCP.Verifier.accProb", + "OfNat.ofNat", + "Rat.instOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Exact normalized rejection of the seven-check finite verifier. ", + "end_line": 405, + "is_class": false, + "kind": "definition", + "line": 401, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F → (H : Finset F) → SimpleGraph (Fin n → ↥H) → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.FiniteConjunction.rejectionRate", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.fintype", + "instDecidableEqFin", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)),\n sizeOf\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n 1", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "SizeOf.sizeOf", + "PCP.CostModel", + "PCP.CostModel._sizeOf_inst", + "PCP.CostModel.mk", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "recursor", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n (t : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) → motive t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The common label keeps its uniform marginal when the two independent call seeds are added. ", + "end_line": 83, + "is_class": false, + "kind": "theorem", + "line": 74, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.distance_lift_labels", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} {S : Type u_3} {A : Type u_4} [inst : Fintype X] [inst_1 : Fintype W]\n [inst_2 : Fintype S] [Nonempty S] [inst_4 : DecidableEq A] (f g : X × W → A),\n (PCP.Algebraic.relativeDistance (fun s => f (s.1, s.2.1)) fun s => g (s.1, s.2.1)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "The randomness budget is **exactly** `a * ⌈log₂ (n + 2)⌉ + b`.\n\nTwo constants determine the whole budget, so it is computable by construction and carries no\ninformation of its own. This is the \"canonical computable budget\" repair: it closes the hole that\n`LogRandomness` leaves open, and it is without loss of generality because a verifier that wants\nfewer bits can ignore the surplus. ", + "end_line": 155, + "is_class": false, + "kind": "definition", + "line": 148, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CanonicalRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ → ℕ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "Eq", + "PCP.Verifier.randomness", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 139, + "is_class": false, + "kind": "theorem", + "line": 138, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testRejectionRate_le_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.testRejectionRate hr H ≤ 1", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Rat", + "Rat.instLE", + "PCP.Algebraic.Hadamard.testRejectionRate", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 375, + "is_class": false, + "kind": "definition", + "line": 375, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Correlation with a Walsh character is precisely the agreement bias. ", + "end_line": 303, + "is_class": false, + "kind": "theorem", + "line": 300, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier_sign_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (H : (ι → ZMod 2) → ZMod 2) (a : ι → ZMod 2),\n PCP.Algebraic.BLR.fourier (fun x => PCP.Algebraic.BLR.sign (H x)) a =\n 1 - 2 * PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.BLR.linearForm a)", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.sign", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Normalized rational Walsh coefficient. ", + "end_line": 194, + "is_class": false, + "kind": "definition", + "line": 192, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier", + "provenance": "lean", + "structural_dependencies": [], + "type": "{ι : Type u_1} → [Fintype ι] → [DecidableEq ι] → ((ι → ZMod 2) → ℚ) → (ι → ZMod 2) → ℚ", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "PCP.Algebraic.BLR.fourier._proof_1", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.rec" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.factorDegree_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {r : ℕ} (k : Fin (r - 1)), ↑k + 1 ≤ r", + "type_dependencies": [ + "Nat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The virtual point-line rejection factor, after both binary decoding steps. ", + "end_line": 47, + "is_class": false, + "kind": "definition", + "line": 45, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "Rat", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instAddNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The NP checking relation induced by a verifier: accept `(x, w)` when the finite witness `w`,\nread as a proof, makes `V` accept on *every* random string.\n\nThis is decidable because the random space `Fin (2 ^ randomness)` is finite, which is the whole\npoint: perfect completeness turns into a finite check. Whether it is *polynomial-time* decidable\nis a separate question, answered by `CostModel.polyTimeRel_finiteWitnessCheck`. ", + "end_line": 210, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Verifier.Definition", + "name": "PCP.finiteWitnessCheck", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → List Bool → Bool", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Decidable.decide", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Eq", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "PCP.oracleOfWitness", + "Bool.true", + "Nat.decidableForallFin", + "instDecidableEqBool" + ] + }, + { + "axioms": [], + "doc": "The input patterns range over exactly `2^k` choices. ", + "end_line": 65, + "is_class": false, + "kind": "definition", + "line": 64, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Fin", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testAccepts.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n PCP.Algebraic.Hadamard.testAccepts hr H s =\n (H (s.base + s.auxiliary) = H s.base + H s.auxiliary ∧\n H (PCP.Algebraic.BinaryPolynomialSpace.constant 1 + s.base) - H s.base = 1 ∧\n H (PCP.Algebraic.Hadamard.TestRandomness.linearQuery hr s + s.base) - H s.base =\n H (PCP.Algebraic.Hadamard.TestRandomness.linearQuery hr s) ∧\n ∀ (k : Fin (r - 1)),\n H (s.productQuery k + s.base) - H s.base =\n (H (PCP.Algebraic.Hadamard.TestRandomness.linearQuery hr s + s.base) - H s.base) *\n (H (s.factorQuery k + s.base) - H s.base))", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness", + "Eq", + "PCP.Algebraic.Hadamard.testAccepts", + "And", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "PCP.Algebraic.Hadamard.TestRandomness.base", + "PCP.Algebraic.Hadamard.TestRandomness.auxiliary", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.BinaryPolynomialSpace.constant", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "PCP.Algebraic.Hadamard.TestRandomness.linearQuery", + "Fin", + "instSubNat", + "PCP.Algebraic.Hadamard.TestRandomness.productQuery", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "PCP.Algebraic.Hadamard.TestRandomness.factorQuery" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The low-degree extension of the input graph's zero-one adjacency table. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 59, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [Fintype σ] → [DecidableEq σ] → [DecidableEq F] → (H : Finset F) → SimpleGraph (σ → ↥H) → MvPolynomial (σ ⊕ σ) F", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Sum", + "MvPolynomial", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.GridInterpolation.interpolate", + "instFintypeSum", + "instDecidableEqSum", + "ite", + "SimpleGraph.Adj", + "Sum.inl", + "Sum.inr", + "Classical.propDecidable", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testRejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.testRejectionRate hr H =\n PCP.Algebraic.relativeDistance (PCP.Algebraic.Hadamard.test hr H) fun x => true", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.Hadamard.testRejectionRate", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.Hadamard.TestRandomness", + "Bool", + "instFintypeProd", + "Prod", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.Hadamard.testRejectionRate._proof_1", + "instDecidableEqBool", + "PCP.Algebraic.Hadamard.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 68, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.distance_shared_snd", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} {A : Type u_4} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S]\n [inst_3 : DecidableEq A] (f g : W × S → A),\n (PCP.Algebraic.relativeDistance (fun s => f (s.1, s.2.2)) fun s => g (s.1, s.2.2)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A binary relation on bit strings is polynomial-time when some `FinTM2` machine computes it\nwithin a polynomial number of steps in the encoded input length. ", + "end_line": 67, + "is_class": false, + "kind": "definition", + "line": 64, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.PolyTimeRel", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → List Bool → Bool) → Prop", + "type_dependencies": [ + "List", + "Bool" + ], + "value_dependencies": [ + "List", + "Bool", + "Nonempty", + "Turing.TM2ComputableInPolyTime", + "Prod", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Auxiliary inner rejection is another normalized marginal of actual rejection. ", + "end_line": 145, + "is_class": false, + "kind": "theorem", + "line": 114, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.inner_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n (Finset.univ.expect fun uv => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate ⋯ ρ nodes (H uv)) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "Finset.expect", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.SetMultilinear.Variables", + "Fin.fintype", + "instDecidableEqProd", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "definition", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ),\n ¬n ≤ c + 1 → ∀ (i : Fin (c + 1)), ↑i < c → ¬↑i + 1 + (n - (c + 1)) < n → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "LT.lt", + "instLTNat", + "Fin.val", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 153, + "is_class": false, + "kind": "theorem", + "line": 151, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character_add", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x y : ι → ZMod 2),\n PCP.Algebraic.BLR.character a (x + y) = PCP.Algebraic.BLR.character a x * PCP.Algebraic.BLR.character a y", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.character", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testAccepts_congr._simp_1_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {n : ℕ} (x : Fin n), (x ∈ List.finRange n) = True", + "type_dependencies": [ + "Nat", + "Fin", + "Eq", + "Membership.mem", + "List", + "List.instMembership", + "List.finRange", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "constructor", + "line": 127, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The tree reads at most `d` bits along any branch: its address set has at most `2 ^ d - 1`\nelements, and along a single run at most `d` queries are made. ", + "end_line": 65, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (T : PCP.QueryTree d), T.addresses.card < 2 ^ d", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The section 5 procedure; `none` denotes rejection. ", + "end_line": 59, + "is_class": false, + "kind": "definition", + "line": 44, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n (σ → F) →\n (σ → F) →\n Fˣ →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n (Fin t → ZMod 2) → PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t → Option (ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Option" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "ite", + "Option", + "Eq", + "Bool", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "Bool.true", + "instDecidableEqBool", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq", + "Option.some", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Option.none" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Reindexing the actual full corrector sample separates its uniform requested label. ", + "end_line": 244, + "is_class": false, + "kind": "theorem", + "line": 209, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.call_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (M : MvPolynomial (Fin n ⊕ Fin n) F),\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n {δ : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δ →\n ∀ (a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n),\n (PCP.Algebraic.relativeDistance\n (fun ws => PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M' A a ws.1 ws.2)\n fun ws => some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) M))) ws.1)) ≤\n (PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.AffineLineSampling.fraction fun ws =>\n PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M' A a ws.1 ws.2 = none) +\n δ +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.relativeDistance", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeCallSeedSumFin_1", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "Prod.fst", + "Prod.snd", + "Option.some", + "PCP.Algebraic.Hadamard.linearEncode", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.AffineLineSampling.fraction", + "Eq", + "Option.none", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Rat.instOfNat", + "HSub.hSub", + "instHSub", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 133, + "is_class": false, + "kind": "theorem", + "line": 132, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2), (PCP.Algebraic.BLR.linearForm a) x = ∑ i, a i * x i", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm", + "Finset.sum", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 385, + "is_class": false, + "kind": "theorem", + "line": 385, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F] {m c t : ℕ}, Nonempty (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.5, in Boolean coordinates. ", + "end_line": 26, + "is_class": false, + "kind": "definition", + "line": 24, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t : ℕ} → (r : ℕ) → (Fin t → ZMod 2) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r →ₗ[ZMod 2] ZMod 2", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.evaluate" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.ClauseHolds.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_3} (q : Fin 3 → PCP.Reduction.NAEThreeColor.Literal W) (a : W → Bool),\n PCP.Reduction.FiniteBooleanConstraints.ClauseHolds q a =\n (PCP.Reduction.NAEThreeColor.Literal.eval a (q 0) = true ∨\n PCP.Reduction.NAEThreeColor.Literal.eval a (q 1) = true ∨ PCP.Reduction.NAEThreeColor.Literal.eval a (q 2) = true)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "Eq", + "PCP.Reduction.FiniteBooleanConstraints.ClauseHolds", + "Or", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "Fin.instOfNat", + "PCP.Reduction.FiniteBooleanConstraints.ClauseHolds._proof_1", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.expect_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : Fintype B] (k : A × B → ℚ),\n (Finset.univ.expect fun p => k p) = Finset.univ.expect fun a => Finset.univ.expect fun b => k (a, b)", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language}\n [inst : (a : List Bool → List Bool → Bool) → SizeOf (P a)] [inst_1 : (a : List Bool) → SizeOf (L a)]\n (witnessBound : Polynomial ℕ) (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true),\n sizeOf { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n 1 + sizeOf witnessBound + sizeOf check_polyTime", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "SizeOf.sizeOf", + "PCP.NPCertificate", + "PCP.NPCertificate._sizeOf_inst", + "PCP.NPCertificate.mk", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial._sizeOf_inst", + "instSizeOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Stop and accept (`true`) or reject (`false`). ", + "end_line": 35, + "is_class": false, + "kind": "constructor", + "line": 34, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf", + "provenance": "lean", + "structural_dependencies": [ + "PCP.QueryTree" + ], + "type": "{d : ℕ} → Bool → PCP.QueryTree d", + "type_dependencies": [ + "Nat", + "Bool", + "PCP.QueryTree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 97, + "is_class": false, + "kind": "theorem", + "line": 94, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testQueries_card_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n (PCP.Algebraic.Hadamard.testQueries hr s).toFinset.card ≤ 2 * r + 4", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Finset.card", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "List.toFinset", + "Fintype.decidablePiFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "ZMod.decidableEq", + "Subtype.fintype", + "Finset", + "Fin", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "PCP.Algebraic.Hadamard.testQueries", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 124, + "is_class": false, + "kind": "theorem", + "line": 120, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.test_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (s : PCP.Algebraic.Hadamard.TestRandomness t r)\n (H H' : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n (∀ p ∈ PCP.Algebraic.Hadamard.testQueries hr s, H p = H' p) →\n PCP.Algebraic.Hadamard.test hr H s = PCP.Algebraic.Hadamard.test hr H' s", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.Hadamard.testQueries", + "Eq", + "Bool", + "PCP.Algebraic.Hadamard.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The two grid equations are precisely the vertex and edge constraints. ", + "end_line": 114, + "is_class": false, + "kind": "theorem", + "line": 90, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.constraints_iff_satisfies", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)) (P : MvPolynomial σ F),\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) ∧\n PCP.Algebraic.GridVanishing.VanishesOn H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)) ↔\n PCP.Algebraic.ThreeColorAlgebra.Satisfies G fun a => (MvPolynomial.eval fun i => ↑(a i)) P", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Iff", + "And", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "Sum", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.ThreeColorAlgebra.Satisfies", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match d + 1, PCP.QueryTree.query a f t with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_2 d a f t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.addresses.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodePair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : List Bool × List Bool), (PCP.Machine.encodePair p).length = p.1.length + p.2.length + 1", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "Nat", + "List.length", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 174, + "is_class": false, + "kind": "theorem", + "line": 160, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_character", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (a : ι → ZMod 2),\n PCP.Algebraic.BLR.average (PCP.Algebraic.BLR.character a) = if a = 0 then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BLR.character", + "ite", + "Zero.toOfNat0", + "Pi.instZero", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Fintype.decidablePiFintype", + "ZMod.decidableEq", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "theorem", + "line": 78, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.generator_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {ζ : F}, IsPrimitiveRoot ζ (Fintype.card F - 1) → ζ ≠ 0", + "type_dependencies": [ + "Field", + "Fintype", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "Nat", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat", + "Ne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 24, + "is_class": false, + "kind": "constructor", + "line": 24, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.sep", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Machine.Sym" + ], + "type": "PCP.Machine.Sym", + "type_dependencies": [ + "PCP.Machine.Sym" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 52, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 70, + "is_class": false, + "kind": "definition", + "line": 70, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.Variable", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_4 → Type u_5 → ℕ → Type (max u_4 u_5)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "PCP.Reduction.FiniteBooleanConstraints.Aux" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueryBound.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ),\n PCP.Algebraic.ThreeColorVerifier.branchQueryBound c =\n ![2 * c + 18, 2 * c + 14, 2 * c + 18, 2 * c + 14, 6 * c + 20, 6 * c + 20, 3]", + "type_dependencies": [ + "Nat", + "Eq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.branchQueryBound", + "Matrix.vecCons", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "definition", + "line": 128, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 3 →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testAccepts_congr._simp_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l)", + "type_dependencies": [ + "List", + "Eq", + "Membership.mem", + "List.instMembership", + "List.cons", + "Or" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 182, + "is_class": false, + "kind": "definition", + "line": 180, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.Query.difference" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : Bool), ¬a = b → PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit b → False", + "type_dependencies": [ + "Bool", + "Not", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) → Function.Injective (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Function.Injective", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n (PCP.Algebraic.SetMultilinear.encode m c) P =\n ∑ k ∈ P.support, P.coeff k • PCP.Algebraic.SetMultilinear.digitMonomial m c k", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Finset.sum", + "Polynomial.support", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "instMulZeroClassOfSemiring", + "Finsupp.instFunLike", + "Polynomial.coeff", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 416, + "is_class": false, + "kind": "theorem", + "line": 413, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n 0 ≤ PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "LE.le", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t r : ℕ} →\n [Fintype F] →\n Fintype (PCP.Algebraic.Hadamard.TestRandomness t r × PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each branch accepts the same honest eight-table proof for every seed. ", + "end_line": 79, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest_honestProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (P : MvPolynomial (Fin n) F)\n (MVal : MvPolynomial (Fin n ⊕ Fin n) F) (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n P.totalDegree < m ^ c →\n MVal.totalDegree < m ^ c →\n MProp.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal →\n PCP.Algebraic.GridVanishing.IsCertificate H\n ((MvPolynomial.rename ⇑(PCP.Algebraic.ThreeColorVerifier.flatten n))\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)))\n MProp →\n ∀ (i : Fin 7) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i),\n PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G\n (PCP.Algebraic.ThreeColorVerifier.honestProof ρ P MVal MProp) i s =\n true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "DFunLike.coe", + "AlgHom", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.branchTest", + "PCP.Algebraic.ThreeColorVerifier.honestProof", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness of the actual two-corrector grid verifier against nearby polynomial encodings.\nBoth proximity hypotheses are global homogeneous-query distances.\nThe auxiliary proof is arbitrary. ", + "end_line": 298, + "is_class": false, + "kind": "theorem", + "line": 246, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_lower_bound", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ p' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) ≤\n δP →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δM →\n (1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 ≤\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) *\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p' M' A +\n δP +\n 2 * δM +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "Fin.fintype", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instFintypeSum", + "instDecidableEqSum", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ),\n IsScalarTower R R (AddMonoidAlgebra R (PCP.Algebraic.SetMultilinear.Variables m c →₀ ℕ))", + "type_dependencies": [ + "CommSemiring", + "Nat", + "IsScalarTower", + "AddMonoidAlgebra", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddMonoidWithOne.toAddMonoid", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "AddMonoidAlgebra.instAddMonoid", + "AddMonoidAlgebra.smulZeroClass" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Option (ZMod 2) → Option (ZMod 2) → Option (ZMod 2) → Sort u_1) →\n (p m₀ mZ : Option (ZMod 2)) →\n ((p m₀ mZ : ZMod 2) → motive (some p) (some m₀) (some mZ)) →\n ((x x_1 x_2 : Option (ZMod 2)) →\n (∀ (p m₀ mZ : ZMod 2), x = some p → x_1 = some m₀ → x_2 = some mZ → False) → motive x x_1 x_2) →\n motive p m₀ mZ", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "False" + ], + "value_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "False", + "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.splitter._sparseCasesOn_2", + "Nat.hasNotBit", + "Option.ctorIdx", + "Option.some.noConfusion", + "HEq", + "Eq.ndrec", + "absurd", + "Nat.land", + "Nat.shiftRight", + "Nat.eq_of_beq_eq_true", + "Eq.refl", + "Bool", + "Bool.true", + "Eq.symm" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testQueries_length._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {r : ℕ}, 1 ≤ r → ¬(r - 1) * 2 + 1 + 1 = 2 * r → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeTest.0.PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p))\n (h_2 :\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inl p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_1 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(a : ℕ) → SizeOf (PCP.QueryTree a)", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "SizeOf.mk", + "PCP.QueryTree", + "PCP.QueryTree._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 101, + "is_class": false, + "kind": "theorem", + "line": 93, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.weights_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) → ∀ (i : Fin (c + 1)), PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i ≠ 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Ne", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 65, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.queries_length", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (u v : σ → F),\n (PCP.Algebraic.GeneratorLowDegreeTest.queries c ζ u v).length = c + 2", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "List.length", + "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encode._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries_length_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 0 (s 0)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 1 (s 1)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 2 (s 2)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 3 (s 3)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 4 (s 4)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 5 (s 5)).length +\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 6 (s 6)).length))))) ≤\n 2 * c + 18 + (2 * c + 14 + (2 * c + 18 + (2 * c + 14 + (6 * c + 20 + (6 * c + 20 + 3))))) →\n ¬(PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 0 (s 0)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 1 (s 1)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 2 (s 2)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 3 (s 3)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 4 (s 4)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 5 (s 5)).length +\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 6 (s 6)).length))))) ≤\n 20 * c + 107 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "LE.le", + "Preorder.toLE", + "Nat.instPreorder", + "AddZero.toAdd", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddCommMonoid.toAddMonoid", + "Nat.instAddCommMonoid", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "Fin.instOfNat", + "instNeZeroNatHAdd_1", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "instLENat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.negate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_3} (b : Bool),\n PCP.Reduction.FiniteBooleanConstraints.negate (PCP.Reduction.NAEThreeColor.Literal.const b) =\n PCP.Reduction.NAEThreeColor.Literal.const !b", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.negate", + "PCP.Reduction.NAEThreeColor.Literal.const", + "Bool.not" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (ctorIdx : ℕ) → (t : PCP.Machine.Sym) → ctorIdx = t.ctorIdx → PCP.Machine.Sym.ctorElimType ctorIdx → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "Eq", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.ctorElimType" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "Eq", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.ctorElimType", + "PCP.Machine.Sym.casesOn", + "Bool", + "PULift.down", + "PCP.Machine.Sym.bit", + "Eq.ndrec", + "PCP.Machine.Sym.sep" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The witness-checking relation. ", + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → List Bool → List Bool → Bool", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 210, + "is_class": false, + "kind": "theorem", + "line": 196, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.inversion", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ) (x : ι → ZMod 2),\n ∑ a, PCP.Algebraic.BLR.fourier f a * PCP.Algebraic.BLR.character a x = f x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every actual branch rate is bounded by the combined rate, with no branch factor. ", + "end_line": 423, + "is_class": false, + "kind": "theorem", + "line": 418, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (i : Fin 7),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π i ≤\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "definition", + "line": 23, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → t.ctorIdx = 0 → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "Bool", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Likewise for the proper certificate, after flattening the constraint coordinates. ", + "end_line": 80, + "is_class": false, + "kind": "definition", + "line": 77, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properAuxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F (n + n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines", + "Prod.mk", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_mul_sign", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : ZMod 2), PCP.Algebraic.BLR.sign a * PCP.Algebraic.BLR.sign b = if a = b then 1 else -1", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.sign", + "ite", + "ZMod.decidableEq", + "Rat.instOfNat", + "Neg.neg", + "Rat.instNeg" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Encoding of a verifier algorithm's answer. A halt decision is one bit; a query is the\nseparator followed by the address in binary. ", + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeAnswer", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool ⊕ ℕ → List PCP.Machine.Sym", + "type_dependencies": [ + "Sum", + "Bool", + "Nat", + "List", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Nat", + "PCP.Machine.encodeAnswer.match_1", + "List", + "PCP.Machine.Sym", + "List.cons", + "PCP.Machine.Sym.bit", + "List.nil", + "PCP.Machine.Sym.sep", + "PCP.Machine.ofBits", + "Nat.bits" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 62, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.distance_shared_fst", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} {A : Type u_4} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S]\n [inst_3 : DecidableEq A] (f g : W × S → A),\n (PCP.Algebraic.relativeDistance (fun s => f (s.1, s.2.1)) fun s => g (s.1, s.2.1)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 232, + "is_class": false, + "kind": "theorem", + "line": 229, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_properQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.properQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.properCert π.properLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.properQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instFintypeSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "Fintype PCP.Machine.Sym", + "type_dependencies": [ + "Fintype", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Fintype.ofEquiv", + "PCP.Machine.Sym", + "Sum", + "Bool", + "Unit", + "instFintypeSum", + "Bool.fintype", + "PUnit.fintype", + "PCP.Machine.Sym.proxyTypeEquiv" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (0 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n PCP.Algebraic.EncodedLineLowDegreeTest.read f H (Sum.inr p) = H p.1 p.2.1 p.2.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "Sum.inr", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 31, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → ℕ → ℕ → ℕ → Type u_3", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every original solution extends to the constructed ternary clauses. ", + "end_line": 184, + "is_class": false, + "kind": "theorem", + "line": 173, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.extend_satisfies", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} (relation : C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool)\n (scope : C → Fin k → V) (a : V → Bool),\n PCP.Reduction.FiniteBooleanConstraints.LocalHolds relation scope a →\n PCP.Reduction.ThreeSATToColor.Satisfies (PCP.Reduction.FiniteBooleanConstraints.clauses relation scope)\n (PCP.Reduction.FiniteBooleanConstraints.extend scope a)", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "PCP.Reduction.FiniteBooleanConstraints.LocalHolds", + "PCP.Reduction.ThreeSATToColor.Satisfies", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.clauses", + "PCP.Reduction.FiniteBooleanConstraints.extend" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 155, + "is_class": false, + "kind": "theorem", + "line": 152, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n 0 ≤ PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Complete runtime certificate for the production amplified verifier. ", + "end_line": 15, + "is_class": false, + "kind": "theorem", + "line": 10, + "module": "PCP.Complexity.ThreeColorRuntime", + "name": "PCP.Lang.ThreeColorRuntime.polyTimeAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.PolyTimeAlg PCP.Algebraic.ComputableThreeColorAmplifiedQueryAlgorithm.algorithm", + "type_dependencies": [ + "PCP.Machine.PolyTimeAlg", + "PCP.Algebraic.ComputableThreeColorAmplifiedQueryAlgorithm.algorithm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testRejectionRate_eq_zero_iff._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x", + "type_dependencies": [ + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.NAEThreeColor.Literal.eval.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a : V → Bool) (a_1 : Bool),\n PCP.Reduction.NAEThreeColor.Literal.eval a (PCP.Reduction.NAEThreeColor.Literal.const a_1) = a_1", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "PCP.Reduction.NAEThreeColor.Literal.const" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "SizeOf PCP.Verifier", + "type_dependencies": [ + "SizeOf", + "PCP.Verifier" + ], + "value_dependencies": [ + "SizeOf.mk", + "PCP.Verifier", + "PCP.Verifier._sizeOf_1" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_monomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ) (a : R),\n (PCP.Algebraic.SetMultilinear.encode m c) ((Polynomial.monomial k) a) =\n a • PCP.Algebraic.SetMultilinear.digitMonomial m c k", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.monomial", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Parseval's identity, with normalized coefficients and an unnormalized dual sum. ", + "end_line": 232, + "is_class": false, + "kind": "theorem", + "line": 229, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.parseval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ),\n ∑ a, PCP.Algebraic.BLR.fourier f a ^ 2 = PCP.Algebraic.BLR.average fun x => f x ^ 2", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.average" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.test.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n PCP.Algebraic.Hadamard.test hr H s = decide (PCP.Algebraic.Hadamard.testAccepts hr H s)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness", + "Eq", + "Bool", + "PCP.Algebraic.Hadamard.test", + "Decidable.decide", + "PCP.Algebraic.Hadamard.testAccepts", + "Classical.propDecidable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.queries_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.queries = PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 187", + "type_dependencies": [ + "Eq", + "Nat", + "PCP.Verifier.queries", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → ℕ", + "type_dependencies": [ + "PCP.CostModel", + "Nat" + ], + "value_dependencies": [ + "PCP.CostModel" + ] + }, + { + "axioms": [], + "doc": "A bit string as tape symbols. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.ofBits", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "List", + "Bool", + "List.map", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ] + }, + { + "axioms": [], + "doc": "Run the decision tree against a proof oracle. ", + "end_line": 44, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "PCP.QueryTree.brecOn", + "Bool", + "PCP.QueryTree.eval._f" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.factor", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} →\n PCP.Algebraic.Hadamard.TestRandomness t r →\n (k : Fin (r - 1)) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t (↑k + 1)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "Prod.snd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Prod" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} {a_2 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.properCert a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The four primary tables and their four shared encoded-line tables. ", + "end_line": 45, + "is_class": false, + "kind": "inductive", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Bound on the number of proof **bits** read (bits, not larger proof symbols). ", + "end_line": 89, + "is_class": false, + "kind": "definition", + "line": 89, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} {S : Type u_3} (p : X → W → ZMod 2) (a b : X → W → S → Option (ZMod 2))\n (s : X × W × S × S),\n PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck p a b s =\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck (some (p s.1 s.2.1)) (a s.1 s.2.1 s.2.2.1) (b s.1 s.2.1 s.2.2.2)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Prod", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Prop) (x : ℕ) (x_1 : PCP.QueryTree x),\n (∀ (x : ℕ) (accept : Bool), motive x (PCP.QueryTree.leaf accept)) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d), motive d.succ (PCP.QueryTree.query a f t)) → motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "Nat.succ", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "Nat.succ", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "Eq", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 46, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.fraction_prod", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} [inst : Fintype X] [inst_1 : Fintype W] (E : X × W → Prop),\n PCP.Algebraic.AffineLineSampling.fraction E =\n Finset.univ.expect fun x => PCP.Algebraic.AffineLineSampling.fraction fun w => E (x, w)", + "type_dependencies": [ + "Fintype", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.AffineLineSampling.fraction", + "instFintypeProd", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → PCP.CostModel → PCP.CostModel → Sort u", + "type_dependencies": [ + "PCP.CostModel" + ], + "value_dependencies": [ + "PCP.CostModel", + "PCP.CostModel.casesOn", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The Walsh basis is orthonormal for the uniform average. ", + "end_line": 227, + "is_class": false, + "kind": "theorem", + "line": 212, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.pairing", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f g : (ι → ZMod 2) → ℚ),\n ∑ a, PCP.Algebraic.BLR.fourier f a * PCP.Algebraic.BLR.fourier g a = PCP.Algebraic.BLR.average fun x => f x * g x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.average" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.weights.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (c : ℕ) (ζ : F),\n PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ =\n PCP.Algebraic.LagrangeConstraint.weight (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) 0", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "PCP.Algebraic.LagrangeConstraint.weight", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each branch's physical queries occur in the complete list. ", + "end_line": 298, + "is_class": false, + "kind": "theorem", + "line": 292, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.mem_queries_of_branch", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t) (i : Fin 7)\n {q : PCP.Algebraic.ThreeColorVerifier.Query F n m c t},\n q ∈ PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i (s i) →\n q ∈ PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "PCP.Algebraic.ThreeColorVerifier.queries" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness: a polynomial-time relation is computable. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 85, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.polyTimeRel_computable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (self : PCP.CostModel) (R : List Bool → List Bool → Bool), self.PolyTimeRel R → Computable₂ R", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.CostModel.PolyTimeRel", + "Computable₂", + "Primcodable.list", + "Primcodable.bool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.two_mul_nonzero_count._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", + "type_dependencies": [ + "Fintype", + "Eq", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.univ", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.1, extended linearly to all univariate polynomials. ", + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] →\n (m : ℕ) → [NeZero m] → (c : ℕ) → Polynomial R →ₗ[R] MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial.lsum", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.smulRight", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.SetMultilinear.encode._proof_1", + "LinearMap.id", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "Fair random bits used on inputs of length `n`. ", + "end_line": 87, + "is_class": false, + "kind": "definition", + "line": 87, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.randomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [], + "doc": "Prefix comparison, executable without enumerating the whole assignment space. ", + "end_line": 92, + "is_class": false, + "kind": "definition", + "line": 90, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.flag", + "provenance": "lean", + "structural_dependencies": [], + "type": "{k : ℕ} → PCP.Reduction.FiniteBooleanConstraints.Pattern k → PCP.Reduction.FiniteBooleanConstraints.Pattern k → ℕ → Bool", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "List.any", + "List.range", + "dite", + "Bool", + "LT.lt", + "instLTNat", + "Nat.decLt", + "Bool.xor", + "Fin.mk", + "Not", + "Bool.false" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every location read by the tester, including the primary Hadamard check. ", + "end_line": 69, + "is_class": false, + "kind": "definition", + "line": 59, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n 1 ≤ r →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r →\n List (PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "List", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "HAppend.hAppend", + "List", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.Hadamard.testQueries", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "List.cons", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "List.nil" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 161, + "is_class": false, + "kind": "theorem", + "line": 159, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_homogeneousIndex", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (x w : Fin t → ZMod 2),\n (PCP.Algebraic.Hadamard.encode r x) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) w) =\n (PCP.Algebraic.Hadamard.linearEncode x) w", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.Hadamard.linearEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 40, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.eval_coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ) (x : σ → R),\n (MvPolynomial.eval x) (PCP.Algebraic.GridVanishing.coordinate H i) = ∏ a ∈ H, (x i - a)", + "type_dependencies": [ + "CommRing", + "Finset", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.GridVanishing.coordinate", + "Finset.prod", + "CommRing.toCommMonoid", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u_2) →\n (x : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ((x : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color x q)) →\n ((x : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert x q)) →\n ((x : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference x q)) →\n ((x : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert x q)) →\n ((uv : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine uv x q)) →\n ((uv :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine uv x q)) →\n ((uv :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine uv x q)) →\n ((uv :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine uv x q)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Closure: an efficiently implemented verifier with logarithmic randomness and a polynomial\nproof-length bound induces a polynomial-time NP checking relation.\n\nThis is the bridge between verifier efficiency and NP-checker efficiency.\nDischarging it means showing the model is closed under: enumerating `2 ^ O(log n)` random\nstrings, unfolding a constant-depth query tree, and indexing a polynomially long witness.\n\nThe budget hypothesis is `CanonicalRandomness`, **not** `LogRandomness`. With only an upper\nbound this field is not justifiable for any standard model: an arbitrary `f : ℕ → Bool` can be\nhidden in the budget (see `Verifier.LogRandomness`) and recovered by an elementary\nlength-measuring algorithm, so the field would assert that every unary language has a computable\nchecking relation. A canonical budget is determined by `a` and `b` and carries no such\ninformation. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 104, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.polyTimeRel_finiteWitnessCheck", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (self : PCP.CostModel) (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n self.PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → self.PolyTimeRel (PCP.finiteWitnessCheck V)", + "type_dependencies": [ + "PCP.CostModel", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.CostModel.PolyTimeAlg", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.CostModel.PolyTimeRel", + "PCP.finiteWitnessCheck" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) →\n (x : ℕ) → Nat.below (motive := fun x => List Bool → PCP.QueryTree x) x → List Bool → PCP.QueryTree x", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Nat.below", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Nat.below", + "PCP.QueryTree", + "PCP.QueryTree.ofStep.match_3", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.ofStep.match_1", + "PCP.QueryTree.leaf", + "Bool.false", + "Nat.succ", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.QueryTree.query", + "PProd", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "List.nil", + "Bool.true" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep._sunfold", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree.ofStep.match_3", + "PCP.QueryTree", + "PCP.QueryTree.ofStep.match_1", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.leaf", + "Bool.false", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.QueryTree.query", + "PCP.QueryTree.ofStep", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "List.nil", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`L` is in NP relative to the polynomial-time-checkability notion `P`. ", + "end_line": 43, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Complexity.NP", + "name": "PCP.InNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Prop", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Nonempty", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The rational Walsh character indexed by `a`. ", + "end_line": 143, + "is_class": false, + "kind": "definition", + "line": 142, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character", + "provenance": "lean", + "structural_dependencies": [], + "type": "{ι : Type u_1} → [Fintype ι] → (ι → ZMod 2) → (ι → ZMod 2) → ℚ", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Algebraic.BLR.sign", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 382, + "is_class": false, + "kind": "definition", + "line": 382, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeGridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n [Fintype F] → [DecidableEq F] → {k : ℕ} → Fintype (PCP.Algebraic.DerivedZeroOnGrid.GridRandomness F k m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.instFintypeCallSeedOfDecidableEq", + "instFintypeSum", + "instDecidableEqSum" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 53, + "is_class": false, + "kind": "definition", + "line": 52, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat" + ], + "value_dependencies": [ + "Field", + "Nat", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.GeneratorLowDegreeTest.correct" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "theorem", + "line": 28, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (x : Fin t → ZMod 2) (c : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n (PCP.Algebraic.Hadamard.encode r x) c = (MvPolynomial.eval x) ((PCP.Algebraic.BinaryPolynomialSpace.polynomial t r) c)", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "RingHom", + "MvPolynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "AddMonoidAlgebra.instAddCommMonoid", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.BinaryPolynomialSpace.polynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.digitMonomial m c k = ∏ i, MvPolynomial.X (i, PCP.Algebraic.digit m k ↑i)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "Finset.prod", + "Fin", + "CommSemiring.toCommMonoid", + "AddMonoidAlgebra.commSemiring", + "Finsupp", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "MvPolynomial.X", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n ℕ → Sort (max 1 (imax (u_2 + 1) u) (imax (u_2 + 1) (u_2 + 1) u))", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "cond", + "Nat.ble", + "PULift", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "constructor", + "line": 30, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.NPCertificate" + ], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.validPolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F),\n PCP.Algebraic.ThreeColorGrid.validPolynomial P = P ^ 3 - 1", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "AddMonoidAlgebra.semiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidAlgebra.zero", + "Finsupp.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "SizeOf PCP.Machine.Sym", + "type_dependencies": [ + "SizeOf", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "SizeOf.mk", + "PCP.Machine.Sym", + "PCP.Machine.Sym._sizeOf_1" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 24, + "is_class": false, + "kind": "definition", + "line": 24, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.sep.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} → (t : PCP.Machine.Sym) → t.ctorIdx = 1 → motive PCP.Machine.Sym.sep → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A received word cannot be within distance less than one quarter of two messages. ", + "end_line": 134, + "is_class": false, + "kind": "theorem", + "line": 125, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.eq_of_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ},\n 1 ≤ r →\n ∀ (x y : Fin t → ZMod 2) (w : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) {ε : ℚ},\n ε < 1 / 4 →\n PCP.Algebraic.relativeDistance w ⇑(PCP.Algebraic.Hadamard.encode r x) ≤ ε →\n PCP.Algebraic.relativeDistance w ⇑(PCP.Algebraic.Hadamard.encode r y) ≤ ε → x = y", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "LT.lt", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_add", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : ZMod 2), PCP.Algebraic.BLR.sign (a + b) = PCP.Algebraic.BLR.sign a * PCP.Algebraic.BLR.sign b", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.sign", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Lemma 3.3 for the generator-weighted test, strengthened to the linear field-size\nhypothesis `q > 2c` (the paper assumes `q > C*c^3`). ", + "end_line": 292, + "is_class": false, + "kind": "theorem", + "line": 272, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F} [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ],\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : (σ → F) → F) {δ : ℚ},\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f ≤ δ →\n δ < 1 / (2 * (↑c + 2) ^ 2) →\n ∃ P, P.totalDegree ≤ c ∧ (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤ 2 * δ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t} →\n {validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t} →\n {properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t} →\n {color' :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {validCert' :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {difference' :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {properCert' :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {colorLines' : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t} →\n {validLines' differenceLines' :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t} →\n {properLines' :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c\n t} →\n { color := color, validCert := validCert, difference := difference,\n properCert := properCert, colorLines := colorLines, validLines := validLines,\n differenceLines := differenceLines, properLines := properLines } =\n { color := color', validCert := validCert', difference := difference',\n properCert := properCert', colorLines := colorLines', validLines := validLines',\n differenceLines := differenceLines', properLines := properLines' } →\n (color ≍ color' →\n validCert ≍ validCert' →\n difference ≍ difference' →\n properCert ≍ properCert' →\n colorLines ≍ colorLines' →\n validLines ≍ validLines' →\n differenceLines ≍ differenceLines' → properLines ≍ properLines' → P) →\n P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.WeightedConstraint.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] [inst_4 : DecidableEq F] [inst_5 : Fintype V] (a w : I → F) (f : V → F),\n PCP.Algebraic.WeightedConstraint.rejectionRate a w f =\n PCP.Algebraic.relativeDistance (fun s => f s.1) fun s => PCP.Algebraic.WeightedConstraint.predict a w f s.1 s.2", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Prod.fst", + "PCP.Algebraic.WeightedConstraint.predict", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.generator_ne_zero._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Fintype F], 1 < Fintype.card F → Fintype.card F - 1 = 0 → False", + "type_dependencies": [ + "Fintype", + "LT.lt", + "Nat", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (5 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 163, + "is_class": false, + "kind": "theorem", + "line": 161, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (c k : ℕ) (i : Fin c) (j : Fin m),\n (PCP.Algebraic.SetMultilinear.digitExponents m c k) (i, j) = if PCP.Algebraic.digit m k ↑i = j then 1 else 0", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Fin", + "Eq", + "DFunLike.coe", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "Finsupp.instFunLike", + "PCP.Algebraic.SetMultilinear.digitExponents", + "Prod.mk", + "ite", + "PCP.Algebraic.digit", + "Fin.val", + "instDecidableEqFin", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 85, + "is_class": false, + "kind": "constructor", + "line": 85, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Verifier" + ], + "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "constructor", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The center and the `c+1` generator positions are all the queried values. ", + "end_line": 62, + "is_class": false, + "kind": "definition", + "line": 60, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → (σ → F) → (σ → F) → List (σ → F)", + "type_dependencies": [ + "Field", + "Nat", + "List" + ], + "value_dependencies": [ + "Field", + "Nat", + "List.cons", + "List.ofFn", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨1, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 1 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 14 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The acceptance bias of the three-query test is the third Fourier moment. ", + "end_line": 282, + "is_class": false, + "kind": "theorem", + "line": 260, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.cubic_identity", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ),\n (PCP.Algebraic.BLR.average fun x => PCP.Algebraic.BLR.average fun y => f x * f y * f (x + y)) =\n ∑ a, PCP.Algebraic.BLR.fourier f a ^ 3", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.fourier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ], + "value_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk", + "PCP.CostModel.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every branch uses only its own mapped physical query list. ", + "end_line": 290, + "is_class": false, + "kind": "theorem", + "line": 258, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π π' : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (i : Fin 7)\n (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i),\n (∀ q ∈ PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i s,\n PCP.Algebraic.ThreeColorVerifier.read π q = PCP.Algebraic.ThreeColorVerifier.read π' q) →\n PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G π i s =\n PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G π' i s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.read", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.ProofOracle) (b : Bool), (PCP.QueryTree.leaf b).eval x_1 = b", + "type_dependencies": [ + "Nat", + "PCP.ProofOracle", + "Bool", + "Eq", + "PCP.QueryTree.eval", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval._unsafe_rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "PCP.QueryTree.eval.match_1", + "Bool", + "ite", + "Eq", + "Bool.true", + "instDecidableEqBool", + "PCP.QueryTree.eval._unsafe_rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 147, + "is_class": false, + "kind": "theorem", + "line": 145, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode_single", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x : Fin t → ZMod 2) (i : Fin t), (PCP.Algebraic.Hadamard.linearEncode x) (Pi.single i 1) = x i", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Pi.single", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "instDecidableEqFin", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.canonicalRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CanonicalRandomness\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000)\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000)", + "type_dependencies": [ + "PCP.Verifier.CanonicalRandomness", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HMul.hMul", + "Nat", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (π : PCP.ProofOracle) (h_1 : (x : ℕ) → (b : Bool) → (x_1 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_1)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match d + 1, PCP.QueryTree.query a f t, π with\n | x, PCP.QueryTree.leaf b, x_1 => h_1 x b x_1\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_2 d a f t π", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.eval.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 80, + "is_class": false, + "kind": "theorem", + "line": 73, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.totalDegree_coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R) (i : σ),\n (PCP.Algebraic.GridVanishing.coordinate H i).totalDegree = H.card", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "Eq", + "Nat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.GridVanishing.coordinate", + "Finset.card" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : PCP.ProofOracle) (d a : ℕ) (f t : PCP.QueryTree d),\n (PCP.QueryTree.query a f t).eval x = if x a = true then t.eval x else f.eval x", + "type_dependencies": [ + "PCP.ProofOracle", + "Nat", + "PCP.QueryTree", + "Eq", + "Bool", + "PCP.QueryTree.eval", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "ite", + "Bool.true", + "instDecidableEqBool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.sample.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F)\n (s : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a s =\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ f H a s.1 s.2.1 s.2.2.1.1 s.2.2.1.2 s.2.2.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "PCP.Algebraic.BinaryLocalCorrection.run", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{a : ℕ} → PCP.QueryTree a → ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.rec", + "Bool", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "instSizeOfNat", + "Bool._sizeOf_inst" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The input bound in the paper's `degree ≤ d`, `d < m ^ c` form. ", + "end_line": 113, + "is_class": false, + "kind": "theorem", + "line": 109, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_encode_of_degree_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c →\n ∀ (P : Polynomial R),\n P.natDegree ≤ d →\n ∀ (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n ((PCP.Algebraic.SetMultilinear.encode m c) P) =\n Polynomial.eval x P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Polynomial", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "LinearMap", + "RingHom.id", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The public adjacency extension, on the flattened pair of vertex coordinates. ", + "end_line": 54, + "is_class": false, + "kind": "definition", + "line": 50, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.edgePolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : Field F] → {n : ℕ} → (H : Finset F) → SimpleGraph (Fin n → ↥H) → MvPolynomial (Fin (n + n)) F", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "DFunLike.coe", + "AlgHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "AddMonoidAlgebra.semiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "`alg` implements `V`: unfolding the algorithm reproduces `V`'s decision tree on every input and\nevery random string.\n\nThis ties the certificate to *this* verifier — its random-bit handling (`bitsOfFin`), its query\naddresses, and its decision rule all have to match. Proving some unrelated verifier efficient\nwould not discharge it. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Complexity.CostModel", + "name": "PCP.Verifier.ImplementedBy", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → PCP.VerifierAlg → Prop", + "type_dependencies": [ + "PCP.Verifier", + "PCP.VerifierAlg" + ], + "value_dependencies": [ + "PCP.Verifier", + "PCP.VerifierAlg", + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Eq", + "PCP.QueryTree", + "PCP.Verifier.queries", + "PCP.QueryTree.ofStep", + "PCP.bitsOfFin", + "List.nil", + "PCP.Verifier.run" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} {a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3},\n PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.difference a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.below", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → {a : ℕ} → PCP.QueryTree a → Sort (max 1 u)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.rec", + "Bool", + "PUnit", + "PProd" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → ℕ → ℕ → Type u_3", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.SetMultilinear.Variables" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The quantitative statement with the actual rejection rate as its error parameter. ", + "end_line": 70, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.test_soundness_at_rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.testRejectionRate hr H < 1 / 28 →\n ∃ x,\n PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.Hadamard.encode r x) ≤\n PCP.Algebraic.Hadamard.testRejectionRate hr H ∧\n PCP.Algebraic.relativeDistance (fun p => H ((PCP.Algebraic.BinaryPolynomialSpace.embed hr) p))\n ⇑(PCP.Algebraic.Hadamard.encode 1 x) ≤\n 3 * PCP.Algebraic.Hadamard.testRejectionRate hr H", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "LT.lt", + "Rat", + "Rat.instLT", + "PCP.Algebraic.Hadamard.testRejectionRate", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Exists", + "Fin", + "And", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.embed", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.negate.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_1} (motive : PCP.Reduction.NAEThreeColor.Literal W → Sort u_2) (v : W) (b : Bool)\n (h_1 : (b : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const b))\n (h_2 : (v : W) → (b : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var v b)),\n (match PCP.Reduction.NAEThreeColor.Literal.var v b with\n | PCP.Reduction.NAEThreeColor.Literal.const b => h_1 b\n | PCP.Reduction.NAEThreeColor.Literal.var v b => h_2 v b) =\n h_2 v b", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Eq", + "PCP.Reduction.FiniteBooleanConstraints.negate.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 168, + "is_class": false, + "kind": "theorem", + "line": 165, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial_eq_monomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.digitMonomial m c k =\n (MvPolynomial.monomial (PCP.Algebraic.SetMultilinear.digitExponents m c k)) 1", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "MvPolynomial.monomial", + "PCP.Algebraic.SetMultilinear.digitExponents", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.corrected.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (ζ : F) (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H s =\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H s.1)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c s.2.1) s.2.2.1.1 s.2.2.1.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses._unsafe_rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.addresses.match_1", + "Finset", + "Bool", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "PCP.QueryTree.addresses._unsafe_rec" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "View the same difference oracle on flattened coordinates. ", + "end_line": 71, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n (Fin (n + n) → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.GridCoordinateTransport.rows", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every individual variable has degree at most one. ", + "end_line": 198, + "is_class": false, + "kind": "theorem", + "line": 192, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.degreeOf_encode_le_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R)\n (ij : PCP.Algebraic.SetMultilinear.Variables m c),\n MvPolynomial.degreeOf ij ((PCP.Algebraic.SetMultilinear.encode m c) P) ≤ 1", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.SetMultilinear.Variables", + "LE.le", + "instLENat", + "MvPolynomial.degreeOf", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries),\n sizeOf { randomness := randomness, queries := queries, run := run } = 1 + sizeOf queries", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "SizeOf.sizeOf", + "PCP.Verifier", + "PCP.Verifier._sizeOf_inst", + "PCP.Verifier.mk", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "instSizeOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.read f H (Sum.inl p) = f p.1 p.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Prod", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Lemma 3.10: low rejection yields a codeword close on both full and degree-one queries. ", + "end_line": 61, + "is_class": false, + "kind": "theorem", + "line": 28, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.test_soundness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) {δ : ℚ},\n δ < 1 / 28 →\n PCP.Algebraic.Hadamard.testRejectionRate hr H ≤ δ →\n ∃ x,\n PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.Hadamard.encode r x) ≤ δ ∧\n PCP.Algebraic.relativeDistance (fun p => H ((PCP.Algebraic.BinaryPolynomialSpace.embed hr) p))\n ⇑(PCP.Algebraic.Hadamard.encode 1 x) ≤\n 3 * δ", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Rat", + "LT.lt", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instLE", + "PCP.Algebraic.Hadamard.testRejectionRate", + "Exists", + "Fin", + "And", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.embed", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a : ι → ZMod 2), PCP.Algebraic.BLR.linearForm a = ∑ i, a i • LinearMap.proj i", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BLR.linearForm", + "Finset.sum", + "LinearMap.addCommMonoid", + "Finset.univ", + "HSMul.hSMul", + "Pi.module", + "instHSMul", + "LinearMap.instSMul", + "NonUnitalNonAssocSemiring.toDistribSMul", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "ZMod.commRing", + "PCP.Algebraic.BLR.linearForm._proof_1", + "LinearMap.proj" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 143, + "is_class": false, + "kind": "theorem", + "line": 141, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x w : Fin t → ZMod 2), (PCP.Algebraic.Hadamard.linearEncode x) w = ∑ i, x i * w i", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Finset.sum", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "definition", + "line": 128, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.acceptance_pow_le_half", + "provenance": "lean", + "structural_dependencies": [], + "type": "(1 - PCP.Algebraic.ThreeColorBinaryVerifier.gap) ^ PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions ≤ 1 / 2", + "type_dependencies": [ + "LE.le", + "Rat", + "Rat.instLE", + "HPow.hPow", + "Nat", + "instHPow", + "Rat.instPowNat", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 126, + "is_class": false, + "kind": "constructor", + "line": 126, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 56, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n (PCP.Algebraic.SetMultilinear.encode m c) 1 = PCP.Algebraic.SetMultilinear.digitMonomial m c 0", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest_honestProof._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} {m c : ℕ} (P : MvPolynomial (Fin n) F) (MVal : MvPolynomial (Fin n ⊕ Fin n) F)\n (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F), ¬1 ≤ 3 → False", + "type_dependencies": [ + "Field", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 190, + "is_class": false, + "kind": "theorem", + "line": 176, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_character_mul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (x y : ι → ZMod 2),\n (PCP.Algebraic.BLR.average fun a => PCP.Algebraic.BLR.character a x * PCP.Algebraic.BLR.character a y) =\n if x = y then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character", + "ite", + "Fintype.decidablePiFintype", + "ZMod.decidableEq", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2),\n PCP.Algebraic.BLR.character a x = PCP.Algebraic.BLR.sign ((PCP.Algebraic.BLR.linearForm a) x)", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.character", + "PCP.Algebraic.BLR.sign", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 182, + "is_class": false, + "kind": "theorem", + "line": 176, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial_isSetMultilinear", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.IsSetMultilinear m c (PCP.Algebraic.SetMultilinear.digitMonomial m c k)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.SetMultilinear.IsSetMultilinear", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.expect_shared_fst", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (f : W × S → ℚ),\n (Finset.univ.expect fun s => f (s.1, s.2.1)) = Finset.univ.expect fun s => f s", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "PCP.Verifier.rec", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "SizeOf.sizeOf", + "instSizeOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An averaged rejection guarantee follows from genuine per-target corrector bounds. ", + "end_line": 194, + "is_class": false, + "kind": "theorem", + "line": 97, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.two_corrector_rejection_bound", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} {S : Type u_3} [inst : Fintype X] [Nonempty X] [inst_2 : Fintype W] [inst_3 : Fintype S]\n [Nonempty S] (p P A B : X → W → ZMod 2) (a b : X → W → S → Option (ZMod 2)) {K ν ε : ℚ},\n 0 ≤ K →\n (∀ (x : X),\n (PCP.Algebraic.relativeDistance (fun ws => a x ws.1 ws.2) fun ws => some (A x ws.1)) ≤\n (K * PCP.Algebraic.AffineLineSampling.fraction fun ws => a x ws.1 ws.2 = none) + ν) →\n (∀ (x : X),\n (PCP.Algebraic.relativeDistance (fun ws => b x ws.1 ws.2) fun ws => some (B x ws.1)) ≤\n (K * PCP.Algebraic.AffineLineSampling.fraction fun ws => b x ws.1 ws.2 = none) + ν) →\n (PCP.Algebraic.relativeDistance (fun xw => p xw.1 xw.2) fun xw => P xw.1 xw.2) ≤ ε →\n (PCP.Algebraic.relativeDistance\n (fun xw => PCP.Algebraic.BinaryZeroOnGrid.checkBits (P xw.1 xw.2) (A xw.1 xw.2) (B xw.1 xw.2)) fun x =>\n (0, 0)) ≤\n ((1 + 2 * K) *\n PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck p a b) fun x =>\n some (0, 0)) +\n ε +\n 2 * ν", + "type_dependencies": [ + "Fintype", + "Nonempty", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Rat", + "LE.le", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Option.instDecidableEq", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "Option.some", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.AffineLineSampling.fraction", + "Eq", + "Option.none", + "instDecidableEqProd", + "PCP.Algebraic.BinaryZeroOnGrid.checkBits", + "Prod.mk", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_character_mul._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x y : ι → ZMod 2),\n PCP.Algebraic.BLR.character a x * PCP.Algebraic.BLR.character a y = PCP.Algebraic.BLR.character a (x + y)", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → PCP.Machine.Sym → PCP.Machine.Sym → Sort u", + "type_dependencies": [ + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.Sym.casesOn", + "Bool", + "Eq" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym → ℕ", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.Sym.rec", + "Nat", + "Bool", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "Bool._sizeOf_inst" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.productQuery.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (s : PCP.Algebraic.Hadamard.TestRandomness t r) (k : Fin (r - 1)),\n s.productQuery k = PCP.Algebraic.BinaryPolynomialSpace.mixedProduct ⋯ s.linear (s.factor k)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.Hadamard.TestRandomness.productQuery", + "PCP.Algebraic.BinaryPolynomialSpace.mixedProduct", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.Hadamard.TestRandomness.productDegree_le", + "PCP.Algebraic.Hadamard.TestRandomness.linear", + "PCP.Algebraic.Hadamard.TestRandomness.factor" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 80, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_equiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (e : α ≃ β) (f : β → ℚ),\n (PCP.Algebraic.BLR.average fun x => f (e x)) = PCP.Algebraic.BLR.average f", + "type_dependencies": [ + "Fintype", + "Equiv", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "DFunLike.coe", + "EquivLike.toFunLike", + "Equiv.instEquivLike" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)),\n 5 * ((H.card - 1) * n) < m ^ c →\n ∀ (P : MvPolynomial (Fin n) F),\n P.totalDegree ≤ (H.card - 1) * n →\n ∀ (MVal : MvPolynomial (Fin n ⊕ Fin n) F) (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n ¬P.totalDegree < m ^ c → False", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 47, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.orGate_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_3} (z x y : PCP.Reduction.NAEThreeColor.Literal W) (a : W → Bool),\n (∀ (j : Fin 3),\n PCP.Reduction.FiniteBooleanConstraints.ClauseHolds (PCP.Reduction.FiniteBooleanConstraints.orGate z x y j) a) ↔\n PCP.Reduction.NAEThreeColor.Literal.eval a z =\n (PCP.Reduction.NAEThreeColor.Literal.eval a x || PCP.Reduction.NAEThreeColor.Literal.eval a y)", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "Iff", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.FiniteBooleanConstraints.ClauseHolds", + "PCP.Reduction.FiniteBooleanConstraints.orGate", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "Bool.or" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 135, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (ζ : F) (f : (σ → F) → F),\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f =\n PCP.Algebraic.WeightedConstraint.rejectionRate (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "Pi.instFintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The field-coordinate version, using only injectivity of the paper's coordinate map. ", + "end_line": 123, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encodeFunction_map", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} {ι : Type u_1} {α : Type u_2} [inst : Fintype ι] [inst_1 : DecidableEq α] (ρ : α → Fin t → ZMod 2),\n Function.Injective ρ →\n 1 ≤ r →\n ∀ (f g : ι → α),\n PCP.Algebraic.relativeDistance (PCP.Algebraic.Hadamard.encodeFunction r fun i => ρ (f i))\n (PCP.Algebraic.Hadamard.encodeFunction r fun i => ρ (g i)) =\n 1 / 2 * PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "LE.le", + "instLENat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.Hadamard.encodeFunction", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (witnessBound : Polynomial ℕ)\n (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true)\n (witnessBound_1 : Polynomial ℕ) (check_1 : List Bool → List Bool → Bool) (check_polyTime_1 : P check_1)\n (spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true),\n ({ witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 }) =\n (witnessBound = witnessBound_1 ∧ check = check_1)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.clauses.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} (relation : C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool)\n (scope : C → Fin k → V) (e : C) (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) (i : Fin k) (j : Fin 3),\n PCP.Reduction.FiniteBooleanConstraints.clauses relation scope (e, p, Sum.inl (i, j)) =\n PCP.Reduction.FiniteBooleanConstraints.orGate (PCP.Reduction.FiniteBooleanConstraints.flagLiteral e p i.succ)\n (PCP.Reduction.FiniteBooleanConstraints.flagLiteral e p i.castSucc)\n (PCP.Reduction.FiniteBooleanConstraints.differenceLiteral scope e p i) j", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.clauses", + "Prod.mk", + "Prod", + "Sum", + "Sum.inl", + "PCP.Reduction.FiniteBooleanConstraints.orGate", + "PCP.Reduction.FiniteBooleanConstraints.flagLiteral", + "Fin.succ", + "Fin.castSucc", + "PCP.Reduction.FiniteBooleanConstraints.differenceLiteral" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d) (addr_1 : ℕ) (onFalse_1 onTrue_1 : PCP.QueryTree d),\n (PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1) =\n (addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n {F' : Type u_2} → {n' m' c' t' : ℕ} → PCP.Algebraic.ThreeColorVerifier.Proof F' n' m' c' t' → Sort u", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → (c : ℕ) → F → Fin (c + 1) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 241, + "is_class": false, + "kind": "theorem", + "line": 235, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_validGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.validGridQuery q) =\n PCP.Algebraic.DerivedZeroOnGrid.read π.color π.validCert (PCP.Algebraic.ThreeColorVerifier.validAuxiliary π) q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery", + "PCP.Algebraic.DerivedZeroOnGrid.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 180, + "is_class": false, + "kind": "theorem", + "line": 161, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.distance_line_bits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [Field F] {m c t r : ℕ} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ]\n {A : Type u_3} [inst_3 : DecidableEq A]\n (k l : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ × F → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k (s.1, s.2.1) s.2.2.1.2) fun s => l (s.1, s.2.1) s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The combined verdict is exactly conjunction of the seven concrete verdicts. ", + "end_line": 316, + "is_class": false, + "kind": "theorem", + "line": 311, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.test_eq_true", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s = true ↔\n ∀ (i : Fin 7), PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G π i (s i) = true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Iff", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "Bool.true", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.inversion._simp_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),\n ∑ i ∈ s, a * f i = a * ∑ i ∈ s, f i", + "type_dependencies": [ + "NonUnitalNonAssocSemiring", + "Finset", + "Eq", + "Finset.sum", + "NonUnitalNonAssocSemiring.toAddCommMonoid", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "NonUnitalNonAssocSemiring.toDistrib" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses._sunfold", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.addresses.match_1", + "Finset", + "Bool", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "PCP.QueryTree.addresses" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 80, + "is_class": false, + "kind": "theorem", + "line": 76, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.totalDegree_edgeExtension_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)),\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree ≤ 2 * ((H.card - 1) * Fintype.card σ)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.factorDegree_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {r : ℕ} (k : Fin (r - 1)), ¬↑k + 1 ≤ r → False", + "type_dependencies": [ + "Nat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The auxiliary encodings of all genuine line restrictions. ", + "end_line": 111, + "is_class": false, + "kind": "definition", + "line": 108, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n [NeZero m] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n MvPolynomial σ F → PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.honestTable", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeTriple.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (t : List Bool × List Bool × List Bool),\n PCP.Machine.encodeTriple t =\n PCP.Machine.ofBits t.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.1 ++\n PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.2", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.encodeTriple", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "definition", + "line": 42, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 135, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 7 →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "PCP.QueryTree.eval.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.expect_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : Fintype B] (k : A × B → ℚ),\n (Finset.univ.expect fun p => k p) = Finset.univ.expect fun a => Finset.univ.expect fun b => k (a, b)", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete honest proof, including the four auxiliary tables shared between tests. ", + "end_line": 36, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.honestProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [NeZero m] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n MvPolynomial (Fin n) F →\n MvPolynomial (Fin n ⊕ Fin n) F →\n MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.honestProof._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Correction queries are routed to the same physical certificate and line tables. ", + "end_line": 172, + "is_class": false, + "kind": "definition", + "line": 168, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} → PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "Prod.mk", + "PCP.Algebraic.ThreeColorVerifier.PairPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k k_1 : ℕ),\n k = k_1 → PCP.Algebraic.SetMultilinear.digitMonomial m c k = PCP.Algebraic.SetMultilinear.digitMonomial m c k_1", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 320, + "is_class": false, + "kind": "theorem", + "line": 311, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate_nodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (ζ : F) (f : (σ → F) → F),\n PCP.Algebraic.FixedLagrangeConstraint.rejectionRate (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) f =\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨2, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 3 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 18 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "Decidable.byContradiction", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The bounded algebraic witness characterizes any finite graph that fits in the grid.\nThe embedding and padded graph are supplied by the stated cardinality bound. ", + "end_line": 191, + "is_class": false, + "kind": "theorem", + "line": 173, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates_on_grid", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ {V : Type u_3} [inst_5 : Fintype V] (G : SimpleGraph V) (H : Finset F),\n H.Nonempty →\n ∀ (hsize : Fintype.card V ≤ H.card ^ Fintype.card σ),\n have G' := PCP.Algebraic.GraphGridEmbedding.pad G (PCP.Algebraic.GraphGridEmbedding.gridEmbedding H hsize);\n G.Colorable 3 ↔\n ∃ P MVal MProp,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n MVal.totalDegree ≤ 3 * ((H.card - 1) * Fintype.card σ) ∧\n MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) ∧\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal ∧\n PCP.Algebraic.GridVanishing.IsCertificate H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G')\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P))\n MProp", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "SimpleGraph", + "Finset", + "Finset.Nonempty", + "LE.le", + "instLENat", + "Fintype.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Finset.card", + "PCP.Algebraic.GraphGridEmbedding.Grid", + "PCP.Algebraic.GraphGridEmbedding.pad", + "PCP.Algebraic.GraphGridEmbedding.gridEmbedding", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "And", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), a ^ m * a ^ n = a ^ (m + n)", + "type_dependencies": [ + "Monoid", + "Nat", + "Eq", + "HMul.hMul", + "instHMul", + "MulOne.toMul", + "MulOneClass.toMulOne", + "Monoid.toMulOneClass", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Both correction calls have the promised mean error even when they share\ntheir sampled direction and homogeneous label. ", + "end_line": 215, + "is_class": false, + "kind": "theorem", + "line": 182, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.correction_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (Q : (σ → F) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F),\n (∀ (b : σ → F), (Q b).totalDegree ≤ c) →\n ∀ (parameter : Fˣ → F),\n PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H parameter)\n (PCP.Algebraic.BinaryLocalCorrection.decodedAt ρ Q parameter) ≤\n ↑(c + 1) *\n Finset.univ.expect fun b =>\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ (H b) fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) (Q b))))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Units", + "Semiring.toMonoid", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "instFintypeProd", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "PCP.Algebraic.BinaryLocalCorrection.decodedAt", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (x : ℕ) (b : Bool) (x_1 : PCP.ProofOracle)\n (h_1 : (x : ℕ) → (b : Bool) → (x_2 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_2)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match x, PCP.QueryTree.leaf b, x_1 with\n | x, PCP.QueryTree.leaf b, x_2 => h_1 x b x_2\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_1 x b x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.eval.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] {inst_1 : DecidableEq ι} [inst_2 : DecidableEq ι] (f f_1 : (ι → ZMod 2) → ℚ),\n f = f_1 → ∀ (a a_1 : ι → ZMod 2), a = a_1 → PCP.Algebraic.BLR.fourier f a = PCP.Algebraic.BLR.fourier f_1 a_1", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.fourier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = ↑(V.acceptingRandomness x π).card / 2 ^ V.randomness x.length", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Eq", + "Rat", + "PCP.Verifier.accProb", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.acceptingRandomness", + "Rat.instPowNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLowDegreeTest.queries.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {c t r : ℕ} (hr : 1 ≤ r)\n (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (a a_1 : Fin (c + 1) → F),\n a = a_1 →\n ∀ (s s_1 : PCP.Algebraic.BinaryLowDegreeTest.TestRandomness F σ t r),\n s = s_1 →\n PCP.Algebraic.BinaryLowDegreeTest.queries hr ρ a s =\n PCP.Algebraic.BinaryLowDegreeTest.queries hr ρ_1 a_1 s_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryLowDegreeTest.TestRandomness", + "List", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLowDegreeTest.queries" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 0 → ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "Bool", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "Bool", + "PCP.QueryTree.leaf", + "PCP.QueryTree.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The seven concrete branch verdicts. ", + "end_line": 115, + "is_class": false, + "kind": "definition", + "line": 96, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n (i : Fin 7) → PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Fin.cases", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_3", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines", + "Fin.succ", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_4", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines", + "Fin.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "Decidable.decide", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_6", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary", + "Option.some", + "Prod.mk", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Option.instDecidableEq", + "instDecidableEqProd", + "ZMod.decidableEq", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_8", + "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "PCP.Algebraic.BinaryDifferenceConsistency.check", + "Prod.fst", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "Prod.snd", + "Fin.elim0" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_singleton", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (a : R) (i : σ),\n PCP.Algebraic.GridVanishing.coordinate {a} i = MvPolynomial.X i - MvPolynomial.C a", + "type_dependencies": [ + "CommRing", + "Eq", + "MvPolynomial", + "CommRing.toCommSemiring", + "PCP.Algebraic.GridVanishing.coordinate", + "Singleton.singleton", + "Finset", + "Finset.instSingleton", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type (max u_2 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Fact 2.7, for ordinary total degree, including constant polynomials. ", + "end_line": 265, + "is_class": false, + "kind": "theorem", + "line": 251, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eq_zero_iff_exists_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F} [Finite σ],\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : (σ → F) → F),\n (∀ (u v : σ → F), PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v = 0) ↔\n ∃ P, P.totalDegree ≤ c ∧ ∀ (x : σ → F), (MvPolynomial.eval x) P = f x", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Finite", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Iff", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Exists", + "MvPolynomial", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The returned answer depends only on the stated queries. ", + "end_line": 119, + "is_class": false, + "kind": "theorem", + "line": 97, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f g : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H K : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a b : σ → F) (z : Fˣ)\n (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n (∀ p ∈ PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ a b z v w s,\n PCP.Algebraic.BinaryLocalCorrection.read f H p = PCP.Algebraic.BinaryLocalCorrection.read g K p) →\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ f H a b z v w s =\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ g K a b z v w s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.run" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} {witnessBound : Polynomial ℕ}\n {check : List Bool → List Bool → Bool} {check_polyTime : P check}\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true}\n {witnessBound_1 : Polynomial ℕ} {check_1 : List Bool → List Bool → Bool} {check_polyTime_1 : P check_1}\n {spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true},\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 } →\n witnessBound = witnessBound_1 ∧ check = check_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.eval_validPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F) (x : σ → F),\n (MvPolynomial.eval x) (PCP.Algebraic.ThreeColorGrid.validPolynomial P) = (MvPolynomial.eval x) P ^ 3 - 1", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every received eight-table proof of a non-three-colorable grid graph is\nrejected with a fixed positive probability, independent of graph size. ", + "end_line": 130, + "is_class": false, + "kind": "theorem", + "line": 115, + "module": "PCP.Algebraic.ThreeColorVerifierSoundness", + "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate_ge_of_not_colorable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] {n m c t : ℕ} [NeZero m]\n [CharP F 2],\n 1 ≤ c →\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n 100 * (c * m ^ c) * H.card ≤ Fintype.card F →\n (H.card - 1) * n ≤ c * m ^ c →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n ¬G.Colorable 3 →\n ∀ (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorSoundnessBudget.gap c ≤\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "Finset.card", + "HSub.hSub", + "instHSub", + "instSubNat", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Not", + "SimpleGraph.Colorable", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat", + "Rat.instLE", + "PCP.Algebraic.ThreeColorSoundnessBudget.gap", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "Classical.propDecidable", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "definition", + "line": 23, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {b b' : Bool} → PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b' → (b = b' → P) → P", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "id", + "PCP.Machine.Sym.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.linearQuery.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (s s_1 : PCP.Algebraic.Hadamard.TestRandomness t r),\n s = s_1 →\n ∀ (a a_1 : PCP.Algebraic.BinaryPolynomialSpace.Monomials t r),\n a = a_1 →\n PCP.Algebraic.Hadamard.TestRandomness.linearQuery hr s a =\n PCP.Algebraic.Hadamard.TestRandomness.linearQuery hr s_1 a_1", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Eq", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness.linearQuery" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 31, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_ofBits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool), (PCP.Machine.ofBits x).length = x.length", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "Nat", + "List.length", + "PCP.Machine.Sym", + "PCP.Machine.ofBits" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "recursor", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Sort u} →\n ((color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t) →\n (validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t) →\n (properLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t) →\n motive\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines }) →\n (t : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) → motive t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 211, + "is_class": false, + "kind": "theorem", + "line": 209, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.card_clause", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {C : Type u_2} {k : ℕ} [inst : Fintype C],\n Fintype.card (PCP.Reduction.FiniteBooleanConstraints.Clause C k) = Fintype.card C * 2 ^ k * (3 * k + 2)", + "type_dependencies": [ + "Nat", + "Fintype", + "Eq", + "Fintype.card", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "instFintypeProd", + "Prod", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Pi.instFintype", + "Bool", + "instDecidableEqFin", + "Fin.fintype", + "Bool.fintype", + "instFintypeSum", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Embed a homogeneous linear query into the degree-`r` query space. ", + "end_line": 152, + "is_class": false, + "kind": "definition", + "line": 149, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} → 1 ≤ r → (Fin t → ZMod 2) →ₗ[ZMod 2] PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Finset.sum", + "Fin", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.addCommMonoid", + "Finset.univ", + "Fin.fintype", + "LinearMap.smulRight", + "PCP.Algebraic.Hadamard.homogeneousIndex._proof_1", + "LinearMap.proj", + "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 170, + "is_class": false, + "kind": "theorem", + "line": 163, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r), Function.Injective ⇑(PCP.Algebraic.Hadamard.homogeneousIndex hr)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Fin", + "ZMod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.queries hr ρ nodes ζ s =\n List.map (fun p => Sum.inl (s.1.1, p)) (PCP.Algebraic.Hadamard.testQueries hr s.2.2.2.1) ++\n List.map (fun p => Sum.inr (s.1, p))\n (PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1 ρ nodes\n s.2.2.2.2) ++\n List.map (fun p => Sum.inr (s.1, p))\n (PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c s.2.1) s.2.2.1.1 s.2.2.1.2) ++\n [Sum.inl\n (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1,\n (PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2.2.1.2)]", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "List", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "HAppend.hAppend", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.SetMultilinear.Variables", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.Hadamard.testQueries", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "List.cons", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "List.nil" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testAccepts_congr._simp_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {β : Type u_2} {f : α → List β} {b : β} {l : List α}, (b ∈ List.flatMap f l) = ∃ a ∈ l, b ∈ f a", + "type_dependencies": [ + "List", + "Eq", + "Membership.mem", + "List.instMembership", + "List.flatMap", + "Exists", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "General point-versus-line soundness with explicit absolute constants,\nincluding degree zero and zero-dimensional spaces. ", + "end_line": 69, + "is_class": false, + "kind": "theorem", + "line": 56, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.PointLineTest.exists_close_of_small_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {d : ℕ},\n PCP.Algebraic.PointLineConstants.fieldFactor * d ^ 3 ≤ Fintype.card F →\n ∀ (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ d),\n PCP.Algebraic.PointLineTest.rejectionRate f table ≤ PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ d ∧\n (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤\n 2 * PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.PointLineTest.LineTable", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Rat.instMul", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 157, + "is_class": false, + "kind": "theorem", + "line": 154, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.polynomial_homogeneousIndex", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (w : Fin t → ZMod 2),\n (PCP.Algebraic.BinaryPolynomialSpace.polynomial t r) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) w) =\n ∑ i, MvPolynomial.C (w i) * MvPolynomial.X i", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.polynomial", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Finset.sum", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C", + "MvPolynomial.X" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 156, + "is_class": false, + "kind": "definition", + "line": 154, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1 →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.validQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.test_eq_true_iff._simp_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n (PCP.Algebraic.Hadamard.test hr H s = true) = PCP.Algebraic.Hadamard.testAccepts hr H s", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness", + "Eq", + "Bool", + "PCP.Algebraic.Hadamard.test", + "Bool.true", + "PCP.Algebraic.Hadamard.testAccepts" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_smul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ) (a : R)\n (P : MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R),\n (PCP.Algebraic.SetMultilinear.decode m c) (a • P) = Polynomial.C a * (PCP.Algebraic.SetMultilinear.decode m c) P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "Polynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ) (i : Fin (c + 1)), ↑i ≠ c → ¬↑i < c → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Ne", + "Fin.val", + "Not", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "An oracle verifier.\n\nOn an input `x` of length `n` it draws `randomness n` fair bits and then runs the decision tree\nselected by that random string, making at most `queries` *bit* queries into the proof. ", + "end_line": 91, + "is_class": false, + "kind": "inductive", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Verifier.mk", + "PCP.Verifier" + ], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instInhabitedSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "Inhabited PCP.Machine.Sym", + "type_dependencies": [ + "Inhabited", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Inhabited.mk", + "PCP.Machine.Sym", + "PCP.Machine.instInhabitedSym.default" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The final primary-oracle proximity factor. ", + "end_line": 50, + "is_class": false, + "kind": "definition", + "line": 49, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HAdd.hAdd", + "Rat", + "instHAdd", + "Rat.instAdd", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "recursor", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Verifier → Sort u} →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n (t : PCP.Verifier) → motive t", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The independent choices in HadTest, including all loop iterations. ", + "end_line": 31, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t : ℕ} →\n (motive : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → Sort u_3) →\n (x : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl p)) →\n ((p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "recursor", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n (t : PCP.NPCertificate P L) → motive t", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The coordinate polynomial `∏ a ∈ H, (X i - a)`. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → Finset R → σ → MvPolynomial σ R", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring" + ], + "value_dependencies": [ + "CommRing", + "Finset", + "Finset.prod", + "MvPolynomial", + "CommRing.toCommSemiring", + "CommRing.toCommMonoid", + "AddMonoidAlgebra.commRing", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False", + "type_dependencies": [ + "Zero", + "OfNat", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "NeZero", + "Eq", + "Zero.toOfNat0", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 223, + "is_class": false, + "kind": "theorem", + "line": 195, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_univariate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : F → F),\n (∀ (u v : F),\n f u =\n PCP.Algebraic.WeightedConstraint.predict (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f u v) →\n ∃ P, P.natDegree ≤ c ∧ ∀ (x : F), Polynomial.eval x P = f x", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "PCP.Algebraic.WeightedConstraint.predict", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Semiring.toModule", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "Exists", + "Polynomial", + "And", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)) (P : MvPolynomial σ F),\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ →\n ∀ (MVal : MvPolynomial (σ ⊕ σ) F) (MProp : MvPolynomial ((σ ⊕ σ) ⊕ σ ⊕ σ) F),\n MProp.totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree +\n 3 * (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree ≤ 2 * ((H.card - 1) * Fintype.card σ) →\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree ≤ P.totalDegree →\n ¬MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) → False", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness in normalized form (Lemma 3.10, first part). ", + "end_line": 161, + "is_class": false, + "kind": "theorem", + "line": 156, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testRejectionRate_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (x : Fin t → ZMod 2),\n PCP.Algebraic.Hadamard.testRejectionRate hr ⇑(PCP.Algebraic.Hadamard.encode r x) = 0", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.Hadamard.testRejectionRate", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 214, + "is_class": false, + "kind": "theorem", + "line": 212, + "module": "PCP.Verifier.Definition", + "name": "PCP.finiteWitnessCheck_eq_true_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w = true ↔\n ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Iff", + "Eq", + "PCP.finiteWitnessCheck", + "Bool.true", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "PCP.oracleOfWitness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The corrector evaluated on its full finite sample. ", + "end_line": 67, + "is_class": false, + "kind": "definition", + "line": 61, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n (σ → F) → PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → Option (ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.run", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "**`PCP(O(log n), O(1)) ⊆ NP` for the concrete machine model.**\n\nAn efficiently implemented verifier — polynomial-time in the sense of `PCP/Complexity/Machine.lean`,\na step count on `Turing.FinTM2` — with a canonical logarithmic budget, a polynomial proof-length\nbound, perfect completeness and soundness `1/2` puts its language in NP for that same concrete\nclass. No cost model is a parameter, and no model-existence premise is assumed: the model comes\nfrom `Machine.exists_standardCostModel`, whose closure field is the certified finite-witness\nchecker of `PCP/Complexity/CheckerFinal.lean`. ", + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 25, + "module": "PCP.ReverseConcrete", + "name": "PCP.pcp_subset_np_concrete", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (L : PCP.Language) (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PCP.Machine.PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n (∀ (x : List Bool), L x → V.CompleteAt x) →\n (∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)) → PCP.InNP PCP.Machine.PolyTimeRel L", + "type_dependencies": [ + "PCP.Language", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.Machine.PolyTimeAlg", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.InNP", + "PCP.Machine.PolyTimeRel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An actual outer test bounded by a larger rejection budget supplies the same\nlarger full and homogeneous proximity budgets. ", + "end_line": 53, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.ThreeColorVerifierSoundness", + "name": "_private.PCP.Algebraic.ThreeColorVerifierSoundness.0.PCP.Algebraic.ThreeColorVerifier.exists_close_of_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] {m c t : ℕ} [NeZero m] [CharP F 2]\n {σ : Type u_2} [inst_5 : Fintype σ] [inst_6 : DecidableEq σ] {r : ℕ},\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (L : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t) {κ : ℚ},\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f L ≤ κ →\n PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c * κ ≤\n PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ c * m ^ c ∧\n (PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ f fun x => (MvPolynomial.eval x) P) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c * κ ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P)))) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c * κ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "DecidableEq", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Rat.instMul", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Field.toCommRing", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 381, + "is_class": false, + "kind": "definition", + "line": 380, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeCallSeedOfDecidableEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n {σ : Type u_2} →\n [Fintype σ] → [DecidableEq σ] → Fintype (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Source-style full coefficient-space proximity costs at most a factor two per oracle. ", + "end_line": 356, + "is_class": false, + "kind": "theorem", + "line": 327, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_lower_bound_of_full_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n (PCP.Algebraic.relativeDistance (fun s => p' s.1 s.2) fun s =>\n (PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval s.1) P))) s.2) ≤\n δP →\n (PCP.Algebraic.relativeDistance (fun s => M' s.1 s.2) fun s =>\n (PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval s.1) M))) s.2) ≤\n δM →\n (1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 ≤\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) *\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p' M' A +\n 2 * δP +\n 4 * δM +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instDecidableEqSum", + "instFintypeSum", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness with the strict outer degree required by the inner encoding. ", + "end_line": 134, + "is_class": false, + "kind": "theorem", + "line": 113, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : NeZero m]\n [CharP F 2] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree < m ^ c →\n ∀ (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P))))\n (PCP.Algebraic.EncodedLineLowDegreeTest.honestTable ρ P) s =\n true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 207, + "is_class": false, + "kind": "theorem", + "line": 204, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.card_variable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} [inst : Fintype V] [inst_1 : Fintype C],\n Fintype.card (PCP.Reduction.FiniteBooleanConstraints.Variable V C k) =\n Fintype.card V + Fintype.card C * 2 ^ k * (k + 1)", + "type_dependencies": [ + "Nat", + "Fintype", + "Eq", + "Fintype.card", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "instFintypeSum", + "PCP.Reduction.FiniteBooleanConstraints.Aux", + "instFintypeProd", + "Prod", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.instFintype", + "Bool", + "instDecidableEqFin", + "Fin.fintype", + "Bool.fintype", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The §7 witness consists of a coloring extension and two bounded certificates. ", + "end_line": 160, + "is_class": false, + "kind": "theorem", + "line": 134, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (σ → ↥H)),\n G.Colorable 3 ↔\n ∃ P MVal MProp,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n MVal.totalDegree ≤ 3 * ((H.card - 1) * Fintype.card σ) ∧\n MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) ∧\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal ∧\n PCP.Algebraic.GridVanishing.IsCertificate H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P))\n MProp", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Fintype.card", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (ctorIdx : ℕ) →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ctorIdx = t_1.ctorIdx → PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType ctorIdx → motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PULift.down", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "Eq.ndrec", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n {inst_3 : DecidableEq F} [inst_4 : DecidableEq F] (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (nodes nodes_1 : Fin (c + 1) → F),\n nodes = nodes_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (H H_1 : Finset F),\n H = H_1 →\n ∀ (p p_1 : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n p = p_1 →\n ∀\n (M M_1 :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n M = M_1 →\n ∀ (A A_1 : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n A = A_1 →\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p M A =\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ_1 nodes_1 ζ_1 H_1 p_1 M_1 A_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest polynomial oracles always return the requested homogeneous bit. ", + "end_line": 154, + "is_class": false, + "kind": "theorem", + "line": 130, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : NeZero m]\n [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree < m ^ c →\n ∀ (a b : σ → F) (z : Fˣ) (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P))))\n (PCP.Algebraic.BinaryLocalCorrection.honestTable ρ P a) a b z v w s =\n some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) w)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.run", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryLocalCorrection.honestTable", + "Option.some", + "PCP.Algebraic.Hadamard.linearEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.two_mul_nonzero_count._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a)", + "type_dependencies": [ + "DecidablePred", + "Finset", + "Eq", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.filter", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a)", + "type_dependencies": [ + "DecidablePred", + "Finset", + "Eq", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.filter", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.honestTable.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : NeZero m]\n (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (P P_1 : MvPolynomial σ F),\n P = P_1 →\n ∀ (a a_1 : σ → F),\n a = a_1 →\n ∀ (b b_1 : σ → F),\n b = b_1 →\n ∀ (a_2 a_3 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c),\n a_2 = a_3 →\n ∀ (a_4 a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n a_4 = a_5 →\n PCP.Algebraic.BinaryLocalCorrection.honestTable ρ P a b a_2 a_4 =\n PCP.Algebraic.BinaryLocalCorrection.honestTable ρ_1 P_1 a_1 b_1 a_3 a_5", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "MvPolynomial", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.honestTable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.distance_expect", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : DecidableEq B] (k l : A → B),\n PCP.Algebraic.relativeDistance k l = Finset.univ.expect fun a => if k a ≠ l a then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "ite", + "Ne", + "instDecidableNot", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "constructor", + "line": 23, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Machine.Sym" + ], + "type": "Bool → PCP.Machine.Sym", + "type_dependencies": [ + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The only discrepancy from always returning the zero-parameter correction\nis actual rejection, exactly rather than merely as an upper bound. ", + "end_line": 135, + "is_class": false, + "kind": "theorem", + "line": 120, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.distance_sample_to_corrected", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a) fun s =>\n some (PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H (fun x => 0) s)) =\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 67, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β → ℚ),\n (PCP.Algebraic.BLR.average fun x => ∑ y, f x y) = ∑ y, PCP.Algebraic.BLR.average fun x => f x y", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), PCP.Machine.Sym.bit b = PCP.Machine.Sym.sep → False", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.properPolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (E Q : MvPolynomial σ F),\n PCP.Algebraic.ThreeColorGrid.properPolynomial E Q = E * PCP.Algebraic.ThreeColorGrid.validPolynomial Q", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.ThreeColorGrid.validPolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "An actual query to one of the eight physical tables. ", + "end_line": 136, + "is_class": false, + "kind": "inductive", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "constructor", + "line": 37, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n (PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), PCP.Machine.Sym.sep = PCP.Machine.Sym.bit b → False", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.bit", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n (ctorIdx : ℕ) →\n {a : ℕ} → (t : PCP.QueryTree a) → ctorIdx = t.ctorIdx → PCP.QueryTree.ctorElimType ctorIdx → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "PCP.QueryTree.ctorElimType" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "PCP.QueryTree.ctorElimType", + "PCP.QueryTree.casesOn", + "Bool", + "PULift.down", + "PCP.QueryTree.leaf", + "Eq.ndrec", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete list certifies a constant number of bit queries for fixed `c`. ", + "end_line": 368, + "is_class": false, + "kind": "theorem", + "line": 361, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n (PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s).length ≤ 20 * c + 107", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "PCP.QueryTree.addresses.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 201, + "is_class": false, + "kind": "theorem", + "line": 183, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.distance_point_bits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t r : ℕ} [inst_1 : Fintype F] [inst_2 : Fintype σ]\n [inst_3 : DecidableEq σ] {A : Type u_3} [inst_4 : DecidableEq A] (k l : (σ → F) → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1) s.2.2.1.2) fun s =>\n l (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1) s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.digit.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (k k_1 : ℕ),\n k = k_1 → ∀ (i i_1 : ℕ), i = i_1 → PCP.Algebraic.digit m k i = PCP.Algebraic.digit m k_1 i_1", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Fin", + "PCP.Algebraic.digit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 140, + "is_class": false, + "kind": "definition", + "line": 140, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Theorem 4.1 at inflated outer degree `c*m^c`, for the actual tester and arbitrary\nauxiliary answers. The only rejection restriction is the explicit final threshold.\nThe second distance is over homogeneous degree-one labels, not all affine ones. ", + "end_line": 359, + "is_class": false, + "kind": "theorem", + "line": 322, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.exists_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] [CharP F 2] [NeZero m],\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ≤\n PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ c * m ^ c ∧\n PCP.Algebraic.relativeDistance (fun p => f p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ ((MvPolynomial.eval x) P)) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P)))) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "Rat.instMul", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.queries_length_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n (PCP.Algebraic.BinaryLowDegreeTest.queries ⋯ ρ nodes s).length ≤ max (2 * 1 + 4) (c + 2) →\n ¬(PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.BinaryLocalCorrection.run._proof_2 ρ nodes s).length +\n (c + 1) +\n (c + 1) +\n 1 ≤\n 3 * c + 9 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "LE.le", + "instLENat", + "List.length", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "Max.max", + "Nat.instMax", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 204, + "is_class": false, + "kind": "definition", + "line": 204, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Fintype F] → {m c t : ℕ} → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Fintype", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Fintype", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Grid vanishing may be tested using coordinatewise subtypes. ", + "end_line": 88, + "is_class": false, + "kind": "theorem", + "line": 83, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.vanishesOn_iff_grid", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (H : Finset F) (P : MvPolynomial σ F),\n PCP.Algebraic.GridVanishing.VanishesOn H P ↔ ∀ (a : σ → ↥H), (MvPolynomial.eval fun i => ↑(a i)) P = 0", + "type_dependencies": [ + "Field", + "Finset", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Iff", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.evaluationPoint.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ) (x : R) (ij : PCP.Algebraic.SetMultilinear.Variables m c),\n PCP.Algebraic.SetMultilinear.evaluationPoint m c x ij = x ^ (↑ij.2 * m ^ ↑ij.1)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "PCP.Algebraic.SetMultilinear.Variables", + "Eq", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V))\n (PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg_1 : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R)\n (polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)),\n ({ PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 }) =\n (PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1)", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 205, + "is_class": false, + "kind": "definition", + "line": 205, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeCallSeedSumFin_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [Fintype F] →\n [DecidableEq F] →\n {n m c t : ℕ} → Fintype (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instDecidableEqSum", + "instDecidableEqFin", + "instFintypeSum", + "Fin.fintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The corrected comparison bit. ", + "end_line": 46, + "is_class": false, + "kind": "definition", + "line": 42, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n F →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 75, + "is_class": false, + "kind": "theorem", + "line": 71, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_digitMonomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n (PCP.Algebraic.SetMultilinear.decode m c) (PCP.Algebraic.SetMultilinear.digitMonomial m c k) =\n Polynomial.X ^ (k % m ^ c)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.X", + "HMod.hMod", + "instHMod", + "Nat.instMod", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodeTriple._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (t : List Bool × List Bool × List Bool),\n ¬t.1.length + (t.2.1.length + (t.2.2.length + 1) + 1) = t.1.length + t.2.1.length + t.2.2.length + 2 → False", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Not", + "Eq", + "Nat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {t t' : PCP.Machine.Sym} → t = t' → PCP.Machine.Sym.noConfusionType P t t'", + "type_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "PCP.Machine.Sym.noConfusionType" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Eq.ndrec", + "PCP.Machine.Sym.noConfusionType", + "PCP.Machine.Sym.casesOn", + "Bool", + "Eq.refl" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.oracleOfWitness.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (w : List Bool) (j : ℕ), PCP.oracleOfWitness w j = w.getD j false", + "type_dependencies": [ + "List", + "Bool", + "Nat", + "Eq", + "PCP.oracleOfWitness", + "List.getD", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (u v : σ → F) (f g : (σ → F) → F),\n (∀ x ∈ PCP.Algebraic.GeneratorLowDegreeTest.queries c ζ u v, f x = g x) →\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v = PCP.Algebraic.GeneratorLowDegreeTest.check c ζ g u v", + "type_dependencies": [ + "Field", + "Nat", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instFintypeSym.match_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : PCP.Machine.Sym → Sort u_1) →\n (x : PCP.Machine.Sym) → ((a : Bool) → motive (PCP.Machine.Sym.bit a)) → (Unit → motive PCP.Machine.Sym.sep) → motive x", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "Unit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "Unit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 44, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.eval_coordinate_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ) (x : σ → R),\n x i ∈ H → (MvPolynomial.eval x) (PCP.Algebraic.GridVanishing.coordinate H i) = 0", + "type_dependencies": [ + "CommRing", + "Finset", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.GridVanishing.coordinate", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testQueries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n PCP.Algebraic.Hadamard.testQueries hr s =\n [s.base, s.auxiliary, s.base + s.auxiliary, PCP.Algebraic.BinaryPolynomialSpace.constant 1 + s.base,\n PCP.Algebraic.Hadamard.TestRandomness.linearQuery hr s + s.base,\n PCP.Algebraic.Hadamard.TestRandomness.linearQuery hr s] ++\n List.flatMap (fun k => [s.productQuery k + s.base, s.factorQuery k + s.base]) (List.finRange (r - 1))", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Eq", + "List", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.Hadamard.testQueries", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "PCP.Algebraic.Hadamard.TestRandomness.base", + "PCP.Algebraic.Hadamard.TestRandomness.auxiliary", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "PCP.Algebraic.BinaryPolynomialSpace.constant", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.Hadamard.TestRandomness.linearQuery", + "List.nil", + "List.flatMap", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "PCP.Algebraic.Hadamard.TestRandomness.productQuery", + "PCP.Algebraic.Hadamard.TestRandomness.factorQuery", + "List.finRange" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.digitExponents m c k = ∑ i, Finsupp.single (i, PCP.Algebraic.digit m k ↑i) 1", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitExponents", + "Finset.sum", + "Fin", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "Finsupp.single", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 193, + "is_class": false, + "kind": "theorem", + "line": 151, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : F → F),\n f 0 = 0 →\n (∀ (i : Fin (c + 1)), f (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i) = 0) →\n (∀ (v : F),\n PCP.Algebraic.WeightedConstraint.predict (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f 0 v =\n 0) →\n ∀ (x : F), f x = 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.WeightedConstraint.predict", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeTest.0.PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3)\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p))\n (h_2 :\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inr p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_2 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {F : Type u_2} →\n {n m c t : ℕ} →\n {t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t} →\n {F' : Type u_2} →\n {n' m' c' t' : ℕ} →\n {t'_1 : PCP.Algebraic.ThreeColorVerifier.Query F' n' m' c' t'} →\n F = F' →\n n = n' →\n m = m' →\n c = c' → t = t' → t_1 ≍ t'_1 → PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType P t_1 t'_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "HEq", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "HEq.refl", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "eq_of_heq" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instReprSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "Repr PCP.Machine.Sym", + "type_dependencies": [ + "Repr", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Repr.mk", + "PCP.Machine.Sym", + "PCP.Machine.instReprSym.repr" + ] + }, + { + "axioms": [], + "doc": "A \"proxy type\" equivalent to `PCP.Machine.Sym` that is constructed from `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum`. See `PCP.Machine.Sym.proxyTypeEquiv` for the equivalence. (Generated by the `proxy_equiv%` elaborator.)", + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.proxyType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "Sum", + "Bool", + "Unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.rejectionProbability.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] [inst_1 : Add V] (H : V → ZMod 2),\n PCP.Algebraic.BLR.rejectionProbability H =\n PCP.Algebraic.relativeDistance (fun p => H (p.1 + p.2)) fun p => H p.1 + H p.2", + "type_dependencies": [ + "Fintype", + "Add", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.rejectionProbability", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "ZMod.decidableEq", + "HAdd.hAdd", + "instHAdd", + "Prod.fst", + "Prod.snd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 330, + "is_class": false, + "kind": "theorem", + "line": 322, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.exists_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ],\n 2 * c < Fintype.card F →\n ∀ {a : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes a →\n ∀ (f : (σ → F) → F) {δ : ℚ},\n PCP.Algebraic.FixedLagrangeConstraint.rejectionRate a f ≤ δ →\n δ < 1 / (2 * (↑c + 2) ^ 2) →\n ∃ P, P.totalDegree ≤ c ∧ (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤ 2 * δ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Option (ZMod 2) → Option (ZMod 2) → Option (ZMod 2) → Sort u_1) (p m₀ mZ : ZMod 2)\n (h_1 : (p m₀ mZ : ZMod 2) → motive (some p) (some m₀) (some mZ))\n (h_2 : (x x_1 x_2 : Option (ZMod 2)) → motive x x_1 x_2),\n (match some p, some m₀, some mZ with\n | some p, some m₀, some mZ => h_1 p m₀ mZ\n | x, x_1, x_2 => h_2 x x_1 x_2) =\n h_1 p m₀ mZ", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_linearEncode._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 140, + "is_class": false, + "kind": "theorem", + "line": 138, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm_single", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (a : ι → ZMod 2) (i : ι),\n (PCP.Algebraic.BLR.linearForm a) (Pi.single i 1) = a i", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm", + "Pi.single", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodePair._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : List Bool × List Bool), ¬p.1.length + (p.2.length + 1) = p.1.length + p.2.length + 1 → False", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Not", + "Eq", + "Nat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → (n m c t : ℕ) → [SizeOf F] → SizeOf (PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "SizeOf.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.totalDegree_validPolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F),\n (PCP.Algebraic.ThreeColorGrid.validPolynomial P).totalDegree ≤ 3 * P.totalDegree", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.clauses.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {C : Type u_1} {k : ℕ} (motive : PCP.Reduction.FiniteBooleanConstraints.Clause C k → Sort u_2) (e : C)\n (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) (j : Fin 2)\n (h_1 :\n (e : C) →\n (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) →\n (i : Fin k) → (j : Fin 3) → motive (e, p, Sum.inl (i, j)))\n (h_2 : (e : C) → (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) → (j : Fin 2) → motive (e, p, Sum.inr j)),\n (match (e, p, Sum.inr j) with\n | (e, p, Sum.inl (i, j)) => h_1 e p i j\n | (e, p, Sum.inr j) => h_2 e p j) =\n h_2 e p j", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Prod.mk", + "Prod", + "Sum", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Reduction.FiniteBooleanConstraints.clauses.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every monomial contains exactly one variable from each block. The zero\npolynomial satisfies this condition because its support is empty. ", + "end_line": 174, + "is_class": false, + "kind": "definition", + "line": 171, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.IsSetMultilinear", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] → (m c : ℕ) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R → Prop", + "type_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial.support", + "Fin", + "Eq", + "Finset.sum", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "DFunLike.coe", + "Finsupp.instFunLike", + "Prod.mk", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False", + "type_dependencies": [ + "Mul", + "Zero", + "NoZeroDivisors", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Eq", + "HMul.hMul", + "instHMul", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (accept : Bool), sizeOf (PCP.QueryTree.leaf accept) = 1 + sizeOf d + sizeOf accept", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "SizeOf.sizeOf", + "PCP.QueryTree", + "PCP.QueryTree._sizeOf_inst", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "instSizeOfNat", + "Bool._sizeOf_inst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "definition", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 4 →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {P_1 : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {t : PCP.NPCertificate P_1 L} →\n {P' : (List Bool → List Bool → Bool) → Prop} →\n {L' : PCP.Language} →\n {t' : PCP.NPCertificate P' L'} → P_1 = P' → L = L' → t ≍ t' → PCP.NPCertificate.noConfusionType P t t'", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Eq", + "HEq", + "PCP.NPCertificate.noConfusionType" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.NPCertificate.noConfusionType", + "PCP.NPCertificate.casesOn", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Bool.true", + "Eq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The random strings on which `V` accepts `x` given proof `π`. ", + "end_line": 99, + "is_class": false, + "kind": "definition", + "line": 97, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.acceptingRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : PCP.Verifier) → (x : List Bool) → PCP.ProofOracle → Finset (Fin (2 ^ V.randomness x.length))", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Finset", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Finset.filter", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Eq", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "Bool.true", + "instDecidableEqBool", + "Finset.univ", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ) (i : Fin (c + 1)), ¬0 < ↑i + 1 + (n - (c + 1)) → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "LT.lt", + "instLTNat", + "Fin.val", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Query proof address `addr`, then continue in `onFalse` or `onTrue`. ", + "end_line": 37, + "is_class": false, + "kind": "constructor", + "line": 36, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query", + "provenance": "lean", + "structural_dependencies": [ + "PCP.QueryTree" + ], + "type": "{d : ℕ} → ℕ → PCP.QueryTree d → PCP.QueryTree d → PCP.QueryTree (d + 1)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 161, + "is_class": false, + "kind": "definition", + "line": 158, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3 →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine" + ] + }, + { + "axioms": [], + "doc": "An equivalence between the \"proxy type\" `PCP.Machine.Sym.proxyType` and `PCP.Machine.Sym`. The proxy type is a reducible definition that represents the inductive type using `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum` (and whatever other inductive types appear within the inductive type), and the intended use is to define typeclass instances uses pre-existing instances on these. (Generated by the `proxy_equiv%` elaborator.)", + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.proxyTypeEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool ⊕ Unit ≃ PCP.Machine.Sym", + "type_dependencies": [ + "Equiv", + "Sum", + "Bool", + "Unit", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Equiv.mk", + "Sum", + "Bool", + "Unit", + "PCP.Machine.Sym", + "PCP.Machine.instFintypeSym.match_3", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.instFintypeSym.match_5", + "Sum.inl", + "Sum.inr", + "Unit.unit", + "Sum.casesOn", + "Eq", + "Eq.ndrec", + "Eq.refl", + "Eq.symm", + "PCP.Machine.Sym.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (c : ℕ) (ζ : F) (i : Fin (c + 1)),\n PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i = ζ ^ (↑i + 1)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Both uses of inner correction, distinguished by the selected parameter. ", + "end_line": 112, + "is_class": false, + "kind": "definition", + "line": 108, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n (Fˣ → F) → PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testRejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n 0 ≤ PCP.Algebraic.Hadamard.testRejectionRate hr H", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.Hadamard.testRejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All three checks must pass; the two tester seeds are independent. ", + "end_line": 57, + "is_class": false, + "kind": "definition", + "line": 48, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n 1 ≤ r →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool.and", + "PCP.Algebraic.Hadamard.test", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "Decidable.decide", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 256, + "is_class": false, + "kind": "theorem", + "line": 253, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_differenceCheckQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery q) =\n PCP.Algebraic.BinaryDifferenceConsistency.read π.color π.difference q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery", + "PCP.Algebraic.BinaryDifferenceConsistency.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 249, + "is_class": false, + "kind": "theorem", + "line": 244, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ c →\n ∀ (u v : σ → F), PCP.Algebraic.GeneratorLowDegreeTest.check c ζ (fun x => (MvPolynomial.eval x) P) u v = 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x x_1 : PCP.Machine.Sym) → Decidable (x = x_1)", + "type_dependencies": [ + "PCP.Machine.Sym", + "Decidable", + "Eq" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.instDecidableEqSym.decEq.match_1", + "Decidable", + "Eq", + "Bool", + "dite", + "PCP.Machine.Sym.bit", + "instDecidableEqBool", + "Eq.ndrec", + "Decidable.isTrue", + "PCP.Machine.instDecidableEqSym.decEq._proof_1", + "Not", + "Decidable.isFalse", + "PCP.Machine.instDecidableEqSym.decEq._proof_2", + "PCP.Machine.Sym.sep", + "PCP.Machine.instDecidableEqSym.decEq._proof_3", + "PCP.Machine.instDecidableEqSym.decEq._proof_4", + "Unit", + "rfl" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d),\n sizeOf (PCP.QueryTree.query addr onFalse onTrue) = 1 + sizeOf d + sizeOf addr + sizeOf onFalse + sizeOf onTrue", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "SizeOf.sizeOf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree._sizeOf_inst", + "PCP.QueryTree.query", + "instSizeOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (a : Fin (c + 1) → F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.FixedLagrangeConstraint.check a f u v = PCP.Algebraic.LagrangeConstraint.check a f u v 0", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.FixedLagrangeConstraint.check", + "PCP.Algebraic.LagrangeConstraint.check", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {P_1 : Sort u} →\n {witnessBound : Polynomial ℕ} →\n {check : List Bool → List Bool → Bool} →\n {check_polyTime : P check} →\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true} →\n {witnessBound' : Polynomial ℕ} →\n {check' : List Bool → List Bool → Bool} →\n {check_polyTime' : P check'} →\n {spec' :\n ∀ (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound' ∧ check' x w = true} →\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound', check := check', check_polyTime := check_polyTime',\n spec := spec' } →\n (witnessBound = witnessBound' → check = check' → P_1) → P_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk", + "id", + "PCP.NPCertificate.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Only the difference-table point is pulled back through the coordinate equivalence. ", + "end_line": 178, + "is_class": false, + "kind": "definition", + "line": 174, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "Function.comp", + "Sum", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "Prod.mk", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type (max u_2 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1) →\n ((x : Fin (n + n) ⊕ Fin (n + n) → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin (n + n) ⊕ Fin (n + n))) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [inst : Fintype F], 1 < Fintype.card F → Fintype.card F - 1 = 0 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Line, full-field parameter, correction direction and label, and both test seeds. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → ℕ → Type (max (max u_4 u_3) u_3)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.ClauseHolds", + "provenance": "lean", + "structural_dependencies": [], + "type": "{W : Type u_3} → (Fin 3 → PCP.Reduction.NAEThreeColor.Literal W) → (W → Bool) → Prop", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "Or", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "Fin.instOfNat", + "PCP.Reduction.FiniteBooleanConstraints.ClauseHolds._proof_1", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A fixed positive repetition count, independent of every input and proof. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "PCP.Algebraic.RationalRepetitionBound.repetitions", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n PCP.Algebraic.SetMultilinear.boundedEncode m c d = PCP.Algebraic.SetMultilinear.boundedEncode m c d", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Subtype", + "Polynomial", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.boundedEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "A decision tree over a Boolean proof oracle, of depth at most `d`.\n\n`leaf` may occur at any depth, so `QueryTree d` is \"at most `d` queries\", not \"exactly `d`\". ", + "end_line": 37, + "is_class": false, + "kind": "inductive", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree", + "provenance": "lean", + "structural_dependencies": [ + "PCP.QueryTree.leaf", + "PCP.QueryTree.query", + "PCP.QueryTree" + ], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validGridQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3) →\n ((x : Fin n → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((fst : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n) →\n (x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (fst, Sum.inl (x, q)))) →\n ((a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n) →\n (b : Fin n ⊕ Fin n → F) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr (a, Sum.inr (b, x, q)))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The bit comparison is tested even when either consistency check also fails. ", + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.comparison_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H) fun s =>\n f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2.2.1.2)) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "ZMod.decidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.PolynomialLine.point", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness: a polynomial-time verifier algorithm is computable. This rules out a degenerate\nmodel that counts an arbitrary, even noncomputable, step function as efficient; such a model\nwould let a \"verifier\" decide the language outright. ", + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 89, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.polyTimeAlg_computable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (self : PCP.CostModel) (alg : PCP.VerifierAlg), self.PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2", + "type_dependencies": [ + "PCP.CostModel", + "PCP.VerifierAlg", + "PCP.CostModel.PolyTimeAlg", + "Computable", + "Prod", + "List", + "Bool", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.list", + "Primcodable.bool", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_linearEncode._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b ≠ 0) = (a ≠ b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "Ne", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "Eq", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The Boolean decision, where `true` means accept. ", + "end_line": 73, + "is_class": false, + "kind": "definition", + "line": 69, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.test", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} →\n 1 ≤ r →\n (PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) → PCP.Algebraic.Hadamard.TestRandomness t r → Bool", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness", + "Bool" + ], + "value_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness", + "Decidable.decide", + "PCP.Algebraic.Hadamard.testAccepts", + "Classical.propDecidable" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → [SizeOf F] → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.rec", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False", + "type_dependencies": [ + "Zero", + "OfNat", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "NeZero", + "Eq", + "Zero.toOfNat0", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n (PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest rejection is zero under exactly the finite sampling used by the tester. ", + "end_line": 164, + "is_class": false, + "kind": "theorem", + "line": 157, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : NeZero m]\n [CharP F 2] [inst_4 : Fintype F] [inst_5 : Fintype σ] [inst_6 : DecidableEq σ] (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree < m ^ c →\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P))))\n (PCP.Algebraic.EncodedLineLowDegreeTest.honestTable ρ P) =\n 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Eq", + "Rat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same bound stated using the received point oracle's exact homogeneous distance. ", + "end_line": 331, + "is_class": false, + "kind": "theorem", + "line": 315, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {D : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a)\n fun s => some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2.2.1.2)) ≤\n (PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a +\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Prod.snd", + "Prod.fst", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.Hadamard.encode", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Equation (3.1): the point at which the encoded polynomial recovers `P(λ)`. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 62, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.evaluationPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → [CommSemiring R] → (m c : ℕ) → R → PCP.Algebraic.SetMultilinear.Variables m c → R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "PCP.Algebraic.SetMultilinear.Variables", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The decision tree used on input `x` and random string `r`. ", + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 91, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.run", + "provenance": "lean", + "structural_dependencies": [], + "type": "(self : PCP.Verifier) → (x : List Bool) → Fin (2 ^ self.randomness x.length) → PCP.QueryTree self.queries", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.queries" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "With small rejection, the actual all-parameter correction is an ordinary\ntotal-degree-bounded polynomial in every finite dimension. ", + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.PointLineTest.exists_polynomial_correction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {d : ℕ},\n 0 < d →\n PCP.Algebraic.PointLineConstants.fieldFactor * d ^ 3 ≤ Fintype.card F →\n ∀ (f : (σ → F) → F),\n PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable d f) ≤\n PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ d ∧\n ∀ (x : σ → F),\n (MvPolynomial.eval x) P =\n PCP.Algebraic.PointLineTest.correction (PCP.Algebraic.PointLineTest.decodedTable d f) x", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineTest.decodedTable", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "MvPolynomial.totalDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.PointLineTest.correction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 219, + "is_class": false, + "kind": "theorem", + "line": 216, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_validQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.validQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.validCert π.validLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.validQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The sum of both local-correction losses and the two direct rejection losses. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HAdd.hAdd", + "Rat", + "instHAdd", + "Rat.instAdd", + "OfNat.ofNat", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "instAddNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The paper's `2*r+4` query bound, with exact accounting for response reuse. ", + "end_line": 92, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testQueries_length", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n (PCP.Algebraic.Hadamard.testQueries hr s).length = 2 * r + 4", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Eq", + "List.length", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.Hadamard.testQueries", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A colorable graph has zero rejection under the actual complete finite seed. ", + "end_line": 141, + "is_class": false, + "kind": "theorem", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_rejectionRate_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [NeZero m] [CharP F 2]\n [inst_4 : Fintype F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n G.Colorable 3 →\n 5 * ((H.card - 1) * n) < m ^ c →\n ∃ π, PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π = 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "SimpleGraph.Colorable", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Exists", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "Classical.propDecidable", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval_congr._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x)\n (f :\n PCP.QueryTree.below (motive := fun x x_2 =>\n ∀ (x_3 x_4 : PCP.ProofOracle), (∀ a ∈ x_2.addresses, x_3 a = x_4 a) → x_2.eval x_3 = x_2.eval x_4) x_1)\n (x_2 x_3 : PCP.ProofOracle), (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → x_1.eval x_2 = x_1.eval x_3", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.eval" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.eval", + "PCP.QueryTree.eval_congr.match_1_1", + "PCP.QueryTree.leaf", + "rfl", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "of_eq_true", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "Eq.trans", + "Or", + "True", + "Finset.mem_insert._simp_1", + "congr", + "congrArg", + "eq_self", + "Finset.mem_union._simp_1", + "true_or", + "PProd", + "Eq.mpr", + "id", + "Iff.mpr", + "Not", + "Classical.or_iff_not_imp_left", + "False.elim", + "ite", + "Bool.true", + "instDecidableEqBool", + "congrFun'", + "ite_congr" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.splitter._sparseCasesOn_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "{α : Type u} →\n {motive : Option α → Sort u_1} →\n (t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t", + "type_dependencies": [ + "Option", + "Option.some", + "Nat.hasNotBit", + "Option.ctorIdx" + ], + "value_dependencies": [ + "Option", + "Option.some", + "Option.rec", + "Nat.hasNotBit", + "Option.ctorIdx", + "Option.none", + "Nat.ne_of_beq_eq_false", + "Nat.land", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Nat.shiftRight", + "Eq.refl", + "Bool", + "Bool.false" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → ℕ → ℕ → ℕ → Type u_3", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLowDegreeTest.TestRandomness", + "PCP.Algebraic.SetMultilinear.Variables", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Translation by a vector with nonzero image exchanges the two fibers of a binary homomorphism. ", + "end_line": 75, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.two_mul_nonzero_count", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : AddCommGroup V] [inst_1 : Fintype V] (L : V →+ ZMod 2) (e : V),\n L e ≠ 0 → 2 * {v | L v ≠ 0}.card = Fintype.card V", + "type_dependencies": [ + "AddCommGroup", + "Fintype", + "AddMonoidHom", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "AddMonoidWithOne.toAddMonoid", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Ne", + "DFunLike.coe", + "AddMonoidHom.instFunLike", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "HMul.hMul", + "instHMul", + "instMulNat", + "Finset.card", + "Finset.filter", + "instDecidableNot", + "ZMod.decidableEq", + "Finset.univ", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep.match_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : ℕ → List Bool → Sort u_1) →\n (x : ℕ) →\n (x_1 : List Bool) →\n ((as : List Bool) → motive 0 as) → ((n : ℕ) → (as : List Bool) → motive n.succ as) → motive x x_1", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "OfNat.ofNat", + "instOfNatNat", + "Nat.succ" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "OfNat.ofNat", + "instOfNatNat", + "Nat.succ", + "Nat.casesOn" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {a : ℕ} →\n {t : PCP.QueryTree a} → {a' : ℕ} → {t' : PCP.QueryTree a'} → a = a' → t ≍ t' → PCP.QueryTree.noConfusionType P t t'", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HEq", + "PCP.QueryTree.noConfusionType" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.QueryTree.noConfusionType", + "PCP.QueryTree.casesOn", + "Bool", + "Eq.refl", + "HEq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.read.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n PCP.Algebraic.BinaryLocalCorrection.read f H (Sum.inl p) = f p.1 p.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Prod", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk", + "PCP.Verifier.rec" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.productDegree_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {r : ℕ} (k : Fin (r - 1)), 1 + (↑k + 1) ≤ r", + "type_dependencies": [ + "Nat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The image of `Y ^ k`: one selected variable from every block. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] →\n (m : ℕ) → [NeZero m] → (c : ℕ) → ℕ → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.prod", + "Fin", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "CommSemiring.toCommMonoid", + "AddMonoidAlgebra.commSemiring", + "Finsupp", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "MvPolynomial.X", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 60, + "is_class": false, + "kind": "theorem", + "line": 58, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_X_pow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n (PCP.Algebraic.SetMultilinear.encode m c) (Polynomial.X ^ k) = PCP.Algebraic.SetMultilinear.digitMonomial m c k", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.X", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.read.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n PCP.Algebraic.BinaryLocalCorrection.read f H (Sum.inr p) = H p.1 p.2.1 p.2.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read", + "Sum.inr", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.edgeValue_eq_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (x : Fin (n + n) → F),\n PCP.Algebraic.ThreeColorVerifier.edgeValue H G x =\n (MvPolynomial.eval x) (PCP.Algebraic.ThreeColorVerifier.edgePolynomial H G)", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorVerifier.edgePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (3 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.ofBits.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool), PCP.Machine.ofBits x = List.map PCP.Machine.Sym.bit x", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.ofBits", + "List.map", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 142, + "is_class": false, + "kind": "definition", + "line": 142, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t r : ℕ} →\n [Fintype F] →\n Fintype (PCP.Algebraic.Hadamard.TestRandomness t r × PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 56, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Total degree is additive on nonzero factors over a domain. ", + "end_line": 71, + "is_class": false, + "kind": "theorem", + "line": 66, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.totalDegree_mul_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] {p q : MvPolynomial σ R},\n p ≠ 0 → q ≠ 0 → (p * q).totalDegree = p.totalDegree + q.totalDegree", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "MvPolynomial", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Eq", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.acceptingRandomness.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.acceptingRandomness x π = {r | (V.run x r).eval π = true}", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Eq", + "Finset", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.acceptingRandomness", + "Finset.filter", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "Bool.true", + "instDecidableEqBool", + "Finset.univ", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The exact coordinate flattening used only by the proper-constraint branch. ", + "end_line": 48, + "is_class": false, + "kind": "definition", + "line": 47, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.flatten", + "provenance": "lean", + "structural_dependencies": [], + "type": "(n : ℕ) → Fin n ⊕ Fin n ≃ Fin (n + n)", + "type_dependencies": [ + "Nat", + "Equiv", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "finSumFinEquiv" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "Eq", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 32, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 122, + "is_class": false, + "kind": "theorem", + "line": 115, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.rejection_bias", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] [Nonempty V] [inst_2 : Add V] (H : V → ZMod 2),\n (PCP.Algebraic.BLR.average fun x =>\n PCP.Algebraic.BLR.average fun y =>\n PCP.Algebraic.BLR.sign (H x) * PCP.Algebraic.BLR.sign (H y) * PCP.Algebraic.BLR.sign (H (x + y))) =\n 1 - 2 * PCP.Algebraic.BLR.rejectionProbability H", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Add", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.average", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.sign", + "HAdd.hAdd", + "instHAdd", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "PCP.Algebraic.BLR.rejectionProbability" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "SMulCommClass (ZMod 2) (ZMod 2) (ZMod 2)", + "type_dependencies": [ + "SMulCommClass", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Algebra.toSMul", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Algebra.id", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.finiteWitnessCheck.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w =\n decide (∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true)", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Eq", + "PCP.finiteWitnessCheck", + "Decidable.decide", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "PCP.oracleOfWitness", + "Bool.true", + "Nat.decidableForallFin", + "instDecidableEqBool" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), sizeOf (PCP.Machine.Sym.bit b) = 1 + sizeOf b", + "type_dependencies": [ + "Bool", + "Eq", + "Nat", + "SizeOf.sizeOf", + "PCP.Machine.Sym", + "PCP.Machine.Sym._sizeOf_inst", + "PCP.Machine.Sym.bit", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Bool._sizeOf_inst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "theorem", + "line": 29, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.BLR.sign 0 = 1", + "type_dependencies": [ + "Eq", + "Rat", + "PCP.Algebraic.BLR.sign", + "OfNat.ofNat", + "ZMod", + "Nat", + "instOfNatNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 155, + "is_class": false, + "kind": "theorem", + "line": 143, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.chain_eq_flag", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {k : ℕ} (x p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) (z : Fin (k + 1) → Bool),\n z 0 = false →\n (∀ (i : Fin k), z i.succ = (z i.castSucc || x i ^^ p i)) →\n ∀ (i : Fin (k + 1)), z i = PCP.Reduction.FiniteBooleanConstraints.flag x p ↑i", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Bool", + "Eq", + "Fin.instOfNat", + "instNeZeroNatHAdd_1", + "Nat.instNeZeroSucc", + "Bool.false", + "Fin.succ", + "Bool.or", + "Fin.castSucc", + "Bool.xor", + "PCP.Reduction.FiniteBooleanConstraints.flag", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk", + "PCP.NPCertificate.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_comm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β → ℚ),\n (PCP.Algebraic.BLR.average fun x => PCP.Algebraic.BLR.average (f x)) =\n PCP.Algebraic.BLR.average fun y => PCP.Algebraic.BLR.average fun x => f x y", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`NP ⊆ PCP(O(log n), O(1))`, with one polynomial-time verifier for each language.\nAll constants and the proof-length polynomial are independent of the input. ", + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 23, + "module": "PCP.Theorem", + "name": "PCP.np_subset_pcp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (L : PCP.Language),\n PCP.InNP PCP.Machine.PolyTimeRel L →\n ∃ V alg a b q p,\n PCP.Machine.PolyTimeAlg alg ∧\n V.ImplementedBy alg ∧\n V.queries = q ∧\n V.CanonicalRandomness a b ∧\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) ∧\n (∀ (x : List Bool), L x → V.CompleteAt x) ∧ ∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)", + "type_dependencies": [ + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "And", + "PCP.Machine.PolyTimeAlg", + "PCP.Verifier.ImplementedBy", + "Eq", + "PCP.Verifier.queries", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A uniform cost model: what \"polynomial time\" means for witness-checking relations and for\nverifier algorithms, together with the coherence and closure properties any genuine model has.\n\nThe field docstrings explain why each field is present. **The machine model is no longer a choice**:\n`PCP/Complexity/Machine.lean` fixes it as `Turing.TM2ComputableInPolyTime`. Showing those concrete\npredicates satisfy this interface was obligation NP-1, now discharged: the two coherence fields in\n`PCP/Complexity/Bridge.lean`, the closure field below in `PCP/Complexity/StandardModel.lean`.\nNote the known cost of that choice: *some* certified composition or subroutine result is needed for\nthe closure field, and mathlib's `comp` is an open `proof_wanted` at the pinned revision. That\nupstream theorem is one route; a specialised call-and-return construction for these fixed encodings\nis another, and is the one that was built. ", + "end_line": 108, + "is_class": false, + "kind": "inductive", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel", + "provenance": "lean", + "structural_dependencies": [ + "PCP.CostModel.mk", + "PCP.CostModel" + ], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All seven branches must accept. ", + "end_line": 121, + "is_class": false, + "kind": "definition", + "line": 117, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.test", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.Sample F n m c t → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.FiniteConjunction.test", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "definition", + "line": 49, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.correct", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat" + ], + "value_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.WeightedConstraint.predict", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "_private.PCP.Algebraic.BinaryLocalCorrection.0.PCP.Algebraic.BinaryLocalCorrection.read.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t : ℕ} →\n (motive : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → Sort u_3) →\n (x : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl p)) →\n ((p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.inr" + ], + "value_dependencies": [ + "PCP.Algebraic.BinaryLocalCorrection.read.match_1" + ] + }, + { + "axioms": [], + "doc": "The depth-`d` decision tree generated by unfolding a step function, starting from the answers\n`as` received so far.\n\nIf the step function has not halted within its `d`-query budget the tree rejects: an algorithm\nclaiming a `q`-query verifier must halt within `q` queries, and `ImplementedBy` below is what\nforces that to match the verifier's actual behaviour. ", + "end_line": 47, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Nat.brecOn", + "PCP.QueryTree", + "PCP.QueryTree.ofStep._f" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 77, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.expect_sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ]\n (k : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r → ℚ),\n (Finset.univ.expect fun s => k s) =\n Finset.univ.expect fun uv =>\n Finset.univ.expect fun z => Finset.univ.expect fun vw => Finset.univ.expect fun hi => k (uv, z, vw, hi)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "instFintypeProd", + "Pi.instFintype", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed_1", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.NAEThreeColor.Literal.eval.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a : V → Bool) (a_1 : V) (a_2 : Bool),\n PCP.Reduction.NAEThreeColor.Literal.eval a (PCP.Reduction.NAEThreeColor.Literal.var a_1 a_2) = (a a_1 ^^ a_2)", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Bool.xor" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.negate.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_3} (v : W) (b : Bool),\n PCP.Reduction.FiniteBooleanConstraints.negate (PCP.Reduction.NAEThreeColor.Literal.var v b) =\n PCP.Reduction.NAEThreeColor.Literal.var v !b", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.negate", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Bool.not" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All four families of checks in HadTest. ", + "end_line": 67, + "is_class": false, + "kind": "definition", + "line": 58, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testAccepts", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} →\n 1 ≤ r →\n (PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) → PCP.Algebraic.Hadamard.TestRandomness t r → Prop", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness" + ], + "value_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness", + "And", + "Eq", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "PCP.Algebraic.Hadamard.TestRandomness.base", + "PCP.Algebraic.Hadamard.TestRandomness.auxiliary", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.BinaryPolynomialSpace.constant", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "PCP.Algebraic.Hadamard.TestRandomness.linearQuery", + "Fin", + "instSubNat", + "PCP.Algebraic.Hadamard.TestRandomness.productQuery", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "PCP.Algebraic.Hadamard.TestRandomness.factorQuery" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every branch's list is mapped to physical proof-table locations. ", + "end_line": 201, + "is_class": false, + "kind": "definition", + "line": 184, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n (i : Fin 7) →\n PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i →\n List (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Fin.cases", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Fin.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_1", + "List.map", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.ThreeColorVerifier.colorQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_3", + "Fin.succ", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_2", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.validQuery", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_4", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_3", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_4", + "PCP.Algebraic.ThreeColorVerifier.properQuery", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_6", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_8", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery", + "PCP.Algebraic.BinaryDifferenceConsistency.queries", + "Prod.fst", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "Prod", + "Prod.snd", + "Fin.elim0" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "Three standard clauses enforce exactly one Boolean OR gate. ", + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 43, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.orGate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{W : Type u_3} →\n PCP.Reduction.NAEThreeColor.Literal W →\n PCP.Reduction.NAEThreeColor.Literal W →\n PCP.Reduction.NAEThreeColor.Literal W → Fin 3 → Fin 3 → PCP.Reduction.NAEThreeColor.Literal W", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Matrix.vecCons", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.FiniteBooleanConstraints.negate", + "PCP.Reduction.NAEThreeColor.Literal.const", + "Bool.false", + "Matrix.vecEmpty" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "No branch loses its normalized marginal through an empty independent seed. ", + "end_line": 399, + "is_class": false, + "kind": "theorem", + "line": 397, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchSeedNonempty", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c t : ℕ} (i : Fin 7),\n Nonempty (PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Nonempty", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 387, + "is_class": false, + "kind": "theorem", + "line": 386, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyCallSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t : ℕ} {σ : Type u_2},\n Nonempty (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The normalized rejection of one concrete branch on its own seed. ", + "end_line": 411, + "is_class": false, + "kind": "definition", + "line": 407, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Fin 7 → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "instDecidableEqBool", + "PCP.Algebraic.ThreeColorVerifier.branchTest", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 377, + "is_class": false, + "kind": "definition", + "line": 376, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeProdTestRandomnessInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t : ℕ} →\n [Fintype F] →\n {r : ℕ} →\n Fintype (PCP.Algebraic.Hadamard.TestRandomness t r × PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.clauses.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{C : Type u_1} →\n {k : ℕ} →\n (motive : PCP.Reduction.FiniteBooleanConstraints.Clause C k → Sort u_2) →\n (x : PCP.Reduction.FiniteBooleanConstraints.Clause C k) →\n ((e : C) →\n (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) →\n (i : Fin k) → (j : Fin 3) → motive (e, p, Sum.inl (i, j))) →\n ((e : C) → (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) → (j : Fin 2) → motive (e, p, Sum.inr j)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Prod.mk", + "Prod", + "Sum", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Prod.mk", + "Prod", + "Sum", + "Sum.inl", + "Sum.inr", + "Prod.casesOn", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The full list of oracle locations; shared responses are reused between checks. ", + "end_line": 86, + "is_class": false, + "kind": "definition", + "line": 80, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testQueries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} →\n 1 ≤ r → PCP.Algebraic.Hadamard.TestRandomness t r → List (PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "List", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "HAppend.hAppend", + "List", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "PCP.Algebraic.Hadamard.TestRandomness.base", + "PCP.Algebraic.Hadamard.TestRandomness.auxiliary", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "PCP.Algebraic.BinaryPolynomialSpace.constant", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.Hadamard.TestRandomness.linearQuery", + "List.nil", + "List.flatMap", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "PCP.Algebraic.Hadamard.TestRandomness.productQuery", + "PCP.Algebraic.Hadamard.TestRandomness.factorQuery", + "List.finRange" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.6: concatenate the encodings of a function's values. ", + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 106, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encodeFunction", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t : ℕ} →\n {ι : Type u_1} → (r : ℕ) → (ι → Fin t → ZMod 2) → ι × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 203, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Fintype F] → {m c : ℕ} → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Fintype", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Fintype", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_vanishesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ),\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.GridVanishing.coordinate H i)", + "type_dependencies": [ + "CommRing", + "Finset", + "PCP.Algebraic.GridVanishing.VanishesOn", + "PCP.Algebraic.GridVanishing.coordinate" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.clauses.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {C : Type u_1} {k : ℕ} (motive : PCP.Reduction.FiniteBooleanConstraints.Clause C k → Sort u_2) (e : C)\n (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) (i : Fin k) (j : Fin 3)\n (h_1 :\n (e : C) →\n (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) →\n (i : Fin k) → (j : Fin 3) → motive (e, p, Sum.inl (i, j)))\n (h_2 : (e : C) → (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) → (j : Fin 2) → motive (e, p, Sum.inr j)),\n (match (e, p, Sum.inl (i, j)) with\n | (e, p, Sum.inl (i, j)) => h_1 e p i j\n | (e, p, Sum.inr j) => h_2 e p j) =\n h_1 e p i j", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Prod.mk", + "Prod", + "Sum", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Reduction.FiniteBooleanConstraints.clauses.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every address the tree could query, along any branch. ", + "end_line": 49, + "is_class": false, + "kind": "definition", + "line": 46, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.brecOn", + "Finset", + "PCP.QueryTree.addresses._f" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One actual verifier has all mathematical resource and probability properties,\nincluding the standard soundness target. Efficiency and NP transfer are not asserted. ", + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 70, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verification_guarantees", + "provenance": "lean", + "structural_dependencies": [], + "type": "0 < PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions ∧\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.queries =\n PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 187 ∧\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CanonicalRandomness\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000)\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000) ∧\n (∀ (x : List Bool),\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.ReadsBelow x\n (Polynomial.eval x.length PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound)) ∧\n (∀ (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CompleteAt x) ∧\n ∀ (x : List Bool),\n ¬(PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.SoundAt x (1 / 2)", + "type_dependencies": [ + "And", + "LT.lt", + "Nat", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "Eq", + "PCP.Verifier.queries", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "Nat.instSemiring", + "List.length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Embedding the primary-color low-degree test's queries. ", + "end_line": 152, + "is_class": false, + "kind": "definition", + "line": 149, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.colorQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.colorQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.eval_properPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (E Q : MvPolynomial σ F) (x : σ → F),\n (MvPolynomial.eval x) (PCP.Algebraic.ThreeColorGrid.properPolynomial E Q) =\n (MvPolynomial.eval x) E * ((MvPolynomial.eval x) Q ^ 3 - 1)", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A query list valid for every branch, including both correction sums. ", + "end_line": 79, + "is_class": false, + "kind": "definition", + "line": 69, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (σ → F) →\n (σ → F) →\n Fˣ →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n (Fin t → ZMod 2) →\n PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t →\n List (PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "List", + "PCP.Algebraic.BinaryLocalCorrection.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "List.cons", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "Units.val", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "HAppend.hAppend", + "List", + "Sum", + "PCP.Algebraic.SetMultilinear.Variables", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (f : PCP.QueryTree.below x_1), x_1.addresses.card < 2 ^ x", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", + "Bool", + "PCP.QueryTree.leaf", + "of_eq_true", + "Preorder.toLT", + "PartialOrder.toPreorder", + "Nat.instPartialOrder", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass", + "Nat.instMonoidWithZero", + "MonoidWithZero.toMonoid", + "pow_pos._simp_1", + "LinearOrderedCommMonoidWithZero.toPosMulStrictMono", + "Nat.instLinearOrderedCommMonoidWithZero", + "Nat.instZeroLEOneClass", + "SemilatticeInf.toPartialOrder", + "Lattice.toSemilatticeInf", + "DistribLattice.toLattice", + "instDistribLatticeOfLinearOrder", + "Nat.instLinearOrder", + "instOfNatAtLeastTwo", + "AddMonoidWithOne.toNatCast", + "Nat.instAddMonoidWithOne", + "Nat.instAtLeastTwoHAddOfNat", + "Nat.instNeZeroSucc", + "Eq.trans", + "LE.le", + "Preorder.toLE", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "True", + "Order.lt_two_iff._simp_1", + "Nat.instSuccAddOrder", + "Nat.instNoMaxOrder", + "zero_le._simp_1", + "LinearOrderedCommMonoidWithZero.toIsBotZeroClass", + "Nat.succ", + "PCP.QueryTree.query", + "PProd", + "instLENat", + "Insert.insert", + "Finset", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le.trans", + "Nat.instPreorder", + "Finset.card_insert_le", + "Finset.card_union_le", + "Decidable.byContradiction", + "Nat.decLe", + "Not", + "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", + "id", + "Eq", + "Mathlib.Tactic.Ring.of_eq", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Nat.instCommSemiring", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "Semiring.toMonoid", + "Nat.rawCast", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "instMulZeroClassOfSemiring", + "instMulNat", + "Mathlib.Tactic.Ring.Common.pow_congr", + "Mathlib.Tactic.Ring.cast_pos", + "Mathlib.Meta.NormNum.isNat_ofNat", + "Eq.refl", + "Mathlib.Tactic.Ring.Common.add_congr", + "Mathlib.Tactic.Ring.Common.atom_pf", + "rfl", + "Eq.mpr", + "congrArg", + "Eq.symm", + "Mathlib.Tactic.Ring.Common.add_pf_add_gt", + "Mathlib.Tactic.Ring.Common.add_pf_add_zero", + "Mathlib.Tactic.Ring.Common.pow_add", + "Mathlib.Tactic.Ring.Common.pow_one_cast_of_isNat", + "Mathlib.Meta.NormNum.IsNat.mk", + "Mathlib.Tactic.Ring.Common.single_pow", + "Mathlib.Tactic.Ring.Common.pow_prod_atom", + "Mathlib.Tactic.Ring.Common.pow_zero", + "Mathlib.Tactic.Ring.Common.add_mul", + "Mathlib.Tactic.Ring.Common.mul_add", + "Mathlib.Tactic.Ring.Common.mul_pf_left", + "Mathlib.Meta.NormNum.IsNat.to_raw_eq", + "Mathlib.Meta.NormNum.isNat_mul", + "Mathlib.Meta.NormNum.IsNat.of_raw", + "Mathlib.Tactic.Ring.Common.mul_zero", + "Mathlib.Tactic.Ring.Common.zero_mul", + "Mathlib.Tactic.Ring.Common.mul_pf_right", + "Mathlib.Tactic.Ring.Common.add_pf_add_overlap", + "Mathlib.Tactic.Ring.Common.add_overlap_pf", + "Mathlib.Meta.NormNum.isNat_add", + "Mathlib.Tactic.Ring.Common.add_pf_zero_add", + "Nat.decLt", + "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.encode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (r : ℕ) (x : Fin t → ZMod 2),\n PCP.Algebraic.Hadamard.encode r x = PCP.Algebraic.BinaryPolynomialSpace.evaluate x", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.evaluate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R)", + "type_dependencies": [ + "CommSemiring", + "RingHomCompTriple", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The edge constraint, using the difference table's polynomial. ", + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [inst : Field F] → MvPolynomial σ F → MvPolynomial σ F → MvPolynomial σ F", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.ThreeColorGrid.validPolynomial" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Below the grid size, the only polynomial vanishing on the grid is zero. ", + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 82, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.eq_zero_of_totalDegree_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R) (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p → p.totalDegree < H.card → p = 0", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "MvPolynomial", + "PCP.Algebraic.GridVanishing.VanishesOn", + "LT.lt", + "Nat", + "instLTNat", + "MvPolynomial.totalDegree", + "Finset.card", + "Eq", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : PCP.Machine.Sym → PCP.Machine.Sym → Sort u_1) →\n (x x_1 : PCP.Machine.Sym) →\n ((a b : Bool) → motive (PCP.Machine.Sym.bit a) (PCP.Machine.Sym.bit b)) →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b) PCP.Machine.Sym.sep) →\n ((b : Bool) → motive PCP.Machine.Sym.sep (PCP.Machine.Sym.bit b)) →\n (Unit → motive PCP.Machine.Sym.sep PCP.Machine.Sym.sep) → motive x x_1", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "Unit" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "Unit", + "PCP.Machine.Sym.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.color" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.differenceLiteral.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} (scope : C → Fin k → V) (e : C)\n (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) (i : Fin k),\n PCP.Reduction.FiniteBooleanConstraints.differenceLiteral scope e p i =\n PCP.Reduction.NAEThreeColor.Literal.var (Sum.inl (scope e i)) (p i)", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.differenceLiteral", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Sum.inl", + "PCP.Reduction.FiniteBooleanConstraints.Aux" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A certificate that `L` is in NP relative to a notion `P` of polynomial-time checkability: a\npolynomial witness bound and a witness-checking relation that `P` accepts.\n\n`P` is a plain parameter here, and that is safe *because nothing is proved by quantifying over it*.\n`InNP` is a definition, not a theorem. The two consumers each pin it down:\n\n* `pcp_subset_np` instantiates `P := M.PolyTimeRel` for a `CostModel` `M`, whose closure field is\n what makes the conclusion non-vacuous;\n* `np_subset_pcp` instantiates `P := PCP.Machine.PolyTimeRel`, the concrete machine definition.\n\nNeither quantifies over an arbitrary `P`. The distinction matters:\na *theorem* over an unconstrained interface is refutable by choosing a degenerate instance; a\n*definition* parameterised by one is just a definition. ", + "end_line": 39, + "is_class": false, + "kind": "inductive", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate", + "provenance": "lean", + "structural_dependencies": [ + "PCP.NPCertificate.mk", + "PCP.NPCertificate" + ], + "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Type", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instNonemptyInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F] {m c t : ℕ}, Nonempty (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n PCP.Algebraic.SetMultilinear.encode m c =\n Polynomial.lsum fun k => LinearMap.id.smulRight (PCP.Algebraic.SetMultilinear.digitMonomial m c k)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.lsum", + "LinearMap.smulRight", + "PCP.Algebraic.SetMultilinear.encode._proof_1", + "LinearMap.id", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p)) →\n ((p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 133, + "is_class": false, + "kind": "theorem", + "line": 130, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testRejectionRate_eq_zero_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.testRejectionRate hr H = 0 ↔\n ∀ (s : PCP.Algebraic.Hadamard.TestRandomness t r), PCP.Algebraic.Hadamard.testAccepts hr H s", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Iff", + "Eq", + "Rat", + "PCP.Algebraic.Hadamard.testRejectionRate", + "Rat.instOfNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.Hadamard.testAccepts" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.correct.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.correct c ζ f u v =\n PCP.Algebraic.WeightedConstraint.predict (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f u v", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.correct", + "PCP.Algebraic.WeightedConstraint.predict", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries_length_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n (PCP.Algebraic.BinaryLowDegreeTest.queries ⋯ ρ nodes s.2.2.2.2).length ≤ max (2 * 1 + 4) (c + 2) →\n ¬2 * r + 4 +\n (PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1 ρ nodes\n s.2.2.2.2).length +\n (c + 1) +\n (0 + 1) ≤\n 2 * r + 2 * c + 12 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "LE.le", + "instLENat", + "List.length", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "Prod.snd", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Max.max", + "Nat.instMax", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (color : PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t)\n (validLines differenceLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t)\n (properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t)\n (color_1 :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (validCert_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (difference_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (properCert_1 :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (colorLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t)\n (validLines_1 differenceLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t)\n (properLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t),\n ({ color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines } =\n { color := color_1, validCert := validCert_1, difference := difference_1, properCert := properCert_1,\n colorLines := colorLines_1, validLines := validLines_1, differenceLines := differenceLines_1,\n properLines := properLines_1 }) =\n (color = color_1 ∧\n validCert = validCert_1 ∧\n difference = difference_1 ∧\n properCert = properCert_1 ∧\n colorLines = colorLines_1 ∧\n validLines = validLines_1 ∧ differenceLines = differenceLines_1 ∧ properLines = properLines_1)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 75, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.flagLiteral", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {k : ℕ} →\n C →\n PCP.Reduction.FiniteBooleanConstraints.Pattern k →\n Fin (k + 1) → PCP.Reduction.NAEThreeColor.Literal (PCP.Reduction.FiniteBooleanConstraints.Variable V C k)", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.Variable" + ], + "value_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "Sum.inr", + "PCP.Reduction.FiniteBooleanConstraints.Aux", + "Prod.mk", + "Prod", + "Bool.false" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.flagLiteral.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} (e : C) (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k)\n (i : Fin (k + 1)),\n PCP.Reduction.FiniteBooleanConstraints.flagLiteral e p i =\n PCP.Reduction.NAEThreeColor.Literal.var (Sum.inr (e, p, i)) false", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.flagLiteral", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Sum.inr", + "PCP.Reduction.FiniteBooleanConstraints.Aux", + "Prod.mk", + "Prod", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R}\n {polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)}\n {PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg_1 : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R}\n {polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)},\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 } →\n PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.distance_expect", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : DecidableEq B] (k l : A → B),\n PCP.Algebraic.relativeDistance k l = Finset.univ.expect fun a => if k a ≠ l a then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "ite", + "Ne", + "instDecidableNot", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 112, + "is_class": false, + "kind": "theorem", + "line": 111, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.flag_eq_true_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {k : ℕ} (x p : PCP.Reduction.FiniteBooleanConstraints.Pattern k),\n PCP.Reduction.FiniteBooleanConstraints.flag x p k = true ↔ x ≠ p", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Iff", + "Eq", + "Bool", + "PCP.Reduction.FiniteBooleanConstraints.flag", + "Bool.true", + "Ne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A canonical budget *is* the closed-form function of the two constants.\n\nNamed for what it says. It is an equality of functions, not a proposition of type\n`Computable V.randomness`. None is needed downstream: the closed form is evidently computable, and\nthe verifier's efficiency is certified separately through `Verifier.ImplementedBy` and the machine\npredicates of `PCP/Complexity/Machine.lean`. ", + "end_line": 167, + "is_class": false, + "kind": "theorem", + "line": 160, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CanonicalRandomness.eq_closedForm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.randomness = fun n => a * Nat.clog 2 (n + 2) + b", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "Eq", + "PCP.Verifier.randomness", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 249, + "is_class": false, + "kind": "theorem", + "line": 234, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier_translate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ) (x a : ι → ZMod 2),\n PCP.Algebraic.BLR.fourier (fun y => f (x + y)) a = PCP.Algebraic.BLR.fourier f a * PCP.Algebraic.BLR.character a x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.fourier", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 157, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CanonicalRandomness.logRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.LogRandomness a b", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.LogRandomness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Claim 3.2: evaluating the encoding at the power point recovers `P(x)`. ", + "end_line": 107, + "is_class": false, + "kind": "theorem", + "line": 100, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c →\n ∀ (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n ((PCP.Algebraic.SetMultilinear.encode m c) P) =\n Polynomial.eval x P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "LinearMap", + "RingHom.id", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Some Walsh coefficient bounds the third moment whenever the energy is one. ", + "end_line": 298, + "is_class": false, + "kind": "theorem", + "line": 284, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.exists_coefficient_ge_cubic", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ),\n (PCP.Algebraic.BLR.average fun x => f x ^ 2) = 1 →\n ∃ a, ∑ b, PCP.Algebraic.BLR.fourier f b ^ 3 ≤ PCP.Algebraic.BLR.fourier f a", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "Rat.instOfNat", + "Exists", + "LE.le", + "Rat.instLE", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "PCP.Algebraic.BLR.fourier" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d addr : ℕ} {onFalse onTrue : PCP.QueryTree d} {addr_1 : ℕ} {onFalse_1 onTrue_1 : PCP.QueryTree d},\n PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1 →\n addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 37, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ}, 1 ≤ r → Function.Injective (PCP.Algebraic.Hadamard.encode r)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Fin", + "ZMod", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.brecOn.eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {motive : (a : ℕ) → PCP.QueryTree a → Sort u} {a : ℕ} (t : PCP.QueryTree a)\n (F_1 : (a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t),\n PCP.QueryTree.brecOn t F_1 = F_1 a t (PCP.QueryTree.brecOn.go t F_1).2", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "Eq", + "PCP.QueryTree.brecOn", + "PProd", + "PCP.QueryTree.brecOn.go" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H =\n PCP.Algebraic.relativeDistance (PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ f H) fun x => true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Eq", + "Rat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample", + "instDecidableEqBool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 258, + "is_class": false, + "kind": "theorem", + "line": 251, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.autocorrelation", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ) (x : ι → ZMod 2),\n (PCP.Algebraic.BLR.average fun y => f y * f (x + y)) =\n ∑ a, PCP.Algebraic.BLR.fourier f a ^ 2 * PCP.Algebraic.BLR.character a x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} {a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.validCert a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {randomness : ℕ → ℕ} {queries : ℕ} {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries}\n {randomness_1 : ℕ → ℕ} {queries_1 : ℕ}\n {run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1},\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 } →\n randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "And", + "HEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Small actual rejection implies ordinary three-colorability, with every\npolynomial and proximity bound constructed from the four low-degree checks. ", + "end_line": 112, + "is_class": false, + "kind": "theorem", + "line": 56, + "module": "PCP.Algebraic.ThreeColorVerifierSoundness", + "name": "PCP.Algebraic.ThreeColorVerifier.colorable_of_rejection_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] {n m c t : ℕ} [NeZero m]\n [CharP F 2],\n 1 ≤ c →\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n 100 * (c * m ^ c) * H.card ≤ Fintype.card F →\n (H.card - 1) * n ≤ c * m ^ c →\n ∀ (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π <\n PCP.Algebraic.ThreeColorSoundnessBudget.gap c →\n G.Colorable 3", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "Finset.card", + "HSub.hSub", + "instHSub", + "instSubNat", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "LT.lt", + "Rat", + "Rat.instLT", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.ThreeColorSoundnessBudget.gap", + "SimpleGraph.Colorable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 113, + "is_class": false, + "kind": "theorem", + "line": 111, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.rejectionProbability_addHom", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] [inst_1 : AddZeroClass V] (L : V →+ ZMod 2),\n PCP.Algebraic.BLR.rejectionProbability ⇑L = 0", + "type_dependencies": [ + "Fintype", + "AddZeroClass", + "AddMonoidHom", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddMonoidWithOne.toAddMonoid", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Eq", + "Rat", + "PCP.Algebraic.BLR.rejectionProbability", + "AddZero.toAdd", + "DFunLike.coe", + "AddMonoidHom.instFunLike", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Homogeneous linear forms, parametrized by their `t` binary coefficients. ", + "end_line": 139, + "is_class": false, + "kind": "definition", + "line": 136, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t : ℕ} → (Fin t → ZMod 2) → (Fin t → ZMod 2) →ₗ[ZMod 2] ZMod 2", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Finset.sum", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.addCommMonoid", + "Finset.univ", + "Fin.fintype", + "HSMul.hSMul", + "Pi.module", + "instHSMul", + "LinearMap.instSMul", + "NonUnitalNonAssocSemiring.toDistribSMul", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "ZMod.commRing", + "PCP.Algebraic.Hadamard.linearEncode._proof_1", + "LinearMap.proj" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eq_interpolation", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v =\n PCP.Algebraic.LagrangeConstraint.check (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) f u v 0", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "PCP.Algebraic.LagrangeConstraint.check", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → [SizeOf F] → PCP.Algebraic.ThreeColorVerifier.Query F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.rec", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "SizeOf.sizeOf", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (6 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 106, + "is_class": false, + "kind": "theorem", + "line": 92, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.distance_sample_origin", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] {A : Type u_3} [inst_5 : DecidableEq A]\n (k l : (σ → F) → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k s.1 s.2.2.1.2) fun s => l s.1 s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v = f u - PCP.Algebraic.GeneratorLowDegreeTest.correct c ζ f u v", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.GeneratorLowDegreeTest.correct" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 202, + "is_class": false, + "kind": "theorem", + "line": 200, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.colorable_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} (relation : C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool)\n (scope : C → Fin k → V),\n (PCP.Reduction.FiniteBooleanConstraints.graph relation scope).Colorable 3 ↔\n ∃ a, PCP.Reduction.FiniteBooleanConstraints.LocalHolds relation scope a", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "Iff", + "SimpleGraph.Colorable", + "PCP.Reduction.NAEThreeColor.Vertex", + "Sum", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "Prod", + "PCP.Reduction.FiniteBooleanConstraints.graph", + "OfNat.ofNat", + "instOfNatNat", + "Exists", + "PCP.Reduction.FiniteBooleanConstraints.LocalHolds" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "definition", + "line": 131, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : Type u_1) (motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u_2) (a : Bool)\n (h_1 : (a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a))\n (h_2 : (a : V) → (a_1 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)),\n (match PCP.Reduction.NAEThreeColor.Literal.const a with\n | PCP.Reduction.NAEThreeColor.Literal.const a => h_1 a\n | PCP.Reduction.NAEThreeColor.Literal.var a a_1 => h_2 a a_1) =\n h_1 a", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Eq", + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Exact satisfiability preservation, including repeated scopes and arity zero. ", + "end_line": 194, + "is_class": false, + "kind": "theorem", + "line": 186, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.satisfiable_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} (relation : C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool)\n (scope : C → Fin k → V),\n (∃ a, PCP.Reduction.ThreeSATToColor.Satisfies (PCP.Reduction.FiniteBooleanConstraints.clauses relation scope) a) ↔\n ∃ a, PCP.Reduction.FiniteBooleanConstraints.LocalHolds relation scope a", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "Iff", + "Exists", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.ThreeSATToColor.Satisfies", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.clauses", + "PCP.Reduction.FiniteBooleanConstraints.LocalHolds" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 34, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.eval_negate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_3} (a : W → Bool) (l : PCP.Reduction.NAEThreeColor.Literal W),\n PCP.Reduction.NAEThreeColor.Literal.eval a (PCP.Reduction.FiniteBooleanConstraints.negate l) =\n !PCP.Reduction.NAEThreeColor.Literal.eval a l", + "type_dependencies": [ + "Bool", + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "PCP.Reduction.FiniteBooleanConstraints.negate", + "Bool.not" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 45, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.properLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.queries c ζ u v =\n u :: List.ofFn fun i => PCP.Algebraic.PolynomialLine.point u v (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i)", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "List", + "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "List.cons", + "List.ofFn", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t →\n {F' : Type u_2} → {n' m' c' t' : ℕ} → PCP.Algebraic.ThreeColorVerifier.Query F' n' m' c' t' → Sort u", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "dite", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Nat.decEq", + "PCP.Algebraic.ThreeColorVerifier.Query.color.elim", + "HEq", + "Not", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.difference.elim", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert.elim", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine.elim" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate_nodes._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.LagrangeConstraint.check (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) f u v 0 =\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.LagrangeConstraint.check", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.eq_def", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 : PCP.ProofOracle),\n x_1.eval x_2 =\n match x, x_1, x_2 with\n | x, PCP.QueryTree.leaf b, x_3 => b\n | .(d + 1), PCP.QueryTree.query a f t, π => if π a = true then t.eval π else f.eval π", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Eq", + "Bool", + "PCP.QueryTree.eval", + "PCP.QueryTree.eval.match_1", + "ite", + "Bool.true", + "instDecidableEqBool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.correctedAt.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (ζ : F) (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (parameter : Fˣ → F) (s : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H parameter s =\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H s.1)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c (parameter s.2.1)) s.2.2.1.1 s.2.2.1.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual correction error averaged over every seed, for an arbitrary chosen inner table. ", + "end_line": 232, + "is_class": false, + "kind": "theorem", + "line": 206, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.correction_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (Q :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F),\n (∀ (uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ), (Q uv).totalDegree ≤ c) →\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H) fun s =>\n (PCP.Algebraic.Hadamard.linearEncode\n (ρ (Polynomial.eval s.2.1 ((PCP.Algebraic.SetMultilinear.decode m c) (Q s.1)))))\n s.2.2.1.2) ≤\n ↑(c + 1) *\n Finset.univ.expect fun uv =>\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ (H uv) fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) (Q uv))))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "ZMod.decidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "Fin.fintype", + "instDecidableEqProd", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "PCP.Algebraic.Hadamard.encode", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.expect_sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (k : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → ℚ),\n (Finset.univ.expect fun s => k s) =\n Finset.univ.expect fun b =>\n Finset.univ.expect fun z => Finset.univ.expect fun vw => Finset.univ.expect fun s => k (b, z, vw, s)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} {a_2 : PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3},\n PCP.Algebraic.ThreeColorVerifier.Query.color a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.color a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeAnswer.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((a : ℕ) → motive (Sum.inr a)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "constructor", + "line": 128, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The noncentral weights sum to one, so with `η₀ = -1` and `0^0 = 1` the weighted sum of the\nconstant monomial vanishes. The forward direction of Fact 2.7 is proved through uniqueness of\nLagrange interpolation instead and does not use this identity; it is retained for\n`PCP/Audit/GeneratorLowDegree.lean`. ", + "end_line": 109, + "is_class": false, + "kind": "theorem", + "line": 103, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.sum_weights", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) → ∑ i, PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i = 1", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "Finset.sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Semiring.toAddCommMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Finset.univ", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (f : α → ℚ), PCP.Algebraic.BLR.average f = (∑ x, f x) / ↑(Fintype.card α)", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Only the first `N` proof bits matter when `V.ReadsBelow x N`. ", + "end_line": 128, + "is_class": false, + "kind": "theorem", + "line": 121, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_congr_of_readsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) {N : ℕ},\n V.ReadsBelow x N → ∀ {π π' : PCP.ProofOracle}, (∀ a < N, π a = π' a) → V.accProb x π = V.accProb x π'", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Nat", + "PCP.Verifier.ReadsBelow", + "PCP.ProofOracle", + "LT.lt", + "instLTNat", + "Eq", + "Rat", + "PCP.Verifier.accProb" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "SMulCommClass (ZMod 2) (ZMod 2) (ZMod 2)", + "type_dependencies": [ + "SMulCommClass", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Algebra.toSMul", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Algebra.id", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.fraction_shared_snd", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (E : W × S → Prop),\n (PCP.Algebraic.AffineLineSampling.fraction fun s => E (s.1, s.2.2)) = PCP.Algebraic.AffineLineSampling.fraction E", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.AffineLineSampling.fraction", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ),\n PCP.Algebraic.SetMultilinear.decode m c =\n MvPolynomial.eval₂Hom Polynomial.C fun ij => Polynomial.X ^ (↑ij.2 * m ^ ↑ij.1)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "Eq", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "PCP.Algebraic.SetMultilinear.decode", + "MvPolynomial.eval₂Hom", + "Polynomial.commSemiring", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.X", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "definition", + "line": 133, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 6 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 226, + "is_class": false, + "kind": "theorem", + "line": 222, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_differenceQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.differenceQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.difference π.differenceLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A bound linear in the inner degree and primary Hadamard degree. ", + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 71, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries hr ρ nodes ζ s).length ≤ 2 * r + 2 * c + 12", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm_comm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2),\n (PCP.Algebraic.BLR.linearForm a) x = (PCP.Algebraic.BLR.linearForm x) a", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "recursor", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → (t : PCP.Machine.Sym) → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 156, + "is_class": false, + "kind": "theorem", + "line": 155, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character_sq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2), PCP.Algebraic.BLR.character a x ^ 2 = 1", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.character", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.honestProof._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_comm._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),\n ∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a", + "type_dependencies": [ + "DivisionSemiring", + "Finset", + "Eq", + "Finset.sum", + "Semiring.toAddCommMonoid", + "DivisionSemiring.toSemiring", + "HDiv.hDiv", + "instHDiv", + "DivInvMonoid.toDiv", + "GroupWithZero.toDivInvMonoid", + "DivisionSemiring.toGroupWithZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "definition", + "line": 127, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.difference a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (a b : σ → F) (z : Fˣ)\n (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ a b z v w s =\n Sum.inl\n (PCP.Algebraic.PolynomialLine.point a b ↑z,\n (PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.BinaryLocalCorrection.run._proof_2) w) ::\n (List.map (fun p => Sum.inr (b, p))\n (PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.BinaryLocalCorrection.run._proof_2 ρ nodes s) ++\n List.map (fun p => Sum.inr (b, p))\n (PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c ↑z) v w) ++\n List.map (fun p => Sum.inr (b, p))\n (PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c 0) v w))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Eq", + "List", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "List.cons", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "Units.val", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "HAppend.hAppend", + "Sum", + "PCP.Algebraic.SetMultilinear.Variables", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) (a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.difference a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (color : PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t)\n (validLines differenceLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t)\n (properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t),\n sizeOf\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines } =\n 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.1's constant total-degree bound. ", + "end_line": 151, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.totalDegree_encode_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n ((PCP.Algebraic.SetMultilinear.encode m c) P).totalDegree ≤ c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each branch has its genuine finite uniform sample space. ", + "end_line": 395, + "is_class": false, + "kind": "definition", + "line": 391, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t : ℕ} →\n [Fintype F] → [DecidableEq F] → (i : Fin 7) → Fintype (PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Fin.cases", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "id", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_1", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.ThreeColorVerifier.instFintypeSampleOfDecidableEq", + "Fin.fintype", + "instDecidableEqFin", + "Fin.succ", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_2", + "Sum", + "instFintypeSum", + "instDecidableEqSum", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_3", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_4", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "PCP.Algebraic.ThreeColorVerifier.instFintypeTestSample", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "ZMod", + "instFintypeProd", + "Pi.instFintype", + "ZMod.fintype", + "Fin.elim0" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n PCP.NPCertificate P L →\n {P' : (List Bool → List Bool → Bool) → Prop} → {L' : PCP.Language} → PCP.NPCertificate P' L' → Sort u", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "PCP.NPCertificate.casesOn", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 155, + "is_class": false, + "kind": "theorem", + "line": 153, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.totalDegree_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c → P ≠ 0 → ((PCP.Algebraic.SetMultilinear.encode m c) P).totalDegree = c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Polynomial.instZero", + "Eq", + "MvPolynomial.totalDegree", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym → ℕ", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.Sym.casesOn", + "Nat", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Recovery proves injectivity on the bounded-degree domain, even over finite fields. ", + "end_line": 121, + "is_class": false, + "kind": "theorem", + "line": 115, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_injective_on", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n Set.InjOn ⇑(PCP.Algebraic.SetMultilinear.encode m c) {P | P.natDegree < m ^ c}", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Set.InjOn", + "Polynomial", + "CommSemiring.toSemiring", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Set.ofPred", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n [Fintype F] → [Fintype σ] → [DecidableEq σ] → Fintype (PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "instFintypeProd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The verifier performs every listed branch, so its complete list concatenates all seven. ", + "end_line": 207, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Sample F n m c t →\n List (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "List.flatten", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List.ofFn", + "List", + "PCP.Algebraic.ThreeColorVerifier.branchQueries" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The reverse inclusion follows by guessing the bounded proof prefix and\nchecking all logarithmically many random bits. The concrete machine model\nsatisfies the cost-model closure properties in `PCP.Complexity.StandardModel`. ", + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Theorem", + "name": "PCP.pcp_subset_np", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : PCP.CostModel) (L : PCP.Language) (V : PCP.Verifier) (a b : ℕ) (p : Polynomial ℕ),\n M.Efficient V →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n (∀ (x : List Bool), L x → V.CompleteAt x) →\n (∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)) → PCP.InNP M.PolyTimeRel L", + "type_dependencies": [ + "PCP.CostModel", + "PCP.Language", + "PCP.Verifier", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.CostModel.Efficient", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.InNP", + "PCP.CostModel.PolyTimeRel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 429, + "is_class": false, + "kind": "theorem", + "line": 425, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 0 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.color π.colorLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Fin.fintype", + "instDecidableEqFin", + "Decidable.byContradiction", + "LE.le", + "instLENat", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a : Bool), PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit a", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The real-valued sign of a binary value, kept in `ℚ`. ", + "end_line": 22, + "is_class": false, + "kind": "definition", + "line": 21, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign", + "provenance": "lean", + "structural_dependencies": [], + "type": "ZMod 2 → ℚ", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "ite", + "Rat", + "Eq", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "ZMod.decidableEq", + "Rat.instOfNat", + "Neg.neg", + "Rat.instNeg" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 146, + "is_class": false, + "kind": "theorem", + "line": 145, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character_comm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2),\n PCP.Algebraic.BLR.character a x = PCP.Algebraic.BLR.character x a", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.eq_def", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x),\n x_1.addresses =\n match x, x_1 with\n | x, PCP.QueryTree.leaf accept => ∅\n | .(d + 1), PCP.QueryTree.query a f t => insert a (f.addresses ∪ t.addresses)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "Finset", + "PCP.QueryTree.addresses", + "PCP.QueryTree.addresses.match_1", + "Bool", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "definition", + "line": 127, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 2 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.difference" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Lemma 2.9: a bounded family of multiples of the coordinate vanishing polynomials. ", + "end_line": 148, + "is_class": false, + "kind": "theorem", + "line": 133, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_decomposition", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] [inst_3 : Fintype σ] (H : Finset R)\n (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p ↔\n ∃ Q,\n (∀ (i : σ), (Q i).totalDegree ≤ p.totalDegree - H.card) ∧\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Fintype", + "Finset", + "MvPolynomial", + "Iff", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Exists", + "And", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.validCert a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 123, + "is_class": false, + "kind": "theorem", + "line": 113, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.eval_zero_eq_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} {a : Fin (c + 1) → F},\n Function.Injective a →\n ∀ (P : Polynomial F),\n P.natDegree ≤ c →\n Polynomial.eval 0 P = ∑ i, PCP.Algebraic.LagrangeConstraint.weight a 0 i * Polynomial.eval (a i) P", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "Polynomial.eval", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "PCP.Algebraic.LagrangeConstraint.weight" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 166, + "is_class": false, + "kind": "definition", + "line": 163, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1 →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.properQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p m₀ mZ : Option (ZMod 2)),\n (∀ (p_1 m₀_1 mZ_1 : ZMod 2), p = some p_1 → m₀ = some m₀_1 → mZ = some mZ_1 → False) →\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck p m₀ mZ = none", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Option.some", + "False", + "Prod", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.ClauseHolds._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (2 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (x : ℕ) (accept : Bool)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match x, PCP.QueryTree.leaf accept with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_1 x accept", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.addresses.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ), ¬n ≤ c + 1 → ¬c + 1 + (n - (c + 1)) = n → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 85, + "is_class": false, + "kind": "definition", + "line": 85, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {randomness : ℕ → ℕ} →\n {queries : ℕ} →\n {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries} →\n {randomness' : ℕ → ℕ} →\n {queries' : ℕ} →\n {run' : (x : List Bool) → Fin (2 ^ randomness' x.length) → PCP.QueryTree queries'} →\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness', queries := queries', run := run' } →\n (randomness = randomness' → queries = queries' → run ≍ run' → P) → P", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "HEq" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "HEq", + "id", + "PCP.Verifier.noConfusion" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testRejectionRate._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1) →\n ((x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin n ⊕ Fin n)) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [], + "doc": "Three gate clauses per comparison, plus the initial and final unit clauses. ", + "end_line": 73, + "is_class": false, + "kind": "definition", + "line": 72, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.Clause", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_4 → ℕ → Type (max u_4 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 138, + "is_class": false, + "kind": "theorem", + "line": 125, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.polynomial_predict", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} {a : Fin (c + 1) → F},\n Function.Injective a →\n ∀ (P : Polynomial F),\n P.natDegree ≤ c →\n ∀ (u v : F),\n Polynomial.eval u P =\n PCP.Algebraic.WeightedConstraint.predict a (PCP.Algebraic.LagrangeConstraint.weight a 0)\n (fun x => Polynomial.eval x P) u v", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "Polynomial.eval", + "PCP.Algebraic.WeightedConstraint.predict", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.LagrangeConstraint.weight", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "definition", + "line": 79, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R} →\n {polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)} →\n {PolyTimeRel' : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg' : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable' : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel' R → Computable₂ R} →\n {polyTimeAlg_computable' :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg' alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck' :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg' alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel' (PCP.finiteWitnessCheck V)} →\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel', PolyTimeAlg := PolyTimeAlg',\n polyTimeRel_computable := polyTimeRel_computable',\n polyTimeAlg_computable := polyTimeAlg_computable',\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck' } →\n (PolyTimeRel = PolyTimeRel' → PolyTimeAlg = PolyTimeAlg' → P) → P", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk", + "id", + "PCP.CostModel.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Vanishing at every point of the Cartesian grid, including zero-dimensional grids. ", + "end_line": 31, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.VanishesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → Finset R → MvPolynomial σ R → Prop", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring" + ], + "value_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.test.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H H_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n H = H_1 →\n ∀ (s s_1 : PCP.Algebraic.Hadamard.TestRandomness t r),\n s = s_1 → PCP.Algebraic.Hadamard.test hr H s = PCP.Algebraic.Hadamard.test hr H_1 s_1", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Eq", + "PCP.Algebraic.Hadamard.TestRandomness", + "Bool", + "PCP.Algebraic.Hadamard.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.colorQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3) →\n ((x : Fin n → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin n)) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 107, + "is_class": false, + "kind": "theorem", + "line": 106, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), 0 ≤ V.accProb x π", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Verifier.accProb" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 223, + "is_class": false, + "kind": "theorem", + "line": 214, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_boundedEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c →\n ∀ (P : ↥(Polynomial.degreeLE R ↑d)) (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n ((PCP.Algebraic.SetMultilinear.boundedEncode m c d) P) =\n Polynomial.eval x ↑P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "LinearMap", + "RingHom.id", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.boundedEncode", + "Polynomial.eval", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a b : σ → F) (z : Fˣ)\n (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ f H a b z v w s =\n if\n PCP.Algebraic.BinaryLowDegreeTest.test PCP.Algebraic.BinaryLocalCorrection.run._proof_2 ρ nodes (H b) s =\n true then\n if\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H b)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c ↑z) v w =\n f (PCP.Algebraic.PolynomialLine.point a b ↑z)\n ((PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.BinaryLocalCorrection.run._proof_2) w) then\n some\n (PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H b)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c 0) v w)\n else none\n else none", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.run", + "ite", + "Bool", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "Bool.true", + "instDecidableEqBool", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq", + "Option.some", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every coloring has a low-degree extension satisfying both grid constraints. ", + "end_line": 132, + "is_class": false, + "kind": "theorem", + "line": 116, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_constraints", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F) (G : SimpleGraph (σ → ↥H)),\n G.Colorable 3 ↔\n ∃ P,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) ∧\n PCP.Algebraic.GridVanishing.VanishesOn H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P))", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Fintype.card", + "PCP.Algebraic.GridVanishing.VanishesOn", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "Sum", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 94, + "is_class": false, + "kind": "definition", + "line": 93, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`V` is efficiently implementable in the model `M`. ", + "end_line": 115, + "is_class": false, + "kind": "definition", + "line": 114, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.Efficient", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → PCP.Verifier → Prop", + "type_dependencies": [ + "PCP.CostModel", + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.CostModel", + "PCP.Verifier", + "Exists", + "PCP.VerifierAlg", + "And", + "PCP.CostModel.PolyTimeAlg", + "PCP.Verifier.ImplementedBy" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 57, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] (H : Finset R) (i : σ),\n PCP.Algebraic.GridVanishing.coordinate H i ≠ 0", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finset", + "Ne", + "MvPolynomial", + "PCP.Algebraic.GridVanishing.coordinate", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "definition", + "line": 131, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 5 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Rejection probability of the binary three-query linearity test. ", + "end_line": 109, + "is_class": false, + "kind": "definition", + "line": 107, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.rejectionProbability", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → [Fintype V] → [Add V] → (V → ZMod 2) → ℚ", + "type_dependencies": [ + "Fintype", + "Add", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "Add", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "ZMod.decidableEq", + "HAdd.hAdd", + "instHAdd", + "Prod.fst", + "Prod.snd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 154, + "is_class": false, + "kind": "theorem", + "line": 152, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.test_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (x : Fin t → ZMod 2) (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n PCP.Algebraic.Hadamard.test hr (⇑(PCP.Algebraic.Hadamard.encode r x)) s = true", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness", + "Eq", + "Bool", + "PCP.Algebraic.Hadamard.test", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "definition", + "line": 133, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual rejection of the concrete procedure, including either failed check. ", + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n [Fintype σ] →\n [DecidableEq σ] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) → (σ → F) → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.AffineLineSampling.fraction", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_2", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.none" + ] + }, + { + "axioms": [], + "doc": "Negation preserves the source variable and flips its literal sign. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.negate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{W : Type u_3} → PCP.Reduction.NAEThreeColor.Literal W → PCP.Reduction.NAEThreeColor.Literal W", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.negate.match_1", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "Bool.not", + "PCP.Reduction.NAEThreeColor.Literal.var" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 77, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_digitMonomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ) (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n (PCP.Algebraic.SetMultilinear.digitMonomial m c k) =\n x ^ (k % m ^ c)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "HMod.hMod", + "instHMod", + "Nat.instMod", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 379, + "is_class": false, + "kind": "definition", + "line": 378, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeSampleOfDecidableEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t : ℕ} →\n [Fintype F] →\n {σ : Type u_2} →\n [Fintype σ] → [DecidableEq σ] → {r : ℕ} → Fintype (PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "instFintypeProd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.instFintypeProdTestRandomnessInnerSeed" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_ne_zero._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)", + "type_dependencies": [ + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (f : List Bool → Bool ⊕ ℕ) (as : List Bool),\n PCP.QueryTree.ofStep f 0 as =\n match f as with\n | Sum.inl b => PCP.QueryTree.leaf b\n | Sum.inr val => PCP.QueryTree.leaf false", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Eq", + "PCP.QueryTree", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.ofStep", + "PCP.QueryTree.ofStep.match_1", + "PCP.QueryTree.leaf", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness only needs the decoded difference identity and the two grid equations;\nit imposes no interpolation-degree restriction on the decoded coloring. ", + "end_line": 171, + "is_class": false, + "kind": "theorem", + "line": 162, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_of_vanishing", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F) (G : SimpleGraph (σ → ↥H)) (P : MvPolynomial σ F) (Q : MvPolynomial (σ ⊕ σ) F),\n Q = PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P →\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) →\n PCP.Algebraic.GridVanishing.VanishesOn H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G) Q) →\n G.Colorable 3", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.GridVanishing.VanishesOn", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "SimpleGraph.Colorable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Observation 3.8: concatenation halves the relative distance of two functions. ", + "end_line": 116, + "is_class": false, + "kind": "theorem", + "line": 110, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encodeFunction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} {ι : Type u_1} [inst : Fintype ι],\n 1 ≤ r →\n ∀ (f g : ι → Fin t → ZMod 2),\n PCP.Algebraic.relativeDistance (PCP.Algebraic.Hadamard.encodeFunction r f)\n (PCP.Algebraic.Hadamard.encodeFunction r g) =\n 1 / 2 * PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.Hadamard.encodeFunction", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Fintype.decidablePiFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk", + "PCP.Verifier.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "theorem", + "line": 34, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_constant", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (x : Fin t → ZMod 2) (a : ZMod 2),\n (PCP.Algebraic.Hadamard.encode r x) (PCP.Algebraic.BinaryPolynomialSpace.constant a) = a", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.constant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", + "type_dependencies": [ + "Fintype", + "Eq", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.univ", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.chain_eq_flag._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {k : ℕ} (j : ℕ), j + 1 < k + 1 → ¬j < k + 1 → False", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGrid.optionCheck._sparseCasesOn_1.else_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))\n («else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck._sparseCasesOn_1 t some «else» = «else» h", + "type_dependencies": [ + "Option", + "Option.some", + "Nat.hasNotBit", + "Option.ctorIdx", + "Eq", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck._sparseCasesOn_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A colorable grid graph supplies an actual eight-table proof accepted on every seed. ", + "end_line": 124, + "is_class": false, + "kind": "theorem", + "line": 100, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n G.Colorable 3 →\n 5 * ((H.card - 1) * n) < m ^ c →\n ∃ π,\n ∀ (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s = true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "SimpleGraph.Colorable", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Exists", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Degree-zero queries see only constants, so they cannot distinguish messages. ", + "end_line": 49, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_degree_zero_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x y : Fin t → ZMod 2), PCP.Algebraic.Hadamard.encode 0 x = PCP.Algebraic.Hadamard.encode 0 y", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : Type u_1) →\n (motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u_2) →\n (x : PCP.Reduction.NAEThreeColor.Literal V) →\n ((a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a)) →\n ((a : V) → (a_1 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)) → motive x", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] {inst_2 : DecidableEq F} [inst_3 : DecidableEq F]\n [inst_4 : Fintype σ] {inst_5 : DecidableEq σ} [inst_6 : DecidableEq σ] (c c_1 : ℕ),\n c = c_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (f f_1 : (σ → F) → F),\n f = f_1 →\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f =\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c_1 ζ_1 f_1", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 231, + "is_class": false, + "kind": "theorem", + "line": 225, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c → Function.Injective ⇑(PCP.Algebraic.SetMultilinear.boundedEncode m c d)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Function.Injective", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.boundedEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The `k+2` iteration's degree-`k+1` query in the full domain. ", + "end_line": 50, + "is_class": false, + "kind": "definition", + "line": 48, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.factorQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} →\n PCP.Algebraic.Hadamard.TestRandomness t r → Fin (r - 1) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "DFunLike.coe", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.embed", + "PCP.Algebraic.Hadamard.TestRandomness.factorDegree_le", + "PCP.Algebraic.Hadamard.TestRandomness.factor" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {F : Type u_2} →\n {n m c t : ℕ} →\n {t_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t} →\n {F' : Type u_2} →\n {n' m' c' t' : ℕ} →\n {t'_1 : PCP.Algebraic.ThreeColorVerifier.Proof F' n' m' c' t'} →\n F = F' →\n n = n' →\n m = m' →\n c = c' → t = t' → t_1 ≍ t'_1 → PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType P t_1 t'_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "HEq", + "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType", + "PCP.Algebraic.ThreeColorVerifier.Proof.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HEq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 44, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.smallError_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), PCP.Algebraic.GeneratorLowDegreeTest.smallError c < 1 / (2 * (↑c + 2) ^ 2)", + "type_dependencies": [ + "Nat", + "LT.lt", + "Rat", + "Rat.instLT", + "PCP.Algebraic.GeneratorLowDegreeTest.smallError", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 302, + "is_class": false, + "kind": "definition", + "line": 301, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → {c : ℕ} → (Fin (c + 1) → F) → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.LagrangeConstraint.check", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The auxiliary oracle explicitly uses degree-one Hadamard labels. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → Type (max u_4 u_3)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 126, + "is_class": false, + "kind": "definition", + "line": 126, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 1 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "theorem", + "line": 31, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.expect_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {U : Type u_5} {V : Type u_6} [inst : Fintype U] [inst_1 : Fintype V] (f : U × V → ℚ),\n (Finset.univ.expect fun uv => f uv) = Finset.univ.expect fun u => Finset.univ.expect fun v => f (u, v)", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.expect_shared_snd", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (f : W × S → ℚ),\n (Finset.univ.expect fun s => f (s.1, s.2.2)) = Finset.univ.expect fun s => f s", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An explicit rejection lower bound, with a provably positive denominator. ", + "end_line": 325, + "is_class": false, + "kind": "theorem", + "line": 300, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ p' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) ≤\n δP →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δM →\n ((1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 - δP - 2 * δM -\n ↑D / ↑(Fintype.card F - 1)) /\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) ≤\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p' M' A", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "Fin.fintype", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instFintypeSum", + "instDecidableEqSum", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Rat.instMul", + "instSubNat", + "Rat.instAdd", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The decision depends only on the stated finite query list. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 86, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)\n (f g : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H K : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n (∀ p ∈ PCP.Algebraic.EncodedLineLowDegreeTest.queries hr ρ nodes ζ s,\n PCP.Algebraic.EncodedLineLowDegreeTest.read f H p = PCP.Algebraic.EncodedLineLowDegreeTest.read g K p) →\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ f H s =\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ g K s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every basis image is homogeneous of degree `c`, including the image of `1`. ", + "end_line": 138, + "is_class": false, + "kind": "theorem", + "line": 132, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial_isHomogeneous", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n (PCP.Algebraic.SetMultilinear.digitMonomial m c k).IsHomogeneous c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "MvPolynomial.IsHomogeneous", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 40, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_sq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a : ZMod 2), PCP.Algebraic.BLR.sign a ^ 2 = 1", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.sign", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (x : Fin (n + n) → F),\n (PCP.Algebraic.HadamardDerivedOracle.weightedCubic (PCP.Algebraic.ThreeColorVerifier.edgeValue H G x)).natDegree ≤ 3", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "constructor", + "line": 135, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A homogeneous binary linear form indexed by its coefficients. ", + "end_line": 130, + "is_class": false, + "kind": "definition", + "line": 128, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm", + "provenance": "lean", + "structural_dependencies": [], + "type": "{ι : Type u_1} → [Fintype ι] → (ι → ZMod 2) → (ι → ZMod 2) →ₗ[ZMod 2] ZMod 2", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Finset.sum", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.addCommMonoid", + "Finset.univ", + "HSMul.hSMul", + "Pi.module", + "instHSMul", + "LinearMap.instSMul", + "NonUnitalNonAssocSemiring.toDistribSMul", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "ZMod.commRing", + "PCP.Algebraic.BLR.linearForm._proof_1", + "LinearMap.proj" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r),\n PCP.Algebraic.Hadamard.homogeneousIndex hr =\n ∑ i, (LinearMap.proj i).smulRight (PCP.Algebraic.BinaryPolynomialSpace.variableCoeff hr i)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Finset.sum", + "LinearMap.addCommMonoid", + "Finset.univ", + "Fin.fintype", + "LinearMap.smulRight", + "PCP.Algebraic.Hadamard.homogeneousIndex._proof_1", + "LinearMap.proj", + "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Primary Hadamard rejection is a marginal of the actual conjunction tester. ", + "end_line": 111, + "is_class": false, + "kind": "theorem", + "line": 80, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.primary_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n PCP.Algebraic.Hadamard.averageRejectionRate hr f ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.Hadamard.averageRejectionRate", + "Pi.instFintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A physical query is answered by precisely its tagged received table. ", + "end_line": 147, + "is_class": false, + "kind": "definition", + "line": 138, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → PCP.Algebraic.ThreeColorVerifier.Query F n m c t → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Query", + "ZMod", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.read.match_1", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A closed, non-strict rejection threshold convenient for downstream decoding. ", + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.smallError", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 74, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.eval_edgeExtension", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)) (a b : σ → ↥H),\n (MvPolynomial.eval (Sum.elim (fun i => ↑(a i)) fun i => ↑(b i))) (PCP.Algebraic.ThreeColorGrid.edgeExtension H G) =\n if G.Adj a b then 1 else 0", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum.elim", + "Subtype.val", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "ite", + "SimpleGraph.Adj", + "Classical.propDecidable", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (accept : Bool), (PCP.QueryTree.leaf accept).addresses = ∅", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "Finset", + "PCP.QueryTree.addresses", + "PCP.QueryTree.leaf", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) →\n ((color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t) →\n (validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t) →\n (properLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t) →\n motive\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines }) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An unused uniform scalar preserves the fixed-width seed encoding without changing rejection. ", + "end_line": 309, + "is_class": false, + "kind": "definition", + "line": 306, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [Field F] →\n {c : ℕ} → [Fintype F] → [DecidableEq F] → [Fintype σ] → [DecidableEq σ] → (Fin (c + 1) → F) → ((σ → F) → F) → ℚ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.FixedLagrangeConstraint.check", + "Prod.fst", + "Prod.snd", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b b_1 : Bool), (PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1) = (b = b_1)", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A point-oracle query or a query to one auxiliary encoded line. ", + "end_line": 42, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.Query", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → Type (max u_3 u_4)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Sharp BLR soundness: rejection probability bounds distance to a linear form. ", + "end_line": 311, + "is_class": false, + "kind": "theorem", + "line": 305, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.exists_linearForm_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (H : (ι → ZMod 2) → ZMod 2),\n ∃ a, PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.BLR.linearForm a) ≤ PCP.Algebraic.BLR.rejectionProbability H", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Exists", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm", + "PCP.Algebraic.BLR.rejectionProbability", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "definition", + "line": 78, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.differenceLiteral", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {k : ℕ} →\n (C → Fin k → V) →\n C →\n PCP.Reduction.FiniteBooleanConstraints.Pattern k →\n Fin k → PCP.Reduction.NAEThreeColor.Literal (PCP.Reduction.FiniteBooleanConstraints.Variable V C k)", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.Variable" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "Sum.inl", + "PCP.Reduction.FiniteBooleanConstraints.Aux" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The proof oracle determined by a finite witness: address `j` holds `w[j]`, and `false` at every\naddress beyond `w`. Padding with `false` is harmless exactly because a verifier satisfying\n`Verifier.ReadsBelow x N` never looks past address `N`. ", + "end_line": 201, + "is_class": false, + "kind": "definition", + "line": 198, + "module": "PCP.Verifier.Definition", + "name": "PCP.oracleOfWitness", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool → PCP.ProofOracle", + "type_dependencies": [ + "List", + "Bool", + "PCP.ProofOracle" + ], + "value_dependencies": [ + "List", + "Bool", + "Nat", + "List.getD", + "Bool.false" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The precise block condition in Definition 3.1, stronger than a total-degree bound. ", + "end_line": 190, + "is_class": false, + "kind": "theorem", + "line": 184, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_isSetMultilinear", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n PCP.Algebraic.SetMultilinear.IsSetMultilinear m c ((PCP.Algebraic.SetMultilinear.encode m c) P)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.SetMultilinear.IsSetMultilinear", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval_congr.match_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀\n (motive :\n (x : ℕ) → (x_1 : PCP.QueryTree x) → (x_2 x_3 : PCP.ProofOracle) → (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → Prop)\n (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 x_3 : PCP.ProofOracle) (x_4 : ∀ a ∈ x_1.addresses, x_2 a = x_3 a),\n (∀ (x : ℕ) (accept : Bool) (x_5 x_6 : PCP.ProofOracle)\n (x_7 : ∀ a ∈ (PCP.QueryTree.leaf accept).addresses, x_5 a = x_6 a),\n motive x (PCP.QueryTree.leaf accept) x_5 x_6 x_7) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d) (π π' : PCP.ProofOracle)\n (h : ∀ a_1 ∈ (PCP.QueryTree.query a f t).addresses, π a_1 = π' a_1),\n motive (d + 1) (PCP.QueryTree.query a f t) π π' h) →\n motive x x_1 x_2 x_3 x_4", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One direct bit and two independently seeded optional bits, with a shared label. ", + "end_line": 95, + "is_class": false, + "kind": "definition", + "line": 92, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck", + "provenance": "lean", + "structural_dependencies": [], + "type": "{X : Type u_1} →\n {W : Type u_2} →\n {S : Type u_3} →\n (X → W → ZMod 2) →\n (X → W → S → Option (ZMod 2)) → (X → W → S → Option (ZMod 2)) → X × W × S × S → Option (ZMod 2 × ZMod 2)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Prod" + ], + "value_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Prod", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "_private.PCP.Algebraic.BinaryLocalCorrection.0.PCP.Algebraic.BinaryLocalCorrection.read.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t : ℕ} (motive : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → Sort u_3)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl p))\n (h_2 :\n (p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inl p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_1 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.inr", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → (c : ℕ) → F → Fin (c + 1) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.LagrangeConstraint.weight", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The rejection probability for the independent uniform choices in `TestRandomness`. ", + "end_line": 128, + "is_class": false, + "kind": "definition", + "line": 126, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testRejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} → 1 ≤ r → (PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) → ℚ", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Rat" + ], + "value_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.Hadamard.TestRandomness", + "Bool", + "instFintypeProd", + "Prod", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.Hadamard.testRejectionRate._proof_1", + "instDecidableEqBool", + "PCP.Algebraic.Hadamard.test", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 125, + "is_class": false, + "kind": "definition", + "line": 125, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n {a' : PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n PCP.Algebraic.ThreeColorVerifier.Query.color a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.color a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d),\n f.addresses.card < 2 ^ d →\n t.addresses.card < 2 ^ d →\n (insert a (f.addresses ∪ t.addresses)).card ≤ 1 + (f.addresses.card + t.addresses.card) →\n ¬(insert a (f.addresses ∪ t.addresses)).card < 2 ^ (d + 1) → False", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "Insert.insert", + "Finset", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encode._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b ≠ 0) = (a ≠ b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "Ne", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "_private.PCP.Algebraic.BinaryLocalCorrection.0.PCP.Algebraic.BinaryLocalCorrection.read.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t : ℕ} (motive : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → Sort u_3)\n (p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl p))\n (h_2 :\n (p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inr p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_2 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (a : Fin (c + 1) → F) (f : (σ → F) → F),\n PCP.Algebraic.FixedLagrangeConstraint.rejectionRate a f =\n PCP.Algebraic.relativeDistance (fun s => PCP.Algebraic.FixedLagrangeConstraint.check a f s.1.1 s.1.2) fun x => 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.FixedLagrangeConstraint.check", + "Prod.fst", + "Prod.snd", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The relation defines `L`. ", + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L) (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length self.witnessBound ∧ self.check x w = true", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Iff", + "Exists", + "And", + "LE.le", + "Nat", + "instLENat", + "List.length", + "Polynomial.eval", + "Nat.instSemiring", + "PCP.NPCertificate.witnessBound", + "Eq", + "PCP.NPCertificate.check", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.eval_zero_eq_sum._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} (P : Polynomial F), P.natDegree ≤ c → ¬P.natDegree < c + 1 → False", + "type_dependencies": [ + "Field", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Not", + "LT.lt", + "instLTNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x : Fin t → ZMod 2), PCP.Algebraic.Hadamard.linearEncode x = ∑ i, x i • LinearMap.proj i", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.linearEncode", + "Finset.sum", + "LinearMap.addCommMonoid", + "Finset.univ", + "Fin.fintype", + "HSMul.hSMul", + "Pi.module", + "instHSMul", + "LinearMap.instSMul", + "NonUnitalNonAssocSemiring.toDistribSMul", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "ZMod.commRing", + "PCP.Algebraic.Hadamard.linearEncode._proof_1", + "LinearMap.proj" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual formal line table extracted from decoded inner polynomials. ", + "end_line": 241, + "is_class": false, + "kind": "definition", + "line": 236, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.decodedTable", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n {m c : ℕ} →\n [NeZero m] →\n (Q :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ →\n MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F) →\n (∀ (uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ), (Q uv).totalDegree ≤ c) →\n PCP.Algebraic.PointLineTest.LineTable F σ (c * m ^ c)", + "type_dependencies": [ + "Field", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.PointLineTest.LineTable", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [ + "Field", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Prod", + "Subtype.mk", + "Polynomial", + "CommSemiring.toSemiring", + "Polynomial.natDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "PCP.Algebraic.EncodedLineLowDegreeTest.decodedTable._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Branch order: color, valid certificate, difference, proper certificate,\nvalid grid, proper grid, difference consistency. ", + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 82, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → Fin 7 → Type u_2", + "type_dependencies": [ + "Monoid", + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Matrix.vecCons", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "ZMod", + "Matrix.vecEmpty" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False", + "type_dependencies": [ + "GroupWithZero", + "Int", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass", + "GroupWithZero.toMonoidWithZero", + "Eq", + "HPow.hPow", + "instHPow", + "ZPow.toPow", + "DivInvMonoid.toZPow", + "GroupWithZero.toDivInvMonoid", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ], + "value_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk", + "PCP.CostModel.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_const", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] [Nonempty α] (c : ℚ), (PCP.Algebraic.BLR.average fun x => c) = c", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3) →\n ((x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin n ⊕ Fin n)) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 115, + "is_class": false, + "kind": "definition", + "line": 114, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.LocalHolds", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {k : ℕ} → (C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool) → (C → Fin k → V) → (V → Bool) → Prop", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "Eq", + "Bool.true" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{a : ℕ} → PCP.QueryTree a → ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.casesOn", + "Bool" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → PCP.Verifier → PCP.Verifier → Sort u", + "type_dependencies": [ + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.Verifier", + "PCP.Verifier.casesOn", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "SizeOf PCP.CostModel", + "type_dependencies": [ + "SizeOf", + "PCP.CostModel" + ], + "value_dependencies": [ + "SizeOf.mk", + "PCP.CostModel", + "PCP.CostModel._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 141, + "is_class": false, + "kind": "theorem", + "line": 117, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.pattern_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} (relation : C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool)\n (scope : C → Fin k → V) (a : PCP.Reduction.FiniteBooleanConstraints.Variable V C k → Bool) (e : C)\n (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k),\n (∀ (j : Fin k × Fin 3 ⊕ Fin 2),\n PCP.Reduction.FiniteBooleanConstraints.ClauseHolds\n (PCP.Reduction.FiniteBooleanConstraints.clauses relation scope (e, p, j)) a) ↔\n a (Sum.inr (e, p, 0)) = false ∧\n (∀ (i : Fin k), a (Sum.inr (e, p, i.succ)) = (a (Sum.inr (e, p, i.castSucc)) || a (Sum.inl (scope e i)) ^^ p i)) ∧\n (relation e p = true ∨ a (Sum.inr (e, p, Fin.last k)) = true)", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "Iff", + "Sum", + "Prod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.FiniteBooleanConstraints.ClauseHolds", + "PCP.Reduction.FiniteBooleanConstraints.clauses", + "Prod.mk", + "And", + "Eq", + "Sum.inr", + "PCP.Reduction.FiniteBooleanConstraints.Aux", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.instOfNat", + "instNeZeroNatHAdd_1", + "Nat.instNeZeroSucc", + "Bool.false", + "Fin.succ", + "Bool.or", + "Fin.castSucc", + "Bool.xor", + "Sum.inl", + "Or", + "Bool.true", + "Fin.last" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.clauses.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{C : Type u_1} →\n {k : ℕ} →\n (motive : PCP.Reduction.FiniteBooleanConstraints.Clause C k → Sort u_2) →\n (x : PCP.Reduction.FiniteBooleanConstraints.Clause C k) →\n ((e : C) →\n (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) →\n (i : Fin k) → (j : Fin 3) → motive (e, p, Sum.inl (i, j))) →\n ((e : C) → (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) → (j : Fin 2) → motive (e, p, Sum.inr j)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Prod.mk", + "Prod", + "Sum", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "PCP.Reduction.FiniteBooleanConstraints.clauses.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 207, + "is_class": false, + "kind": "definition", + "line": 206, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeSampleSumFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [Fintype F] →\n [DecidableEq F] → {n m c t : ℕ} → Fintype (PCP.Algebraic.BinaryLocalCorrection.Sample F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instDecidableEqSum", + "instDecidableEqFin", + "instFintypeSum", + "Fin.fintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "ZMod.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1._proof_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Evaluate public adjacency at the original two vertex blocks. ", + "end_line": 60, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → {n : ℕ} → (H : Finset F) → SimpleGraph (Fin n → ↥H) → (Fin (n + n) → F) → F", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Function.comp", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`V` reads only proof addresses below `N` on input `x`, whatever the randomness and whatever\nthe oracle answers. This is how \"a proof of polynomial length\" is expressed. ", + "end_line": 119, + "is_class": false, + "kind": "definition", + "line": 116, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.ReadsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → ℕ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "LT.lt", + "instLTNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Encoding an ordinary finite graph gives the intended soundness statement. ", + "end_line": 68, + "is_class": false, + "kind": "theorem", + "line": 65, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.soundAt_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (G : SimpleGraph (Fin N)) [inst : DecidableRel G.Adj],\n ¬G.Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.SoundAt (PCP.Algebraic.ThreeColorEncoding.encode G) (1 / 2)", + "type_dependencies": [ + "Nat", + "SimpleGraph", + "Fin", + "DecidableRel", + "SimpleGraph.Adj", + "Not", + "SimpleGraph.Colorable", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.SoundAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "PCP.Algebraic.ThreeColorEncoding.encode", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {b b_1 : Bool}, PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1 → b = b_1", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "recursor", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.CostModel → Sort u} →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n (t : PCP.CostModel) → motive t", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 125, + "is_class": false, + "kind": "definition", + "line": 125, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 0 →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Equal messages give distance zero; distinct ones give distance one half. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 98, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encode_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ},\n 1 ≤ r →\n ∀ (x y : Fin t → ZMod 2),\n PCP.Algebraic.relativeDistance ⇑(PCP.Algebraic.Hadamard.encode r x) ⇑(PCP.Algebraic.Hadamard.encode r y) =\n if x = y then 0 else 1 / 2", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "ite", + "Fintype.decidablePiFintype", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 125, + "is_class": false, + "kind": "constructor", + "line": 125, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The weighted corrector uses a number of bit queries linear in `c`. ", + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 81, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (a b : σ → F) (z : Fˣ)\n (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ a b z v w s).length ≤ 3 * c + 9", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 98, + "is_class": false, + "kind": "theorem", + "line": 96, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.flag_succ", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {k : ℕ} (x p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) (i : Fin k),\n PCP.Reduction.FiniteBooleanConstraints.flag x p (↑i + 1) =\n (PCP.Reduction.FiniteBooleanConstraints.flag x p ↑i || x i ^^ p i)", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Fin", + "Eq", + "Bool", + "PCP.Reduction.FiniteBooleanConstraints.flag", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "OfNat.ofNat", + "instOfNatNat", + "Bool.or", + "Bool.xor" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 97, + "is_class": false, + "kind": "theorem", + "line": 91, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.vanishesOn_of_eq_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (H : Finset R) (p : MvPolynomial σ R)\n (Q : σ → MvPolynomial σ R),\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i → PCP.Algebraic.GridVanishing.VanishesOn H p", + "type_dependencies": [ + "CommRing", + "Fintype", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate", + "PCP.Algebraic.GridVanishing.VanishesOn" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete verifier is determined by its stated physical oracle reads. ", + "end_line": 309, + "is_class": false, + "kind": "theorem", + "line": 300, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.test_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π π' : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n (∀ q ∈ PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s,\n PCP.Algebraic.ThreeColorVerifier.read π q = PCP.Algebraic.ThreeColorVerifier.read π' q) →\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s = PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π' s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorVerifier.queries", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.read", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 75, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.test_eq_true_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (s : PCP.Algebraic.Hadamard.TestRandomness t r),\n PCP.Algebraic.Hadamard.test hr H s = true ↔ PCP.Algebraic.Hadamard.testAccepts hr H s", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "PCP.Algebraic.Hadamard.TestRandomness", + "Iff", + "Eq", + "Bool", + "PCP.Algebraic.Hadamard.test", + "Bool.true", + "PCP.Algebraic.Hadamard.testAccepts" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → (n m c t : ℕ) → [SizeOf F] → SizeOf (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "SizeOf.mk", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ}, IsScalarTower (ZMod 2) (ZMod 2) (PCP.Algebraic.BinaryPolynomialSpace.Monomials t r → ZMod 2)", + "type_dependencies": [ + "Nat", + "IsScalarTower", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddMonoidWithOne.toAddMonoid", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "Pi.instSMul", + "SemigroupAction.toSMul", + "Monoid.toSemigroup", + "MulAction.toSemigroupAction", + "DistribMulAction.toMulAction", + "AddCommMonoid.toAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → Type (max u_3 u_4)", + "type_dependencies": [], + "value_dependencies": [ + "Prod" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Standard constant soundness for every proof oracle. ", + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 53, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.soundAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n ¬(PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.SoundAt x (1 / 2)", + "type_dependencies": [ + "List", + "Bool", + "Not", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Verifier.SoundAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((val : ℕ) → motive (Sum.inr val)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 146, + "is_class": false, + "kind": "theorem", + "line": 140, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_isHomogeneous", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n ((PCP.Algebraic.SetMultilinear.encode m c) P).IsHomogeneous c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "MvPolynomial.IsHomogeneous", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex_injective._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", + "type_dependencies": [ + "Fintype", + "Eq", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.univ", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 149, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a : ι → ZMod 2), PCP.Algebraic.BLR.character a 0 = 1", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.character", + "Zero.toOfNat0", + "Pi.instZero", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLowDegreeTest.test.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {c t r : ℕ} (hr : 1 ≤ r)\n (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (a a_1 : Fin (c + 1) → F),\n a = a_1 →\n ∀ (H H_1 : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n H = H_1 →\n ∀ (s s_1 : PCP.Algebraic.BinaryLowDegreeTest.TestRandomness F σ t r),\n s = s_1 →\n PCP.Algebraic.BinaryLowDegreeTest.test hr ρ a H s =\n PCP.Algebraic.BinaryLowDegreeTest.test hr ρ_1 a_1 H_1 s_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLowDegreeTest.TestRandomness", + "Bool", + "PCP.Algebraic.BinaryLowDegreeTest.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Read an indexed query from the two received oracles. ", + "end_line": 95, + "is_class": false, + "kind": "definition", + "line": 91, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t : ℕ} →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.BinaryLocalCorrection.read.match_1", + "Prod", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.inversion._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),\n ∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a", + "type_dependencies": [ + "DivisionSemiring", + "Finset", + "Eq", + "Finset.sum", + "Semiring.toAddCommMonoid", + "DivisionSemiring.toSemiring", + "HDiv.hDiv", + "instHDiv", + "DivInvMonoid.toDiv", + "GroupWithZero.toDivInvMonoid", + "DivisionSemiring.toGroupWithZero" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instFintypeSym.match_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool ⊕ Unit → Sort u_1) →\n (x : Bool ⊕ Unit) → ((a : Bool) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Unit", + "Sum.inl", + "Sum.inr", + "PUnit.unit" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Unit", + "Sum.inl", + "Sum.inr", + "PUnit.unit", + "Sum.casesOn", + "PUnit.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → PCP.Algebraic.ThreeColorVerifier.Query F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The local corrector uses the same valid-certificate line table as its outer test. ", + "end_line": 75, + "is_class": false, + "kind": "definition", + "line": 73, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validAuxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "Prod.mk", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p_2 m₀_2 mZ_2 : ZMod 2),\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck (some p_2) (some m₀_2) (some mZ_2) =\n some (PCP.Algebraic.BinaryZeroOnGrid.checkBits p_2 m₀_2 mZ_2)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "PCP.Algebraic.BinaryZeroOnGrid.checkBits" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "All finite choices, including the homogeneous label whose answer is requested. ", + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.Sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_3) → Type u_4 → [Monoid F] → ℕ → ℕ → ℕ → Type (max (max u_3 u_4) u_3)", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A degree-sensitive form of Lemma 2.9, retaining the bound before subtraction. ", + "end_line": 131, + "is_class": false, + "kind": "theorem", + "line": 99, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.exists_decomposition", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] [inst_3 : Fintype σ] (H : Finset R)\n (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p →\n ∃ Q,\n (∀ (i : σ), Q i ≠ 0 → (Q i).totalDegree + H.card ≤ p.totalDegree) ∧\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Fintype", + "Finset", + "MvPolynomial", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Exists", + "And", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "MvPolynomial.totalDegree", + "Finset.card", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "PCP.Algebraic.GridVanishing.coordinate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Acceptance probability is exactly `1` precisely when *every* random string accepts. This is\nthe bridge between the probabilistic statement of perfect completeness and the finite, decidable\ncondition used by the NP witness checker below. ", + "end_line": 188, + "is_class": false, + "kind": "theorem", + "line": 169, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_eq_one_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = 1 ↔ ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval π = true", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Iff", + "Eq", + "Rat", + "PCP.Verifier.accProb", + "OfNat.ofNat", + "Rat.instOfNat", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testAccepts_congr._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {a : α} {s t : List α}, (a ∈ s ++ t) = (a ∈ s ∨ a ∈ t)", + "type_dependencies": [ + "List", + "Eq", + "Membership.mem", + "List.instMembership", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "Or" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The vertex constraint applied to the coloring polynomial. ", + "end_line": 29, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [inst : Field F] → MvPolynomial σ F → MvPolynomial σ F", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "AddMonoidAlgebra.semiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidAlgebra.zero", + "Finsupp.instZero" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False", + "type_dependencies": [ + "MonoidWithZero", + "IsReduced", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass", + "NPow.toPow", + "Monoid.toNPow", + "MonoidWithZero.toMonoid", + "Nat", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Eq", + "HPow.hPow", + "instHPow", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {t t' : PCP.Verifier} → t = t' → PCP.Verifier.noConfusionType P t t'", + "type_dependencies": [ + "PCP.Verifier", + "Eq", + "PCP.Verifier.noConfusionType" + ], + "value_dependencies": [ + "PCP.Verifier", + "Eq", + "Eq.ndrec", + "PCP.Verifier.noConfusionType", + "PCP.Verifier.casesOn", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "HEq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same canonical verifier repeated a fixed number of times on the same proof. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier", + "type_dependencies": [ + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.Verifier.repeat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.rec" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.chain_eq_flag._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {k : ℕ} (j : ℕ), j + 1 < k + 1 → ¬j < k → False", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (c k k_1 : ℕ),\n k = k_1 → PCP.Algebraic.SetMultilinear.digitExponents m c k = PCP.Algebraic.SetMultilinear.digitExponents m c k_1", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitExponents" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (accept accept_1 : Bool), (PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1) = (accept = accept_1)", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "PCP.QueryTree", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ),\n PCP.Algebraic.GridVanishing.coordinate H i = ∏ a ∈ H, (MvPolynomial.X i - MvPolynomial.C a)", + "type_dependencies": [ + "CommRing", + "Finset", + "Eq", + "MvPolynomial", + "CommRing.toCommSemiring", + "PCP.Algebraic.GridVanishing.coordinate", + "Finset.prod", + "CommRing.toCommMonoid", + "AddMonoidAlgebra.commRing", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instNonemptyTestRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ}, Nonempty (PCP.Algebraic.Hadamard.TestRandomness t r)", + "type_dependencies": [ + "Nat", + "Nonempty", + "PCP.Algebraic.Hadamard.TestRandomness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.clauses.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} (relation : C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool)\n (scope : C → Fin k → V) (e : C) (p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) (j : Fin 2),\n PCP.Reduction.FiniteBooleanConstraints.clauses relation scope (e, p, Sum.inr j) =\n if ↑j = 0 then\n ![PCP.Reduction.FiniteBooleanConstraints.negate (PCP.Reduction.FiniteBooleanConstraints.flagLiteral e p 0),\n PCP.Reduction.NAEThreeColor.Literal.const false, PCP.Reduction.NAEThreeColor.Literal.const false]\n else\n ![PCP.Reduction.NAEThreeColor.Literal.const (relation e p),\n PCP.Reduction.FiniteBooleanConstraints.flagLiteral e p (Fin.last k),\n PCP.Reduction.NAEThreeColor.Literal.const false]", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.clauses", + "Prod.mk", + "Prod", + "Sum", + "Sum.inr", + "ite", + "Fin.val", + "instDecidableEqNat", + "Matrix.vecCons", + "PCP.Reduction.FiniteBooleanConstraints.negate", + "PCP.Reduction.FiniteBooleanConstraints.flagLiteral", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.instOfNat", + "PCP.Reduction.FiniteBooleanConstraints.clauses._proof_1", + "PCP.Reduction.NAEThreeColor.Literal.const", + "Bool.false", + "Matrix.vecEmpty", + "Fin.last" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.totalDegree_properPolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (E Q : MvPolynomial σ F),\n (PCP.Algebraic.ThreeColorGrid.properPolynomial E Q).totalDegree ≤ E.totalDegree + 3 * Q.totalDegree", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (x : Fin n → F), PCP.Algebraic.HadamardDerivedOracle.cubic.natDegree ≤ 3", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 74, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_prod", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α × β → ℚ),\n (PCP.Algebraic.BLR.average fun x => PCP.Algebraic.BLR.average fun y => f (x, y)) = PCP.Algebraic.BLR.average f", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Prod.mk", + "instFintypeProd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (4 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 213, + "is_class": false, + "kind": "theorem", + "line": 210, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_colorQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.colorQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.color π.colorLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.colorQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep._unsafe_rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree.ofStep.match_3", + "PCP.QueryTree", + "PCP.QueryTree.ofStep.match_1", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.leaf", + "Bool.false", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.QueryTree.query", + "PCP.QueryTree.ofStep._unsafe_rec", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "List.nil", + "Bool.true" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 222, + "is_class": false, + "kind": "theorem", + "line": 221, + "module": "PCP.Verifier.Definition", + "name": "PCP.length_witness_of_oracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (π : PCP.ProofOracle) (N : ℕ), (List.map π (List.range N)).length = N", + "type_dependencies": [ + "PCP.ProofOracle", + "Nat", + "Eq", + "List.length", + "Bool", + "List.map", + "List.range" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {t t' : PCP.CostModel} → t = t' → PCP.CostModel.noConfusionType P t t'", + "type_dependencies": [ + "PCP.CostModel", + "Eq", + "PCP.CostModel.noConfusionType" + ], + "value_dependencies": [ + "PCP.CostModel", + "Eq", + "Eq.ndrec", + "PCP.CostModel.noConfusionType", + "PCP.CostModel.casesOn", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq.refl" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (i i_1 : Fin t),\n i = i_1 →\n ∀ (a a_1 : PCP.Algebraic.BinaryPolynomialSpace.Monomials t r),\n a = a_1 →\n PCP.Algebraic.BinaryPolynomialSpace.variableCoeff hr i a =\n PCP.Algebraic.BinaryPolynomialSpace.variableCoeff hr i_1 a_1", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "Eq", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (2 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The formerly open point-versus-line proposition, now proved in every dimension. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 79, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.pointLineSoundness_largeField", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (m c : ℕ),\n PCP.Algebraic.PointLineConstants.fieldFactor * c ^ 3 ≤ Fintype.card F →\n PCP.Algebraic.PointLineSoundness F m c PCP.Algebraic.PointLineConstants.smallError", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", "PCP.Algebraic.PointLineSoundness", - "PCP.Algebraic.SetMultilinear", - "PCP.Algebraic.ThreeColorAmplifiedVerifier", - "PCP.Algebraic.ThreeColorGrid", - "PCP.Algebraic.ThreeColorVerifier", - "PCP.Algebraic.ThreeColorVerifierCompleteness", - "PCP.Algebraic.ThreeColorVerifierSoundness", - "PCP.Complexity.CostModel", - "PCP.Complexity.Machine", - "PCP.Complexity.NP", - "PCP.Complexity.ThreeColorRuntime", - "PCP.Reduction.FiniteBooleanConstraints", - "PCP.ReverseConcrete", - "PCP.Theorem", - "PCP.Verifier.Definition" - ], - "lean_version": "4.35.0-rc2", - "provenance": { - "kind": "source-read", - "text": "The reading-guide interface retains extracted records from matching pinned source. The forward theorem retains statement compilation. Other selected declarations are source excerpts. Proof dependencies and axiom reports depend on the record's provenance." - }, - "declarations": [ - { - "axioms": [], - "doc": null, - "end_line": 33, - "is_class": false, - "kind": "theorem", - "line": 25, - "module": "PCP.Theorem", - "name": "PCP.np_subset_pcp", - "provenance": "statement-compiled", - "structural_dependencies": [], - "type": "theorem np_subset_pcp (L : Language) (hL : InNP Machine.PolyTimeRel L) :\n ∃ (V : Verifier) (alg : VerifierAlg) (a b q : ℕ) (p : Polynomial ℕ),\n Machine.PolyTimeAlg alg ∧\n V.ImplementedBy alg ∧\n V.queries = q ∧\n V.CanonicalRandomness a b ∧\n (∀ x : List Bool, V.ReadsBelow x (p.eval x.length)) ∧\n (∀ x : List Bool, L x → V.CompleteAt x) ∧\n (∀ x : List Bool, ¬ L x → V.SoundAt x (1 / 2))", - "type_dependencies": [ - "And", - "Bool", - "Eq", - "Exists", - "HDiv.hDiv", - "List", - "List.length", - "Nat", - "Nat.instSemiring", - "Not", - "OfNat.ofNat", - "PCP.InNP", - "PCP.Language", - "PCP.Machine.PolyTimeAlg", - "PCP.Machine.PolyTimeRel", - "PCP.Verifier", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.CompleteAt", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.ReadsBelow", - "PCP.Verifier.SoundAt", - "PCP.Verifier.queries", - "PCP.VerifierAlg", - "Polynomial", - "Polynomial.eval", - "Rat", - "Rat.instDiv", - "Rat.instOfNat", - "instHDiv" - ], - "value_dependencies": [] - }, - { - "name": "PCP.Algebraic.ThreeColorGrid.constraints_iff_satisfies", - "module": "PCP.Algebraic.ThreeColorGrid", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem constraints_iff_satisfies (H : Finset F)\n (G : SimpleGraph (σ → H)) (P : MvPolynomial σ F) :\n (VanishesOn H (validPolynomial P) ∧\n VanishesOn H (properPolynomial (edgeExtension H G) (differencePolynomial P))) ↔\n Satisfies G (fun a => eval (fun i => (a i : F)) P)\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F]\nvariable [Fintype σ] [DecidableEq σ] [DecidableEq F]", - "line": 91, - "end_line": 114, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_decomposition", - "module": "PCP.Algebraic.GridVanishing", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem vanishesOn_iff_exists_decomposition (H : Finset R)\n (p : MvPolynomial σ R) :\n VanishesOn H p ↔ ∃ Q : σ → MvPolynomial σ R,\n (∀ i, (Q i).totalDegree ≤ p.totalDegree - H.card) ∧\n p = ∑ i, Q i * coordinate H i\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {R σ : Type*} [CommRing R]\nvariable [IsDomain R]\nvariable [Finite σ]\nvariable [Fintype σ]", - "line": 134, - "end_line": 148, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.PointLineTest.exists_close_of_small_rejection", - "module": "PCP.Algebraic.PointLineSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_close_of_small_rejection\n (hq : fieldFactor * d ^ 3 ≤ Fintype.card F) (f : (σ → F) → F)\n (table : LineTable F σ d) (hδ : rejectionRate f table ≤ smallError) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ d ∧\n relativeDistance f (fun x => MvPolynomial.eval x P) ≤ 2 * rejectionRate f table\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Fintype F] [DecidableEq F]\nvariable [Fintype σ] [DecidableEq σ] {d : ℕ}", - "line": 58, - "end_line": 69, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_close", - "module": "PCP.Algebraic.GeneratorLowDegreeTest", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_close (hq : 2 * c < Fintype.card F)\n (hζ : IsPrimitiveRoot ζ (Fintype.card F - 1)) (f : (σ → F) → F)\n {δ : ℚ} (hrej : rejectionRate c ζ f ≤ δ) (hδ : δ < 1 / (2 * (c + 2 : ℚ) ^ 2)) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ c ∧\n relativeDistance f (fun x => MvPolynomial.eval x P) ≤ 2 * δ\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] {c : ℕ}\nvariable [Fintype F] {ζ : F}\nvariable [Fintype F] {ζ : F}\nvariable [DecidableEq F] [Fintype σ] [DecidableEq σ]", - "line": 274, - "end_line": 292, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BLR.exists_linearMap_distance_le_of_rejection_le", - "module": "PCP.Algebraic.BLR", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_linearMap_distance_le_of_rejection_le (H : (ι → ZMod 2) → ZMod 2)\n {ε : ℚ} (hε : rejectionProbability H ≤ ε) :\n ∃ L : (ι → ZMod 2) →ₗ[ZMod 2] ZMod 2, relativeDistance H L ≤ ε\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {ι : Type*} [Fintype ι]\nvariable [DecidableEq ι]", - "line": 321, - "end_line": 325, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.Hadamard.test_soundness", - "module": "PCP.Algebraic.HadamardSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem test_soundness (hr : 1 ≤ r) (H : Coefficients t r → ZMod 2)\n {δ : ℚ} (hδ : δ < (1 : ℚ) / 28) (hH : testRejectionRate hr H ≤ δ) :\n ∃ x : Fin t → ZMod 2,\n relativeDistance H (encode r x) ≤ δ ∧\n relativeDistance (fun p : Coefficients t 1 => H (embed hr p)) (encode 1 x) ≤\n 3 * δ\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {t r : ℕ}", - "line": 29, - "end_line": 61, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.EncodedLineLowDegreeTest.exists_close", - "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_close\n (hq : PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F)\n (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ)\n (f : (σ → F) → Coefficients t r → ZMod 2) (H : Auxiliary F σ m c t)\n (hsmall : lineErrorConstant c * rejectionRate hr ρ nodes ζ f H ≤\n PointLineConstants.smallError) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ c * m ^ c ∧\n relativeDistance (fun p : (σ → F) × Coefficients t r => f p.1 p.2)\n (encodeFunction r (fun x => ρ (MvPolynomial.eval x P))) ≤\n soundnessConstant c * rejectionRate hr ρ nodes ζ f H ∧\n BinaryLagrangeConstraint.homogeneousDistance hr f\n (fun x => encode r (ρ (MvPolynomial.eval x P))) ≤\n soundnessConstant c * rejectionRate hr ρ nodes ζ f H\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Algebra (ZMod 2) F] {m c t r : ℕ}\nvariable [Fintype F] [DecidableEq F] [Fintype σ] [DecidableEq σ]\nvariable [CharP F 2]\nvariable [NeZero m]", - "line": 325, - "end_line": 359, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate_ge_of_not_colorable", - "module": "PCP.Algebraic.ThreeColorVerifierSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem rejectionRate_ge_of_not_colorable\n (hc : 1 ≤ c)\n (hq : PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) {ω : F} (hω : IsPrimitiveRoot ω 3)\n (H : Finset F) (hH : H.Nonempty)\n (hgrid : 100 * (c * m ^ c) * H.card ≤ Fintype.card F)\n (hdegree : (H.card - 1) * n ≤ c * m ^ c)\n (G : SimpleGraph (Fin n → H)) (hG : ¬ G.Colorable 3) (π : Proof F n m c t) :\n ThreeColorSoundnessBudget.gap c ≤ rejectionRate ρ nodes ζ H G π\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F : Type*} [Field F] [Algebra (ZMod 2) F] [Fintype F]\nvariable {n m c t : ℕ} [NeZero m] [CharP F 2]", - "line": 117, - "end_line": 130, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Lang.ThreeColorRuntime.polyTimeAlg", - "module": "PCP.Complexity.ThreeColorRuntime", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem polyTimeAlg :\n Machine.PolyTimeAlg ComputableThreeColorAmplifiedQueryAlgorithm.algorithm\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 11, - "end_line": 15, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_rejectionRate_eq_zero", - "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_proof_rejectionRate_eq_zero (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : Function.Injective nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) {ω : F} (hω : IsPrimitiveRoot ω 3)\n (H : Finset F) (hH : H.Nonempty) (G : SimpleGraph (Fin n → H)) (hG : G.Colorable 3)\n (hdegree : 5 * ((H.card - 1) * n) < m ^ c) :\n ∃ π : Proof F n m c t, rejectionRate ρ nodes ζ H G π = 0\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F : Type*} [Field F] [Algebra (ZMod 2) F] {n m c t : ℕ}\nvariable [NeZero m]\nvariable [CharP F 2]\nvariable [Fintype F]", - "line": 130, - "end_line": 141, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le", - "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem failure_le\n (hq : 2 * c < Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ)\n {D : ℕ} (P : MvPolynomial σ F) (hP : P.totalDegree ≤ D)\n (hdecode : c * m ^ c ≤ D)\n (f : (σ → F) → Coefficients t 1 → ZMod 2)\n (H : (σ → F) → RowOracle F m c t) {δ : ℚ}\n (hnear : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) f\n (fun x => encode 1 (ρ (MvPolynomial.eval x P))) ≤ δ) (a : σ → F) :\n relativeDistance (sample ρ nodes ζ f H a)\n (fun s : Sample F σ m c t => some (linearEncode (ρ (MvPolynomial.eval a P)) s.2.2.1.2)) ≤\n soundnessConstant c * rejectionRate ρ nodes ζ f H a + δ +\n (D : ℚ) / (2 * (Fintype.card F - 1 : ℕ))\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Algebra (ZMod 2) F] {m c t : ℕ}\nvariable [Fintype F] [DecidableEq F] [Fintype σ] [DecidableEq σ]\nvariable [CharP F 2]\nvariable [NeZero m]", - "line": 222, - "end_line": 313, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_ge", - "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem rejectionRate_ge\n (hq : 2 * c < Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) (H : Finset F) (hH : H.Nonempty)\n (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F)\n (hP : P.totalDegree ≤ D) (hM : M.totalDegree ≤ D)\n (hdecode : c * m ^ c ≤ D) (hnot : ¬ GridVanishing.VanishesOn H P)\n (p' : (Fin n → F) → Coefficients t 1 → ZMod 2)\n (M' : CertificatePoint F n → Coefficients t 1 → ZMod 2)\n (A : Auxiliary F n m c t) {δP δM : ℚ}\n (hp : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) p'\n (fun x => encode 1 (ρ (eval x P))) ≤ δP)\n (hm : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) M'\n (fun x => encode 1 (ρ (eval x M))) ≤ δM) :\n ((1 - ((D * H.card : ℕ) : ℚ) / Fintype.card F) / 2 - δP - 2 * δM -\n (D : ℚ) / (Fintype.card F - 1 : ℕ)) /\n (1 + 2 * BinaryLocalCorrection.soundnessConstant c) ≤\n rejectionRate ρ nodes ζ H p' M' A\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {X W S A : Type*} [Fintype X] [Fintype W] [Fintype S] [Nonempty S]\nvariable [DecidableEq A]\nvariable {X W S : Type*} [Fintype X] [Nonempty X] [Fintype W]\nvariable [Fintype S] [Nonempty S]\nvariable {F : Type*} [Field F] [Algebra (ZMod 2) F] [Fintype F] [DecidableEq F]\nvariable [CharP F 2] {n m c t D : ℕ} [NeZero m]", - "line": 301, - "end_line": 325, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.pcp_subset_np_concrete", - "module": "PCP.ReverseConcrete", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem pcp_subset_np_concrete (L : Language) (V : Verifier) (alg : VerifierAlg) (a b : ℕ)\n (p : Polynomial ℕ) (halg : Machine.PolyTimeAlg alg) (himpl : V.ImplementedBy alg)\n (hrand : V.CanonicalRandomness a b)\n (hlen : ∀ x : List Bool, V.ReadsBelow x (p.eval x.length))\n (hcomplete : ∀ x : List Bool, L x → V.CompleteAt x)\n (hsound : ∀ x : List Bool, ¬ L x → V.SoundAt x (1 / 2)) :\n InNP Machine.PolyTimeRel L\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 33, - "end_line": 43, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.Hadamard.relativeDistance_encodeFunction_map", - "module": "PCP.Algebraic.Hadamard", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem relativeDistance_encodeFunction_map {ι α : Type*} [Fintype ι] [DecidableEq α]\n (ρ : α → Fin t → ZMod 2) (hρ : Function.Injective ρ) (hr : 1 ≤ r) (f g : ι → α) :\n relativeDistance (encodeFunction r (fun i => ρ (f i)))\n (encodeFunction r (fun i => ρ (g i))) = (1 : ℚ) / 2 * relativeDistance f g", - "line": 119, - "end_line": 123, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verification_guarantees", - "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem verification_guarantees :\n 0 < repetitions ∧ verifier.queries = repetitions * 187 ∧\n verifier.CanonicalRandomness (repetitions * 32000000) (repetitions * 32000000) ∧\n (∀ x, verifier.ReadsBelow x (ThreeColorCanonicalVerifier.proofBound.eval x.length)) ∧\n (∀ x, (ThreeColorEncoding.graph x).Colorable 3 → verifier.CompleteAt x) ∧\n (∀ x, ¬ (ThreeColorEncoding.graph x).Colorable 3 → verifier.SoundAt x (1 / 2))\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 72, - "end_line": 78, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "axioms": [ - "propext" - ], - "doc": "Reading the first `N` bits of an oracle back out reproduces it below `N`. ", - "end_line": 219, - "is_class": false, - "kind": "theorem", - "line": 216, - "module": "PCP.Verifier.Definition", - "name": "PCP.oracleOfWitness_prefix", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (π : PCP.ProofOracle) (N : ℕ) {j : ℕ}, j < N → PCP.oracleOfWitness (List.map π (List.range N)) j = π j", - "type_dependencies": [ - "PCP.ProofOracle", - "Nat", - "LT.lt", - "instLTNat", - "Eq", - "Bool", - "PCP.oracleOfWitness", - "List.map", - "List.range" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk", - "PCP.Verifier.rec" - ] - }, - { - "axioms": [], - "doc": "A proof oracle is an infinite Boolean string; `π a` is the bit at address `a`. ", - "end_line": 28, - "is_class": false, - "kind": "definition", - "line": 27, - "module": "PCP.Verifier.Definition", - "name": "PCP.ProofOracle", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "Nat", - "Bool" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodePair.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (p : List Bool × List Bool),\n PCP.Machine.encodePair p = PCP.Machine.ofBits p.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits p.2", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.encodePair", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "Logarithmic randomness as an upper bound: at most `a * ⌈log₂ (n + 2)⌉ + b` fair bits on\ninputs of length `n`.\n\n**This is too weak to be an efficiency hypothesis on its own.** An upper bound does not make\n`randomness` computable, and `Verifier.randomness` is an unrestricted function `ℕ → ℕ`. Take\n`randomness n = if f n then 1 else 0` for arbitrary `f`: the\nbound `LogRandomness 0 1` holds, yet the budget smuggles in an arbitrary Boolean function of the\ninput length, which an algorithm recovers just by measuring the length of the random string it is\nhanded. Use `CanonicalRandomness` wherever efficiency is at stake. ", - "end_line": 146, - "is_class": false, - "kind": "definition", - "line": 136, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.LogRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ → ℕ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "LE.le", - "instLENat", - "PCP.Verifier.randomness", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "HMul.hMul", - "instHMul", - "instMulNat", - "Nat.clog", - "OfNat.ofNat", - "instOfNatNat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.ofBits.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : List Bool), PCP.Machine.ofBits x = List.map PCP.Machine.Sym.bit x", - "type_dependencies": [ - "List", - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.ofBits", - "List.map", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.acceptingRandomness.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.acceptingRandomness x π = {r | (V.run x r).eval π = true}", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Eq", - "Finset", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.Verifier.acceptingRandomness", - "Finset.filter", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "Bool.true", - "instDecidableEqBool", - "Finset.univ", - "Fin.fintype" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "Eq", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 79, - "is_class": false, - "kind": "constructor", - "line": 79, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk", - "provenance": "lean", - "structural_dependencies": [ - "PCP.CostModel" - ], - "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.finiteWitnessCheck.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w =\n decide (∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true)", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Eq", - "PCP.finiteWitnessCheck", - "Decidable.decide", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "PCP.oracleOfWitness", - "Bool.true", - "Nat.decidableForallFin", - "instDecidableEqBool" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b : Bool), sizeOf (PCP.Machine.Sym.bit b) = 1 + sizeOf b", - "type_dependencies": [ - "Bool", - "Eq", - "Nat", - "SizeOf.sizeOf", - "PCP.Machine.Sym", - "PCP.Machine.Sym._sizeOf_inst", - "PCP.Machine.Sym.bit", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "Bool._sizeOf_inst" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk", - "PCP.NPCertificate.rec" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A verifier algorithm is polynomial-time when some `FinTM2` machine computes its step function\nwithin a polynomial number of steps in the encoded input length. ", - "end_line": 73, - "is_class": false, - "kind": "definition", - "line": 69, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.PolyTimeAlg", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.VerifierAlg → Prop", - "type_dependencies": [ - "PCP.VerifierAlg" - ], - "value_dependencies": [ - "PCP.VerifierAlg", - "Nonempty", - "Turing.TM2ComputableInPolyTime", - "Prod", - "List", - "Bool", - "Sum", - "Nat", - "PCP.Machine.Sym", - "PCP.Machine.encodeTriple", - "PCP.Machine.encodeAnswer", - "Prod.fst", - "Prod.snd" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A uniform cost model: what \"polynomial time\" means for witness-checking relations and for\nverifier algorithms, together with the coherence and closure properties any genuine model has.\n\nThe field docstrings explain why each field is present. **The machine model is no longer a choice**:\n`PCP/Complexity/Machine.lean` fixes it as `Turing.TM2ComputableInPolyTime`. Showing those concrete\npredicates satisfy this interface was obligation NP-1, now discharged: the two coherence fields in\n`PCP/Complexity/Bridge.lean`, the closure field below in `PCP/Complexity/StandardModel.lean`.\nNote the known cost of that choice: *some* certified composition or subroutine result is needed for\nthe closure field, and mathlib's `comp` is an open `proof_wanted` at the pinned revision. That\nupstream theorem is one route; a specialised call-and-return construction for these fixed encodings\nis another, and is the one that was built. ", - "end_line": 108, - "is_class": false, - "kind": "inductive", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel", - "provenance": "lean", - "structural_dependencies": [ - "PCP.CostModel.mk", - "PCP.CostModel" - ], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] → [(a : List Bool) → SizeOf (L a)] → PCP.NPCertificate P L → ℕ", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "PCP.NPCertificate", - "Nat" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "PCP.NPCertificate", - "PCP.NPCertificate.rec", - "Nat", - "Polynomial", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "SizeOf.sizeOf", - "Polynomial._sizeOf_inst", - "instSizeOfNat" - ] - }, - { - "axioms": [], - "doc": "The depth-`d` decision tree generated by unfolding a step function, starting from the answers\n`as` received so far.\n\nIf the step function has not halted within its `d`-query budget the tree rejects: an algorithm\nclaiming a `q`-query verifier must halt within `q` queries, and `ImplementedBy` below is what\nforces that to match the verifier's actual behaviour. ", - "end_line": 47, - "is_class": false, - "kind": "definition", - "line": 35, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Nat.brecOn", - "PCP.QueryTree", - "PCP.QueryTree.ofStep._f" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "If the oracles agree on every address the tree can reach, the tree cannot tell them apart. ", - "end_line": 77, - "is_class": false, - "kind": "theorem", - "line": 67, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval_congr", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (T : PCP.QueryTree d) {π π' : PCP.ProofOracle}, (∀ a ∈ T.addresses, π a = π' a) → T.eval π = T.eval π'", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.eval" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.brecOn.go", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t ×' PCP.QueryTree.below t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PProd" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.QueryTree.rec", - "PProd", - "Bool", - "PProd.mk", - "PCP.QueryTree.leaf", - "PUnit", - "PUnit.unit", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 36, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 1 →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Polynomial bound on witness length. ", - "end_line": 32, - "is_class": false, - "kind": "definition", - "line": 32, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.witnessBound", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → Polynomial ℕ", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ] - }, - { - "axioms": [], - "doc": "A language over the binary alphabet: inputs are bit strings. ", - "end_line": 15, - "is_class": false, - "kind": "definition", - "line": 14, - "module": "PCP.Complexity.NP", - "name": "PCP.Language", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "List", - "Bool" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Every address the tree could query, along any branch. ", - "end_line": 49, - "is_class": false, - "kind": "definition", - "line": 46, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.brecOn", - "Finset", - "PCP.QueryTree.addresses._f" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (d : ℕ) (f t : PCP.QueryTree d),\n (f.addresses ∪ t.addresses).card ≤ f.addresses.card + t.addresses.card →\n ¬(f.addresses ∪ t.addresses).card + 1 ≤ 1 + (f.addresses.card + t.addresses.card) → False", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "LE.le", - "instLENat", - "Finset.card", - "Union.union", - "Finset", - "Finset.instUnion", - "instDecidableEqNat", - "PCP.QueryTree.addresses", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Not", - "Preorder.toLE", - "Nat.instPreorder", - "OfNat.ofNat", - "instOfNatNat", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (f : PCP.QueryTree.below x_1), x_1.addresses.card < 2 ^ x", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", - "Bool", - "PCP.QueryTree.leaf", - "of_eq_true", - "Preorder.toLT", - "PartialOrder.toPreorder", - "Nat.instPartialOrder", - "Zero.toOfNat0", - "MulZeroClass.toZero", - "MulZeroOneClass.toMulZeroClass", - "MonoidWithZero.toMulZeroOneClass", - "Nat.instMonoidWithZero", - "MonoidWithZero.toMonoid", - "pow_pos._simp_1", - "LinearOrderedCommMonoidWithZero.toPosMulStrictMono", - "Nat.instLinearOrderedCommMonoidWithZero", - "Nat.instZeroLEOneClass", - "SemilatticeInf.toPartialOrder", - "Lattice.toSemilatticeInf", - "DistribLattice.toLattice", - "instDistribLatticeOfLinearOrder", - "Nat.instLinearOrder", - "instOfNatAtLeastTwo", - "AddMonoidWithOne.toNatCast", - "Nat.instAddMonoidWithOne", - "Nat.instAtLeastTwoHAddOfNat", - "Nat.instNeZeroSucc", - "Eq.trans", - "LE.le", - "Preorder.toLE", - "One.toOfNat1", - "AddMonoidWithOne.toOne", - "True", - "Order.lt_two_iff._simp_1", - "Nat.instSuccAddOrder", - "Nat.instNoMaxOrder", - "zero_le._simp_1", - "LinearOrderedCommMonoidWithZero.toIsBotZeroClass", - "Nat.succ", - "PCP.QueryTree.query", - "PProd", - "instLENat", - "Insert.insert", - "Finset", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "LE.le.trans", - "Nat.instPreorder", - "Finset.card_insert_le", - "Finset.card_union_le", - "Decidable.byContradiction", - "Nat.decLe", - "Not", - "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", - "id", - "Eq", - "Mathlib.Tactic.Ring.of_eq", - "Distrib.toAdd", - "instDistribOfSemiring", - "CommSemiring.toSemiring", - "Nat.instCommSemiring", - "HMul.hMul", - "instHMul", - "Distrib.toMul", - "Semiring.toMonoid", - "Nat.rawCast", - "AddCommMonoidWithOne.toAddMonoidWithOne", - "NonAssocSemiring.toAddCommMonoidWithOne", - "Semiring.toNonAssocSemiring", - "instMulZeroClassOfSemiring", - "instMulNat", - "Mathlib.Tactic.Ring.Common.pow_congr", - "Mathlib.Tactic.Ring.cast_pos", - "Mathlib.Meta.NormNum.isNat_ofNat", - "Eq.refl", - "Mathlib.Tactic.Ring.Common.add_congr", - "Mathlib.Tactic.Ring.Common.atom_pf", - "rfl", - "Eq.mpr", - "congrArg", - "Eq.symm", - "Mathlib.Tactic.Ring.Common.add_pf_add_gt", - "Mathlib.Tactic.Ring.Common.add_pf_add_zero", - "Mathlib.Tactic.Ring.Common.pow_add", - "Mathlib.Tactic.Ring.Common.pow_one_cast_of_isNat", - "Mathlib.Meta.NormNum.IsNat.mk", - "Mathlib.Tactic.Ring.Common.single_pow", - "Mathlib.Tactic.Ring.Common.pow_prod_atom", - "Mathlib.Tactic.Ring.Common.pow_zero", - "Mathlib.Tactic.Ring.Common.add_mul", - "Mathlib.Tactic.Ring.Common.mul_add", - "Mathlib.Tactic.Ring.Common.mul_pf_left", - "Mathlib.Meta.NormNum.IsNat.to_raw_eq", - "Mathlib.Meta.NormNum.isNat_mul", - "Mathlib.Meta.NormNum.IsNat.of_raw", - "Mathlib.Tactic.Ring.Common.mul_zero", - "Mathlib.Tactic.Ring.Common.zero_mul", - "Mathlib.Tactic.Ring.Common.mul_pf_right", - "Mathlib.Tactic.Ring.Common.add_pf_add_overlap", - "Mathlib.Tactic.Ring.Common.add_overlap_pf", - "Mathlib.Meta.NormNum.isNat_add", - "Mathlib.Tactic.Ring.Common.add_pf_zero_add", - "Nat.decLt", - "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instReprSym.repr", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym → ℕ → Format", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "Std.Format" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "PCP.Machine.instFintypeSym.match_5", - "Std.Format", - "Bool", - "Repr.addAppParen", - "Std.Format.group", - "Std.Format.nest", - "ite", - "Int", - "GE.ge", - "instLENat", - "OfNat.ofNat", - "instOfNatNat", - "Nat.decLe", - "instOfNat", - "HAppend.hAppend", - "instHAppendOfAppend", - "Std.Format.instAppend", - "Std.Format.text", - "Std.Format.line", - "reprArg", - "instReprBool", - "Std.Format.FlattenBehavior.allOrNone", - "Unit" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : PCP.Machine.Sym → PCP.Machine.Sym → Sort u_1) →\n (x x_1 : PCP.Machine.Sym) →\n ((a b : Bool) → motive (PCP.Machine.Sym.bit a) (PCP.Machine.Sym.bit b)) →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b) PCP.Machine.Sym.sep) →\n ((b : Bool) → motive PCP.Machine.Sym.sep (PCP.Machine.Sym.bit b)) →\n (Unit → motive PCP.Machine.Sym.sep PCP.Machine.Sym.sep) → motive x x_1", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "Unit" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "Unit", - "PCP.Machine.Sym.casesOn", - "Unit.unit" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A certificate that `L` is in NP relative to a notion `P` of polynomial-time checkability: a\npolynomial witness bound and a witness-checking relation that `P` accepts.\n\n`P` is a plain parameter here, and that is safe *because nothing is proved by quantifying over it*.\n`InNP` is a definition, not a theorem. The two consumers each pin it down:\n\n* `pcp_subset_np` instantiates `P := M.PolyTimeRel` for a `CostModel` `M`, whose closure field is\n what makes the conclusion non-vacuous;\n* `np_subset_pcp` instantiates `P := PCP.Machine.PolyTimeRel`, the concrete machine definition.\n\nNeither quantifies over an arbitrary `P`. The distinction matters:\na *theorem* over an unconstrained interface is refutable by choosing a degenerate instance; a\n*definition* parameterised by one is just a definition. ", - "end_line": 39, - "is_class": false, - "kind": "inductive", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate", - "provenance": "lean", - "structural_dependencies": [ - "PCP.NPCertificate.mk", - "PCP.NPCertificate" - ], - "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Type", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → ℕ", - "type_dependencies": [ - "PCP.CostModel", - "Nat" - ], - "value_dependencies": [ - "PCP.CostModel", - "PCP.CostModel.rec", - "Nat", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "OfNat.ofNat", - "instOfNatNat" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Verifier algorithms running in polynomial time. ", - "end_line": 83, - "is_class": false, - "kind": "definition", - "line": 83, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.PolyTimeAlg", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → PCP.VerifierAlg → Prop", - "type_dependencies": [ - "PCP.CostModel", - "PCP.VerifierAlg" - ], - "value_dependencies": [ - "PCP.CostModel" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk", - "PCP.NPCertificate.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval._sunfold", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "PCP.QueryTree.eval.match_1", - "Bool", - "ite", - "Eq", - "Bool.true", - "instDecidableEqBool", - "PCP.QueryTree.eval" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "The `k`-bit binary expansion of a random string index, least significant bit first. ", - "end_line": 28, - "is_class": false, - "kind": "definition", - "line": 26, - "module": "PCP.Complexity.CostModel", - "name": "PCP.bitsOfFin", - "provenance": "lean", - "structural_dependencies": [], - "type": "(k : ℕ) → Fin (2 ^ k) → List Bool", - "type_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List", - "Bool" - ], - "value_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.map", - "Bool", - "Nat.testBit", - "Fin.val", - "List.range" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R}\n {polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)}\n {PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg_1 : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R}\n {polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)},\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 } →\n PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d), (PCP.QueryTree.query a f t).addresses = insert a (f.addresses ∪ t.addresses)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "Finset", - "PCP.QueryTree.addresses", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": 56, - "is_class": false, - "kind": "theorem", - "line": 54, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodeTriple", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (t : List Bool × List Bool × List Bool),\n (PCP.Machine.encodeTriple t).length = t.1.length + t.2.1.length + t.2.2.length + 2", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "Nat", - "List.length", - "PCP.Machine.Sym", - "PCP.Machine.encodeTriple", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "(P : (List Bool → List Bool → Bool) → Prop) →\n (L : PCP.Language) →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] →\n [(a : List Bool) → SizeOf (L a)] → SizeOf (PCP.NPCertificate P L)", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "SizeOf.mk", - "PCP.NPCertificate", - "PCP.NPCertificate._sizeOf_1" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": "A canonical budget *is* the closed-form function of the two constants.\n\nNamed for what it says. It is an equality of functions, not a proposition of type\n`Computable V.randomness`. None is needed downstream: the closed form is evidently computable, and\nthe verifier's efficiency is certified separately through `Verifier.ImplementedBy` and the machine\npredicates of `PCP/Complexity/Machine.lean`. ", - "end_line": 167, - "is_class": false, - "kind": "theorem", - "line": 160, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CanonicalRandomness.eq_closedForm", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.randomness = fun n => a * Nat.clog 2 (n + 2) + b", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "PCP.Verifier.CanonicalRandomness", - "Eq", - "PCP.Verifier.randomness", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "HMul.hMul", - "instHMul", - "instMulNat", - "Nat.clog", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Acceptance probability, as an exact rational: the fraction of the `2 ^ randomness` equally\nlikely random strings on which `V` accepts. ", - "end_line": 104, - "is_class": false, - "kind": "definition", - "line": 101, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → PCP.ProofOracle → ℚ", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Rat" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "HDiv.hDiv", - "Rat", - "instHDiv", - "Rat.instDiv", - "Nat.cast", - "Rat.instNatCast", - "Finset.card", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.Verifier.acceptingRandomness", - "Rat.instPowNat", - "Rat.instOfNat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.ctorElimType", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} → ℕ → Sort (max 1 u)", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "cond", - "Nat.ble", - "PULift", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 158, - "is_class": false, - "kind": "theorem", - "line": 157, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CanonicalRandomness.logRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.LogRandomness a b", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.LogRandomness" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d addr : ℕ} {onFalse onTrue : PCP.QueryTree d} {addr_1 : ℕ} {onFalse_1 onTrue_1 : PCP.QueryTree d},\n PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1 →\n addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Perfect completeness at `x`: some proof is accepted with probability 1. ", - "end_line": 131, - "is_class": false, - "kind": "definition", - "line": 130, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CompleteAt", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → Prop", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Exists", - "PCP.ProofOracle", - "Eq", - "Rat", - "PCP.Verifier.accProb", - "OfNat.ofNat", - "Rat.instOfNat" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)),\n sizeOf\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n 1", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "SizeOf.sizeOf", - "PCP.CostModel", - "PCP.CostModel._sizeOf_inst", - "PCP.CostModel.mk", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.brecOn.eq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {motive : (a : ℕ) → PCP.QueryTree a → Sort u} {a : ℕ} (t : PCP.QueryTree a)\n (F_1 : (a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t),\n PCP.QueryTree.brecOn t F_1 = F_1 a t (PCP.QueryTree.brecOn.go t F_1).2", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "Eq", - "PCP.QueryTree.brecOn", - "PProd", - "PCP.QueryTree.brecOn.go" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "The randomness budget is **exactly** `a * ⌈log₂ (n + 2)⌉ + b`.\n\nTwo constants determine the whole budget, so it is computable by construction and carries no\ninformation of its own. This is the \"canonical computable budget\" repair: it closes the hole that\n`LogRandomness` leaves open, and it is without loss of generality because a verifier that wants\nfewer bits can ignore the surplus. ", - "end_line": 155, - "is_class": false, - "kind": "definition", - "line": 148, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CanonicalRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ → ℕ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "Eq", - "PCP.Verifier.randomness", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "HMul.hMul", - "instHMul", - "instMulNat", - "Nat.clog", - "OfNat.ofNat", - "instOfNatNat" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {randomness : ℕ → ℕ} {queries : ℕ} {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries}\n {randomness_1 : ℕ → ℕ} {queries_1 : ℕ}\n {run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1},\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 } →\n randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "And", - "HEq" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.rec" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "The NP checking relation induced by a verifier: accept `(x, w)` when the finite witness `w`,\nread as a proof, makes `V` accept on *every* random string.\n\nThis is decidable because the random space `Fin (2 ^ randomness)` is finite, which is the whole\npoint: perfect completeness turns into a finite check. Whether it is *polynomial-time* decidable\nis a separate question, answered by `CostModel.polyTimeRel_finiteWitnessCheck`. ", - "end_line": 210, - "is_class": false, - "kind": "definition", - "line": 203, - "module": "PCP.Verifier.Definition", - "name": "PCP.finiteWitnessCheck", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → List Bool → Bool", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Decidable.decide", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Eq", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "PCP.oracleOfWitness", - "Bool.true", - "Nat.decidableForallFin", - "instDecidableEqBool" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A binary relation on bit strings is polynomial-time when some `FinTM2` machine computes it\nwithin a polynomial number of steps in the encoded input length. ", - "end_line": 67, - "is_class": false, - "kind": "definition", - "line": 64, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.PolyTimeRel", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → List Bool → Bool) → Prop", - "type_dependencies": [ - "List", - "Bool" - ], - "value_dependencies": [ - "List", - "Bool", - "Nonempty", - "Turing.TM2ComputableInPolyTime", - "Prod", - "PCP.Machine.Sym", - "PCP.Machine.encodePair", - "PCP.Machine.encodeBool", - "Prod.fst", - "Prod.snd" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.eq_def", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 : PCP.ProofOracle),\n x_1.eval x_2 =\n match x, x_1, x_2 with\n | x, PCP.QueryTree.leaf b, x_3 => b\n | .(d + 1), PCP.QueryTree.query a f t, π => if π a = true then t.eval π else f.eval π", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Eq", - "Bool", - "PCP.QueryTree.eval", - "PCP.QueryTree.eval.match_1", - "ite", - "Bool.true", - "instDecidableEqBool" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The tree reads at most `d` bits along any branch: its address set has at most `2 ^ d - 1`\nelements, and along a single run at most `d` queries are made. ", - "end_line": 65, - "is_class": false, - "kind": "theorem", - "line": 51, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (T : PCP.QueryTree d), T.addresses.card < 2 ^ d", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeAnswer.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((a : ℕ) → motive (Sum.inr a)) → motive x", - "type_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr", - "Sum.casesOn" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language}\n [inst : (a : List Bool → List Bool → Bool) → SizeOf (P a)] [inst_1 : (a : List Bool) → SizeOf (L a)]\n (witnessBound : Polynomial ℕ) (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true),\n sizeOf { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n 1 + sizeOf witnessBound + sizeOf check_polyTime", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "SizeOf.sizeOf", - "PCP.NPCertificate", - "PCP.NPCertificate._sizeOf_inst", - "PCP.NPCertificate.mk", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "Polynomial._sizeOf_inst", - "instSizeOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": "Stop and accept (`true`) or reject (`false`). ", - "end_line": 35, - "is_class": false, - "kind": "constructor", - "line": 34, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf", - "provenance": "lean", - "structural_dependencies": [ - "PCP.QueryTree" - ], - "type": "{d : ℕ} → Bool → PCP.QueryTree d", - "type_dependencies": [ - "Nat", - "Bool", - "PCP.QueryTree" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Only the first `N` proof bits matter when `V.ReadsBelow x N`. ", - "end_line": 128, - "is_class": false, - "kind": "theorem", - "line": 121, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_congr_of_readsBelow", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) {N : ℕ},\n V.ReadsBelow x N → ∀ {π π' : PCP.ProofOracle}, (∀ a < N, π a = π' a) → V.accProb x π = V.accProb x π'", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Nat", - "PCP.Verifier.ReadsBelow", - "PCP.ProofOracle", - "LT.lt", - "instLTNat", - "Eq", - "Rat", - "PCP.Verifier.accProb" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match d + 1, PCP.QueryTree.query a f t with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_2 d a f t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.addresses.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "recursor", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → (t : PCP.Machine.Sym) → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": 52, - "is_class": false, - "kind": "theorem", - "line": 50, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodePair", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (p : List Bool × List Bool), (PCP.Machine.encodePair p).length = p.1.length + p.2.length + 1", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "Nat", - "List.length", - "PCP.Machine.Sym", - "PCP.Machine.encodePair", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 24, - "is_class": false, - "kind": "constructor", - "line": 24, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.sep", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Machine.Sym" - ], - "type": "PCP.Machine.Sym", - "type_dependencies": [ - "PCP.Machine.Sym" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u →\n {P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n PCP.NPCertificate P L →\n {P' : (List Bool → List Bool → Bool) → Prop} → {L' : PCP.Language} → PCP.NPCertificate P' L' → Sort u", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "PCP.NPCertificate.casesOn", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym → ℕ", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.Sym.casesOn", - "Nat", - "Bool" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (a b : Bool), ¬a = b → PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit b → False", - "type_dependencies": [ - "Bool", - "Not", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (a : Bool), PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit a", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk._flat_ctor", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.eq_def", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x),\n x_1.addresses =\n match x, x_1 with\n | x, PCP.QueryTree.leaf accept => ∅\n | .(d + 1), PCP.QueryTree.query a f t => insert a (f.addresses ∪ t.addresses)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "Finset", - "PCP.QueryTree.addresses", - "PCP.QueryTree.addresses.match_1", - "Bool", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk._flat_ctor", - "provenance": "lean", - "structural_dependencies": [], - "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "(a : ℕ) → SizeOf (PCP.QueryTree a)", - "type_dependencies": [ - "Nat", - "SizeOf", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "SizeOf.mk", - "PCP.QueryTree", - "PCP.QueryTree._sizeOf_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.ctorElim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (ctorIdx : ℕ) → (t : PCP.Machine.Sym) → ctorIdx = t.ctorIdx → PCP.Machine.Sym.ctorElimType ctorIdx → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "Eq", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.ctorElimType" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "Eq", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.ctorElimType", - "PCP.Machine.Sym.casesOn", - "Bool", - "PULift.down", - "PCP.Machine.Sym.bit", - "Eq.ndrec", - "PCP.Machine.Sym.sep" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The witness-checking relation. ", - "end_line": 34, - "is_class": false, - "kind": "definition", - "line": 34, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.check", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → List Bool → List Bool → Bool", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 23, - "is_class": false, - "kind": "definition", - "line": 23, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → t.ctorIdx = 0 → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "Bool", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (x : ℕ) (accept : Bool)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match x, PCP.QueryTree.leaf accept with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_1 x accept", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.addresses.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 85, - "is_class": false, - "kind": "definition", - "line": 85, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {randomness : ℕ → ℕ} →\n {queries : ℕ} →\n {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries} →\n {randomness' : ℕ → ℕ} →\n {queries' : ℕ} →\n {run' : (x : List Bool) → Fin (2 ^ randomness' x.length) → PCP.QueryTree queries'} →\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness', queries := queries', run := run' } →\n (randomness = randomness' → queries = queries' → run ≍ run' → P) → P", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "HEq" - ], - "value_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "HEq", - "id", - "PCP.Verifier.noConfusion" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": "Encoding of a verifier algorithm's answer. A halt decision is one bit; a query is the\nseparator followed by the address in binary. ", - "end_line": 45, - "is_class": false, - "kind": "definition", - "line": 41, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeAnswer", - "provenance": "lean", - "structural_dependencies": [], - "type": "Bool ⊕ ℕ → List PCP.Machine.Sym", - "type_dependencies": [ - "Sum", - "Bool", - "Nat", - "List", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Nat", - "PCP.Machine.encodeAnswer.match_1", - "List", - "PCP.Machine.Sym", - "List.cons", - "PCP.Machine.Sym.bit", - "List.nil", - "PCP.Machine.Sym.sep", - "PCP.Machine.ofBits", - "Nat.bits" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instFintypeSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "Fintype PCP.Machine.Sym", - "type_dependencies": [ - "Fintype", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Fintype.ofEquiv", - "PCP.Machine.Sym", - "Sum", - "Bool", - "Unit", - "instFintypeSum", - "Bool.fintype", - "PUnit.fintype", - "PCP.Machine.Sym.proxyTypeEquiv" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 79, - "is_class": false, - "kind": "definition", - "line": 79, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R} →\n {polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)} →\n {PolyTimeRel' : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg' : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable' : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel' R → Computable₂ R} →\n {polyTimeAlg_computable' :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg' alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck' :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg' alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel' (PCP.finiteWitnessCheck V)} →\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel', PolyTimeAlg := PolyTimeAlg',\n polyTimeRel_computable := polyTimeRel_computable',\n polyTimeAlg_computable := polyTimeAlg_computable',\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck' } →\n (PolyTimeRel = PolyTimeRel' → PolyTimeAlg = PolyTimeAlg' → P) → P", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk", - "id", - "PCP.CostModel.noConfusion" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "SizeOf PCP.Verifier", - "type_dependencies": [ - "SizeOf", - "PCP.Verifier" - ], - "value_dependencies": [ - "SizeOf.mk", - "PCP.Verifier", - "PCP.Verifier._sizeOf_1" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 107, - "is_class": false, - "kind": "theorem", - "line": 106, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_nonneg", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), 0 ≤ V.accProb x π", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "LE.le", - "Rat", - "Rat.instLE", - "OfNat.ofNat", - "Rat.instOfNat", - "PCP.Verifier.accProb" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → ℕ", - "type_dependencies": [ - "PCP.CostModel", - "Nat" - ], - "value_dependencies": [ - "PCP.CostModel" - ] - }, - { - "axioms": [], - "doc": "A bit string as tape symbols. ", - "end_line": 28, - "is_class": false, - "kind": "definition", - "line": 27, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.ofBits", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "List", - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "List", - "Bool", - "List.map", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ] - }, - { - "axioms": [], - "doc": "Run the decision tree against a proof oracle. ", - "end_line": 44, - "is_class": false, - "kind": "definition", - "line": 41, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "PCP.QueryTree.brecOn", - "Bool", - "PCP.QueryTree.eval._f" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "`V` is efficiently implementable in the model `M`. ", - "end_line": 115, - "is_class": false, - "kind": "definition", - "line": 114, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.Efficient", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → PCP.Verifier → Prop", - "type_dependencies": [ - "PCP.CostModel", - "PCP.Verifier" - ], - "value_dependencies": [ - "PCP.CostModel", - "PCP.Verifier", - "Exists", - "PCP.VerifierAlg", - "And", - "PCP.CostModel.PolyTimeAlg", - "PCP.Verifier.ImplementedBy" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "Bound on the number of proof **bits** read (bits, not larger proof symbols). ", - "end_line": 89, - "is_class": false, - "kind": "definition", - "line": 89, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.queries", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Prop) (x : ℕ) (x_1 : PCP.QueryTree x),\n (∀ (x : ℕ) (accept : Bool), motive x (PCP.QueryTree.leaf accept)) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d), motive d.succ (PCP.QueryTree.query a f t)) → motive x x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "Nat.succ", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "Nat.succ", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "Eq", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → PCP.CostModel → PCP.CostModel → Sort u", - "type_dependencies": [ - "PCP.CostModel" - ], - "value_dependencies": [ - "PCP.CostModel", - "PCP.CostModel.casesOn", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 50, - "is_class": false, - "kind": "theorem", - "line": 49, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep_zero", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (f : List Bool → Bool ⊕ ℕ) (as : List Bool),\n PCP.QueryTree.ofStep f 0 as =\n match f as with\n | Sum.inl b => PCP.QueryTree.leaf b\n | Sum.inr val => PCP.QueryTree.leaf false", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Eq", - "PCP.QueryTree", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.ofStep", - "PCP.QueryTree.ofStep.match_1", - "PCP.QueryTree.leaf", - "Bool.false" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Soundness: a polynomial-time relation is computable. ", - "end_line": 85, - "is_class": false, - "kind": "theorem", - "line": 85, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.polyTimeRel_computable", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (self : PCP.CostModel) (R : List Bool → List Bool → Bool), self.PolyTimeRel R → Computable₂ R", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.CostModel.PolyTimeRel", - "Computable₂", - "Primcodable.list", - "Primcodable.bool" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "Fair random bits used on inputs of length `n`. ", - "end_line": 87, - "is_class": false, - "kind": "definition", - "line": 87, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.randomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Closure: an efficiently implemented verifier with logarithmic randomness and a polynomial\nproof-length bound induces a polynomial-time NP checking relation.\n\nThis is the bridge between verifier efficiency and NP-checker efficiency.\nDischarging it means showing the model is closed under: enumerating `2 ^ O(log n)` random\nstrings, unfolding a constant-depth query tree, and indexing a polynomially long witness.\n\nThe budget hypothesis is `CanonicalRandomness`, **not** `LogRandomness`. With only an upper\nbound this field is not justifiable for any standard model: an arbitrary `f : ℕ → Bool` can be\nhidden in the budget (see `Verifier.LogRandomness`) and recovered by an elementary\nlength-measuring algorithm, so the field would assert that every unary language has a computable\nchecking relation. A canonical budget is determined by `a` and `b` and carries no such\ninformation. ", - "end_line": 104, - "is_class": false, - "kind": "theorem", - "line": 104, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.polyTimeRel_finiteWitnessCheck", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (self : PCP.CostModel) (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n self.PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → self.PolyTimeRel (PCP.finiteWitnessCheck V)", - "type_dependencies": [ - "PCP.CostModel", - "PCP.Verifier", - "PCP.VerifierAlg", - "Nat", - "Polynomial", - "Nat.instSemiring", - "PCP.CostModel.PolyTimeAlg", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "List", - "Bool", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.CostModel.PolyTimeRel", - "PCP.finiteWitnessCheck" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) →\n (x : ℕ) → Nat.below (motive := fun x => List Bool → PCP.QueryTree x) x → List Bool → PCP.QueryTree x", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Nat.below", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Nat.below", - "PCP.QueryTree", - "PCP.QueryTree.ofStep.match_3", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.ofStep.match_1", - "PCP.QueryTree.leaf", - "Bool.false", - "Nat.succ", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "PCP.QueryTree.query", - "PProd", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "List.cons", - "List.nil", - "Bool.true" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk", - "PCP.Verifier.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep._sunfold", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree.ofStep.match_3", - "PCP.QueryTree", - "PCP.QueryTree.ofStep.match_1", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.leaf", - "Bool.false", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "PCP.QueryTree.query", - "PCP.QueryTree.ofStep", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "List.cons", - "List.nil", - "Bool.true" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "`L` is in NP relative to the polynomial-time-checkability notion `P`. ", - "end_line": 43, - "is_class": false, - "kind": "definition", - "line": 41, - "module": "PCP.Complexity.NP", - "name": "PCP.InNP", - "provenance": "lean", - "structural_dependencies": [], - "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Prop", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Nonempty", - "PCP.NPCertificate" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 30, - "is_class": false, - "kind": "constructor", - "line": 30, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk", - "provenance": "lean", - "structural_dependencies": [ - "PCP.NPCertificate" - ], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", - "type_dependencies": [ - "Fintype", - "Eq", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "Finset.univ", - "True" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "SizeOf PCP.Machine.Sym", - "type_dependencies": [ - "SizeOf", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "SizeOf.mk", - "PCP.Machine.Sym", - "PCP.Machine.Sym._sizeOf_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 24, - "is_class": false, - "kind": "definition", - "line": 24, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.sep.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} → (t : PCP.Machine.Sym) → t.ctorIdx = 1 → motive PCP.Machine.Sym.sep → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 85, - "is_class": false, - "kind": "constructor", - "line": 85, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Verifier" - ], - "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "definition", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ], - "value_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk", - "PCP.CostModel.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.ProofOracle) (b : Bool), (PCP.QueryTree.leaf b).eval x_1 = b", - "type_dependencies": [ - "Nat", - "PCP.ProofOracle", - "Bool", - "Eq", - "PCP.QueryTree.eval", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval._unsafe_rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "PCP.QueryTree.eval.match_1", - "Bool", - "ite", - "Eq", - "Bool.true", - "instDecidableEqBool", - "PCP.QueryTree.eval._unsafe_rec" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (accept : Bool), (PCP.QueryTree.leaf accept).addresses = ∅", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "Finset", - "PCP.QueryTree.addresses", - "PCP.QueryTree.leaf", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (π : PCP.ProofOracle) (h_1 : (x : ℕ) → (b : Bool) → (x_1 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_1)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match d + 1, PCP.QueryTree.query a f t, π with\n | x, PCP.QueryTree.leaf b, x_1 => h_1 x b x_1\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_2 d a f t π", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.eval.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : PCP.ProofOracle) (d a : ℕ) (f t : PCP.QueryTree d),\n (PCP.QueryTree.query a f t).eval x = if x a = true then t.eval x else f.eval x", - "type_dependencies": [ - "PCP.ProofOracle", - "Nat", - "PCP.QueryTree", - "Eq", - "Bool", - "PCP.QueryTree.eval", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "ite", - "Bool.true", - "instDecidableEqBool" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b b_1 : Bool), (PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1) = (b = b_1)", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "The proof oracle determined by a finite witness: address `j` holds `w[j]`, and `false` at every\naddress beyond `w`. Padding with `false` is harmless exactly because a verifier satisfying\n`Verifier.ReadsBelow x N` never looks past address `N`. ", - "end_line": 201, - "is_class": false, - "kind": "definition", - "line": 198, - "module": "PCP.Verifier.Definition", - "name": "PCP.oracleOfWitness", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool → PCP.ProofOracle", - "type_dependencies": [ - "List", - "Bool", - "PCP.ProofOracle" - ], - "value_dependencies": [ - "List", - "Bool", - "Nat", - "List.getD", - "Bool.false" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "{a : ℕ} → PCP.QueryTree a → ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.rec", - "Bool", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "SizeOf.sizeOf", - "instSizeOfNat", - "Bool._sizeOf_inst" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval_congr.match_1_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀\n (motive :\n (x : ℕ) → (x_1 : PCP.QueryTree x) → (x_2 x_3 : PCP.ProofOracle) → (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → Prop)\n (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 x_3 : PCP.ProofOracle) (x_4 : ∀ a ∈ x_1.addresses, x_2 a = x_3 a),\n (∀ (x : ℕ) (accept : Bool) (x_5 x_6 : PCP.ProofOracle)\n (x_7 : ∀ a ∈ (PCP.QueryTree.leaf accept).addresses, x_5 a = x_6 a),\n motive x (PCP.QueryTree.leaf accept) x_5 x_6 x_7) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d) (π π' : PCP.ProofOracle)\n (h : ∀ a_1 ∈ (PCP.QueryTree.query a f t).addresses, π a_1 = π' a_1),\n motive (d + 1) (PCP.QueryTree.query a f t) π π' h) →\n motive x x_1 x_2 x_3 x_4", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "`alg` implements `V`: unfolding the algorithm reproduces `V`'s decision tree on every input and\nevery random string.\n\nThis ties the certificate to *this* verifier — its random-bit handling (`bitsOfFin`), its query\naddresses, and its decision rule all have to match. Proving some unrelated verifier efficient\nwould not discharge it. ", - "end_line": 64, - "is_class": false, - "kind": "definition", - "line": 56, - "module": "PCP.Complexity.CostModel", - "name": "PCP.Verifier.ImplementedBy", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → PCP.VerifierAlg → Prop", - "type_dependencies": [ - "PCP.Verifier", - "PCP.VerifierAlg" - ], - "value_dependencies": [ - "PCP.Verifier", - "PCP.VerifierAlg", - "List", - "Bool", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Eq", - "PCP.QueryTree", - "PCP.Verifier.queries", - "PCP.QueryTree.ofStep", - "PCP.bitsOfFin", - "List.nil", - "PCP.Verifier.run" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.below", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → {a : ℕ} → PCP.QueryTree a → Sort (max 1 u)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.rec", - "Bool", - "PUnit", - "PProd" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d),\n f.addresses.card < 2 ^ d →\n t.addresses.card < 2 ^ d →\n (insert a (f.addresses ∪ t.addresses)).card ≤ 1 + (f.addresses.card + t.addresses.card) →\n ¬(insert a (f.addresses ∪ t.addresses)).card < 2 ^ (d + 1) → False", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "LE.le", - "instLENat", - "Insert.insert", - "Finset", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Not", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses._unsafe_rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.addresses.match_1", - "Finset", - "Bool", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "PCP.QueryTree.addresses._unsafe_rec" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries),\n sizeOf { randomness := randomness, queries := queries, run := run } = 1 + sizeOf queries", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "SizeOf.sizeOf", - "PCP.Verifier", - "PCP.Verifier._sizeOf_inst", - "PCP.Verifier.mk", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "instSizeOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The relation defines `L`. ", - "end_line": 38, - "is_class": false, - "kind": "theorem", - "line": 38, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L) (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length self.witnessBound ∧ self.check x w = true", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Iff", - "Exists", - "And", - "LE.le", - "Nat", - "instLENat", - "List.length", - "Polynomial.eval", - "Nat.instSemiring", - "PCP.NPCertificate.witnessBound", - "Eq", - "PCP.NPCertificate.check", - "Bool.true" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "definition", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ], - "value_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk", - "PCP.CostModel.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "{a : ℕ} → PCP.QueryTree a → ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.casesOn", - "Bool" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "PCP.Verifier.rec", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "SizeOf.sizeOf", - "instSizeOfNat" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → PCP.Verifier → PCP.Verifier → Sort u", - "type_dependencies": [ - "PCP.Verifier" - ], - "value_dependencies": [ - "PCP.Verifier", - "PCP.Verifier.casesOn", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "HEq" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "SizeOf PCP.CostModel", - "type_dependencies": [ - "SizeOf", - "PCP.CostModel" - ], - "value_dependencies": [ - "SizeOf.mk", - "PCP.CostModel", - "PCP.CostModel._sizeOf_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → PCP.Machine.Sym → PCP.Machine.Sym → Sort u", - "type_dependencies": [ - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.Sym.casesOn", - "Bool", - "Eq" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym → ℕ", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.Sym.rec", - "Nat", - "Bool", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "SizeOf.sizeOf", - "Bool._sizeOf_inst" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "`V` reads only proof addresses below `N` on input `x`, whatever the randomness and whatever\nthe oracle answers. This is how \"a proof of polynomial length\" is expressed. ", - "end_line": 119, - "is_class": false, - "kind": "definition", - "line": 116, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.ReadsBelow", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → ℕ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "LT.lt", - "instLTNat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {b b_1 : Bool}, PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1 → b = b_1", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "recursor", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.CostModel → Sort u} →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n (t : PCP.CostModel) → motive t", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (witnessBound : Polynomial ℕ)\n (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true)\n (witnessBound_1 : Polynomial ℕ) (check_1 : List Bool → List Bool → Bool) (check_polyTime_1 : P check_1)\n (spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true),\n ({ witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 }) =\n (witnessBound = witnessBound_1 ∧ check = check_1)", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d) (addr_1 : ℕ) (onFalse_1 onTrue_1 : PCP.QueryTree d),\n (PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1) =\n (addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses._sunfold", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.addresses.match_1", - "Finset", - "Bool", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "PCP.QueryTree.addresses" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeTriple.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (t : List Bool × List Bool × List Bool),\n PCP.Machine.encodeTriple t =\n PCP.Machine.ofBits t.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.1 ++\n PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.2", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.encodeTriple", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.splitter", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "PCP.QueryTree.eval.match_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((val : ℕ) → motive (Sum.inr val)) → motive x", - "type_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr", - "Sum.casesOn" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (x : ℕ) (b : Bool) (x_1 : PCP.ProofOracle)\n (h_1 : (x : ℕ) → (b : Bool) → (x_2 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_2)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match x, PCP.QueryTree.leaf b, x_1 with\n | x, PCP.QueryTree.leaf b, x_2 => h_1 x b x_2\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_1 x b x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.eval.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instFintypeSym.match_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : Bool ⊕ Unit → Sort u_1) →\n (x : Bool ⊕ Unit) → ((a : Bool) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x", - "type_dependencies": [ - "Sum", - "Bool", - "Unit", - "Sum.inl", - "Sum.inr", - "PUnit.unit" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Unit", - "Sum.inl", - "Sum.inr", - "PUnit.unit", - "Sum.casesOn", - "PUnit.casesOn", - "Unit.unit" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = ↑(V.acceptingRandomness x π).card / 2 ^ V.randomness x.length", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Eq", - "Rat", - "PCP.Verifier.accProb", - "HDiv.hDiv", - "instHDiv", - "Rat.instDiv", - "Nat.cast", - "Rat.instNatCast", - "Finset.card", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.Verifier.acceptingRandomness", - "Rat.instPowNat", - "Rat.instOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 35, - "is_class": false, - "kind": "definition", - "line": 34, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 0 → ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "Bool", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "Bool", - "PCP.QueryTree.leaf", - "PCP.QueryTree.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} {witnessBound : Polynomial ℕ}\n {check : List Bool → List Bool → Bool} {check_polyTime : P check}\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true}\n {witnessBound_1 : Polynomial ℕ} {check_1 : List Bool → List Bool → Bool} {check_polyTime_1 : P check_1}\n {spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true},\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 } →\n witnessBound = witnessBound_1 ∧ check = check_1", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Acceptance probability is exactly `1` precisely when *every* random string accepts. This is\nthe bridge between the probabilistic statement of perfect completeness and the finite, decidable\ncondition used by the NP witness checker below. ", - "end_line": 188, - "is_class": false, - "kind": "theorem", - "line": 169, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_eq_one_iff", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = 1 ↔ ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval π = true", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Iff", - "Eq", - "Rat", - "PCP.Verifier.accProb", - "OfNat.ofNat", - "Rat.instOfNat", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "Bool.true" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 23, - "is_class": false, - "kind": "definition", - "line": 23, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {b b' : Bool} → PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b' → (b = b' → P) → P", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "id", - "PCP.Machine.Sym.noConfusion" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {t t' : PCP.Verifier} → t = t' → PCP.Verifier.noConfusionType P t t'", - "type_dependencies": [ - "PCP.Verifier", - "Eq", - "PCP.Verifier.noConfusionType" - ], - "value_dependencies": [ - "PCP.Verifier", - "Eq", - "Eq.ndrec", - "PCP.Verifier.noConfusionType", - "PCP.Verifier.casesOn", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "HEq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 31, - "is_class": false, - "kind": "theorem", - "line": 30, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_ofBits", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : List Bool), (PCP.Machine.ofBits x).length = x.length", - "type_dependencies": [ - "List", - "Bool", - "Eq", - "Nat", - "List.length", - "PCP.Machine.Sym", - "PCP.Machine.ofBits" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.rec" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (accept accept_1 : Bool), (PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1) = (accept = accept_1)", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "PCP.QueryTree", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "An oracle verifier.\n\nOn an input `x` of length `n` it draws `randomness n` fair bits and then runs the decision tree\nselected by that random string, making at most `queries` *bit* queries into the proof. ", - "end_line": 91, - "is_class": false, - "kind": "inductive", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Verifier.mk", - "PCP.Verifier" - ], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instInhabitedSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "Inhabited PCP.Machine.Sym", - "type_dependencies": [ - "Inhabited", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Inhabited.mk", - "PCP.Machine.Sym", - "PCP.Machine.instInhabitedSym.default" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep._unsafe_rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree.ofStep.match_3", - "PCP.QueryTree", - "PCP.QueryTree.ofStep.match_1", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.leaf", - "Bool.false", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "PCP.QueryTree.query", - "PCP.QueryTree.ofStep._unsafe_rec", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "List.cons", - "List.nil", - "Bool.true" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 222, - "is_class": false, - "kind": "theorem", - "line": 221, - "module": "PCP.Verifier.Definition", - "name": "PCP.length_witness_of_oracle", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (π : PCP.ProofOracle) (N : ℕ), (List.map π (List.range N)).length = N", - "type_dependencies": [ - "PCP.ProofOracle", - "Nat", - "Eq", - "List.length", - "Bool", - "List.map", - "List.range" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "recursor", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Verifier → Sort u} →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n (t : PCP.Verifier) → motive t", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "definition", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {t t' : PCP.CostModel} → t = t' → PCP.CostModel.noConfusionType P t t'", - "type_dependencies": [ - "PCP.CostModel", - "Eq", - "PCP.CostModel.noConfusionType" - ], - "value_dependencies": [ - "PCP.CostModel", - "Eq", - "Eq.ndrec", - "PCP.CostModel.noConfusionType", - "PCP.CostModel.casesOn", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq.refl" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "recursor", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n (t : PCP.NPCertificate P L) → motive t", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 214, - "is_class": false, - "kind": "theorem", - "line": 212, - "module": "PCP.Verifier.Definition", - "name": "PCP.finiteWitnessCheck_eq_true_iff", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w = true ↔\n ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Iff", - "Eq", - "PCP.finiteWitnessCheck", - "Bool.true", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "PCP.oracleOfWitness" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "DecidableEq PCP.Machine.Sym", - "type_dependencies": [ - "DecidableEq", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "PCP.Machine.instDecidableEqSym.decEq" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk._flat_ctor", - "provenance": "lean", - "structural_dependencies": [], - "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier" - ], - "value_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Binary relations on bit strings decidable in polynomial time. ", - "end_line": 81, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.PolyTimeRel", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → (List Bool → List Bool → Bool) → Prop", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool" - ], - "value_dependencies": [ - "PCP.CostModel" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a)", - "type_dependencies": [ - "DecidablePred", - "Finset", - "Eq", - "Membership.mem", - "SetLike.instMembership", - "Finset.instSetLike", - "Finset.filter", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 23, - "is_class": false, - "kind": "constructor", - "line": 23, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Machine.Sym" - ], - "type": "Bool → PCP.Machine.Sym", - "type_dependencies": [ - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.bitsOfFin.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), PCP.bitsOfFin k r = List.map (fun j => (↑r).testBit j) (List.range k)", - "type_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "Eq", - "List", - "Bool", - "PCP.bitsOfFin", - "List.map", - "Nat.testBit", - "Fin.val", - "List.range" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": "Encoding of an argument pair: `x`, separator, `w`. ", - "end_line": 35, - "is_class": false, - "kind": "definition", - "line": 33, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodePair", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool × List Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Prod", - "List", - "Bool", - "HAppend.hAppend", - "PCP.Machine.Sym", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b : Bool), PCP.Machine.Sym.bit b = PCP.Machine.Sym.sep → False", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_4", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b : Bool), PCP.Machine.Sym.sep = PCP.Machine.Sym.bit b → False", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.bit", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.ctorElim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n (ctorIdx : ℕ) →\n {a : ℕ} → (t : PCP.QueryTree a) → ctorIdx = t.ctorIdx → PCP.QueryTree.ctorElimType ctorIdx → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "PCP.QueryTree.ctorElimType" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "PCP.QueryTree.ctorElimType", - "PCP.QueryTree.casesOn", - "Bool", - "PULift.down", - "PCP.QueryTree.leaf", - "Eq.ndrec", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.splitter", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "PCP.QueryTree.addresses.match_1" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The relation is polynomial-time checkable. ", - "end_line": 36, - "is_class": false, - "kind": "theorem", - "line": 36, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.check_polyTime", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L), P self.check", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "PCP.NPCertificate.check" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 35, - "is_class": false, - "kind": "definition", - "line": 34, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {d : ℕ} →\n {accept : Bool} →\n {d' : ℕ} →\n {accept' : Bool} →\n d = d' → PCP.QueryTree.leaf accept ≍ PCP.QueryTree.leaf accept' → (d = d' → accept = accept' → P) → P", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "HEq", - "PCP.QueryTree", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [ - "Nat", - "Bool", - "Eq", - "HEq", - "PCP.QueryTree", - "PCP.QueryTree.leaf", - "id", - "PCP.QueryTree.noConfusion" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 36, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {d addr : ℕ} →\n {onFalse onTrue : PCP.QueryTree d} →\n {d' addr' : ℕ} →\n {onFalse' onTrue' : PCP.QueryTree d'} →\n d + 1 = d' + 1 →\n PCP.QueryTree.query addr onFalse onTrue ≍ PCP.QueryTree.query addr' onFalse' onTrue' →\n (d = d' → addr = addr' → onFalse ≍ onFalse' → onTrue ≍ onTrue' → P) → P", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "HEq", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "HEq", - "PCP.QueryTree.query", - "id", - "PCP.QueryTree.noConfusion" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V))\n (PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg_1 : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R)\n (polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)),\n ({ PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 }) =\n (PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1)", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 114, - "is_class": false, - "kind": "theorem", - "line": 109, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_le_one", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.accProb x π ≤ 1", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "LE.le", - "Rat", - "Rat.instLE", - "PCP.Verifier.accProb", - "OfNat.ofNat", - "Rat.instOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.rec" - ] - }, - { - "axioms": [], - "doc": "Encoding of an argument triple: input, random string, answers so far. ", - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 37, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeTriple", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool × List Bool × List Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Prod", - "List", - "Bool", - "HAppend.hAppend", - "PCP.Machine.Sym", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodeTriple._proof_1_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (t : List Bool × List Bool × List Bool),\n ¬t.1.length + (t.2.1.length + (t.2.2.length + 1) + 1) = t.1.length + t.2.1.length + t.2.2.length + 2 → False", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Not", - "Eq", - "Nat", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "List.length", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {t t' : PCP.Machine.Sym} → t = t' → PCP.Machine.Sym.noConfusionType P t t'", - "type_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "PCP.Machine.Sym.noConfusionType" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Eq.ndrec", - "PCP.Machine.Sym.noConfusionType", - "PCP.Machine.Sym.casesOn", - "Bool", - "Eq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.oracleOfWitness.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (w : List Bool) (j : ℕ), PCP.oracleOfWitness w j = w.getD j false", - "type_dependencies": [ - "List", - "Bool", - "Nat", - "Eq", - "PCP.oracleOfWitness", - "List.getD", - "Bool.false" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instFintypeSym.match_5", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : PCP.Machine.Sym → Sort u_1) →\n (x : PCP.Machine.Sym) → ((a : Bool) → motive (PCP.Machine.Sym.bit a)) → (Unit → motive PCP.Machine.Sym.sep) → motive x", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "Unit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "Unit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.casesOn", - "Unit.unit" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 31, - "is_class": false, - "kind": "theorem", - "line": 30, - "module": "PCP.Complexity.CostModel", - "name": "PCP.length_bitsOfFin", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), (PCP.bitsOfFin k r).length = k", - "type_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "Eq", - "List.length", - "Bool", - "PCP.bitsOfFin" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Soundness at `x` with error `s`: every proof is accepted with probability at most `s`. ", - "end_line": 134, - "is_class": false, - "kind": "definition", - "line": 133, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.SoundAt", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → ℚ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Rat" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Rat", - "PCP.ProofOracle", - "LE.le", - "Rat.instLE", - "PCP.Verifier.accProb" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "recursor", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n {a : ℕ} → (t : PCP.QueryTree a) → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} {accept accept_1 : Bool}, PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1 → accept = accept_1", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "PCP.QueryTree", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → ℕ", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Nat" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instReprSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "Repr PCP.Machine.Sym", - "type_dependencies": [ - "Repr", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Repr.mk", - "PCP.Machine.Sym", - "PCP.Machine.instReprSym.repr" - ] - }, - { - "axioms": [], - "doc": "A \"proxy type\" equivalent to `PCP.Machine.Sym` that is constructed from `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum`. See `PCP.Machine.Sym.proxyTypeEquiv` for the equivalence. (Generated by the `proxy_equiv%` elaborator.)", - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.proxyType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "Sum", - "Bool", - "Unit" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodePair._proof_1_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (p : List Bool × List Bool), ¬p.1.length + (p.2.length + 1) = p.1.length + p.2.length + 1 → False", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Not", - "Eq", - "Nat", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "List.length", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.ctorElimType", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → ℕ → Sort (max 1 u)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "cond", - "Nat.ble", - "PULift", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ] - }, - { - "axioms": [], - "doc": "One step of an adaptive verifier algorithm.\n\n`alg x r as` is given the input `x`, the random string `r` as a bit list, and the answer bits\nreceived so far (oldest first). It returns either `.inl b`, halting with decision `b`, or\n`.inr a`, naming the next proof address to query.\n\nThis is the algorithmic counterpart of `QueryTree`: a decision tree is what the algorithm *does*,\nthis is the algorithm itself, and a cost model measures the latter. ", - "end_line": 24, - "is_class": false, - "kind": "definition", - "line": 16, - "module": "PCP.Complexity.CostModel", - "name": "PCP.VerifierAlg", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (accept : Bool), sizeOf (PCP.QueryTree.leaf accept) = 1 + sizeOf d + sizeOf accept", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "SizeOf.sizeOf", - "PCP.QueryTree", - "PCP.QueryTree._sizeOf_inst", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "instSizeOfNat", - "Bool._sizeOf_inst" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {P_1 : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {t : PCP.NPCertificate P_1 L} →\n {P' : (List Bool → List Bool → Bool) → Prop} →\n {L' : PCP.Language} →\n {t' : PCP.NPCertificate P' L'} → P_1 = P' → L = L' → t ≍ t' → PCP.NPCertificate.noConfusionType P t t'", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Eq", - "HEq", - "PCP.NPCertificate.noConfusionType" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Eq", - "HEq", - "Eq.ndrec", - "PCP.NPCertificate.noConfusionType", - "PCP.NPCertificate.casesOn", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Bool.true", - "Eq.refl", - "eq_of_heq" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The random strings on which `V` accepts `x` given proof `π`. ", - "end_line": 99, - "is_class": false, - "kind": "definition", - "line": 97, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.acceptingRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "(V : PCP.Verifier) → (x : List Bool) → PCP.ProofOracle → Finset (Fin (2 ^ V.randomness x.length))", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Finset", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Finset.filter", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Eq", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "Bool.true", - "instDecidableEqBool", - "Finset.univ", - "Fin.fintype" - ] - }, - { - "axioms": [], - "doc": "Query proof address `addr`, then continue in `onFalse` or `onTrue`. ", - "end_line": 37, - "is_class": false, - "kind": "constructor", - "line": 36, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query", - "provenance": "lean", - "structural_dependencies": [ - "PCP.QueryTree" - ], - "type": "{d : ℕ} → ℕ → PCP.QueryTree d → PCP.QueryTree d → PCP.QueryTree (d + 1)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.rec" - ] - }, - { - "axioms": [], - "doc": "An equivalence between the \"proxy type\" `PCP.Machine.Sym.proxyType` and `PCP.Machine.Sym`. The proxy type is a reducible definition that represents the inductive type using `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum` (and whatever other inductive types appear within the inductive type), and the intended use is to define typeclass instances uses pre-existing instances on these. (Generated by the `proxy_equiv%` elaborator.)", - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.proxyTypeEquiv", - "provenance": "lean", - "structural_dependencies": [], - "type": "Bool ⊕ Unit ≃ PCP.Machine.Sym", - "type_dependencies": [ - "Equiv", - "Sum", - "Bool", - "Unit", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Equiv.mk", - "Sum", - "Bool", - "Unit", - "PCP.Machine.Sym", - "PCP.Machine.instFintypeSym.match_3", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.instFintypeSym.match_5", - "Sum.inl", - "Sum.inr", - "Unit.unit", - "Sum.casesOn", - "Eq", - "Eq.ndrec", - "Eq.refl", - "Eq.symm", - "PCP.Machine.Sym.casesOn" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.sep.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "sizeOf PCP.Machine.Sym.sep = 1", - "type_dependencies": [ - "Eq", - "Nat", - "SizeOf.sizeOf", - "PCP.Machine.Sym", - "PCP.Machine.Sym._sizeOf_inst", - "PCP.Machine.Sym.sep", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instInhabitedSym.default", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym", - "type_dependencies": [ - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "PCP.Machine.Sym.bit", - "Inhabited.default", - "Bool", - "instInhabitedBool" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "(x x_1 : PCP.Machine.Sym) → Decidable (x = x_1)", - "type_dependencies": [ - "PCP.Machine.Sym", - "Decidable", - "Eq" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.instDecidableEqSym.decEq.match_1", - "Decidable", - "Eq", - "Bool", - "dite", - "PCP.Machine.Sym.bit", - "instDecidableEqBool", - "Eq.ndrec", - "Decidable.isTrue", - "PCP.Machine.instDecidableEqSym.decEq._proof_1", - "Not", - "Decidable.isFalse", - "PCP.Machine.instDecidableEqSym.decEq._proof_2", - "PCP.Machine.Sym.sep", - "PCP.Machine.instDecidableEqSym.decEq._proof_3", - "PCP.Machine.instDecidableEqSym.decEq._proof_4", - "Unit", - "rfl" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d),\n sizeOf (PCP.QueryTree.query addr onFalse onTrue) = 1 + sizeOf d + sizeOf addr + sizeOf onFalse + sizeOf onTrue", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "SizeOf.sizeOf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree._sizeOf_inst", - "PCP.QueryTree.query", - "instSizeOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 30, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {P_1 : Sort u} →\n {witnessBound : Polynomial ℕ} →\n {check : List Bool → List Bool → Bool} →\n {check_polyTime : P check} →\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true} →\n {witnessBound' : Polynomial ℕ} →\n {check' : List Bool → List Bool → Bool} →\n {check_polyTime' : P check'} →\n {spec' :\n ∀ (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound' ∧ check' x w = true} →\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound', check := check', check_polyTime := check_polyTime',\n spec := spec' } →\n (witnessBound = witnessBound' → check = check' → P_1) → P_1", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk", - "id", - "PCP.NPCertificate.noConfusion", - "Eq.refl", - "heq_of_eq" - ] - }, - { - "axioms": [], - "doc": "A decision tree over a Boolean proof oracle, of depth at most `d`.\n\n`leaf` may occur at any depth, so `QueryTree d` is \"at most `d` queries\", not \"exactly `d`\". ", - "end_line": 37, - "is_class": false, - "kind": "inductive", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree", - "provenance": "lean", - "structural_dependencies": [ - "PCP.QueryTree.leaf", - "PCP.QueryTree.query", - "PCP.QueryTree" - ], - "type": "ℕ → Type", - "type_dependencies": [ - "Nat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "(x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n PCP.QueryTree.below (motive := fun x x_2 => PCP.ProofOracle → Bool) x_1 → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.eval.match_1", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "ite", - "Eq", - "Bool.true", - "instDecidableEqBool", - "PProd" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Soundness: a polynomial-time verifier algorithm is computable. This rules out a degenerate\nmodel that counts an arbitrary, even noncomputable, step function as efficient; such a model\nwould let a \"verifier\" decide the language outright. ", - "end_line": 89, - "is_class": false, - "kind": "theorem", - "line": 89, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.polyTimeAlg_computable", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (self : PCP.CostModel) (alg : PCP.VerifierAlg), self.PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2", - "type_dependencies": [ - "PCP.CostModel", - "PCP.VerifierAlg", - "PCP.CostModel.PolyTimeAlg", - "Computable", - "Prod", - "List", - "Bool", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.list", - "Primcodable.bool", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "Eq", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "The decision tree used on input `x` and random string `r`. ", - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 91, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.run", - "provenance": "lean", - "structural_dependencies": [], - "type": "(self : PCP.Verifier) → (x : List Bool) → Fin (2 ^ self.randomness x.length) → PCP.QueryTree self.queries", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.queries" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries)\n (randomness_1 : ℕ → ℕ) (queries_1 : ℕ)\n (run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1),\n ({ randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 }) =\n (randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1)", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "And", - "HEq" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.brecOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} → (t : PCP.QueryTree a) → ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PProd", - "PCP.QueryTree.brecOn.go" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → {a : ℕ} → PCP.QueryTree a → {a' : ℕ} → PCP.QueryTree a' → Sort u", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.casesOn", - "Bool", - "Eq", - "HEq" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval_congr._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x)\n (f :\n PCP.QueryTree.below (motive := fun x x_2 =>\n ∀ (x_3 x_4 : PCP.ProofOracle), (∀ a ∈ x_2.addresses, x_3 a = x_4 a) → x_2.eval x_3 = x_2.eval x_4) x_1)\n (x_2 x_3 : PCP.ProofOracle), (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → x_1.eval x_2 = x_1.eval x_3", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.eval" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.eval", - "PCP.QueryTree.eval_congr.match_1_1", - "PCP.QueryTree.leaf", - "rfl", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "of_eq_true", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "Eq.trans", - "Or", - "True", - "Finset.mem_insert._simp_1", - "congr", - "congrArg", - "eq_self", - "Finset.mem_union._simp_1", - "true_or", - "PProd", - "Eq.mpr", - "id", - "Iff.mpr", - "Not", - "Classical.or_iff_not_imp_left", - "False.elim", - "ite", - "Bool.true", - "instDecidableEqBool", - "congrFun'", - "ite_congr" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep.match_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : ℕ → List Bool → Sort u_1) →\n (x : ℕ) →\n (x_1 : List Bool) →\n ((as : List Bool) → motive 0 as) → ((n : ℕ) → (as : List Bool) → motive n.succ as) → motive x x_1", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "OfNat.ofNat", - "instOfNatNat", - "Nat.succ" - ], - "value_dependencies": [ - "Nat", - "List", - "Bool", - "OfNat.ofNat", - "instOfNatNat", - "Nat.succ", - "Nat.casesOn" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "(x : ℕ) → (x_1 : PCP.QueryTree x) → PCP.QueryTree.below x_1 → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "Finset", - "PCP.QueryTree.addresses.match_1", - "Bool", - "PCP.QueryTree.leaf", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "PProd" - ] - }, - { - "axioms": [], - "doc": "Encoding of a Boolean result. ", - "end_line": 48, - "is_class": false, - "kind": "definition", - "line": 47, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeBool", - "provenance": "lean", - "structural_dependencies": [], - "type": "Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "Bool", - "List", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Bool", - "List.cons", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "List.nil" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {a : ℕ} →\n {t : PCP.QueryTree a} → {a' : ℕ} → {t' : PCP.QueryTree a'} → a = a' → t ≍ t' → PCP.QueryTree.noConfusionType P t t'", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HEq", - "PCP.QueryTree.noConfusionType" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HEq", - "Eq.ndrec", - "PCP.QueryTree.noConfusionType", - "PCP.QueryTree.casesOn", - "Bool", - "Eq.refl", - "HEq.refl", - "eq_of_heq" - ] - }, - { - "axioms": [], - "doc": "The tape alphabet: a bit, or a separator between arguments.\n\nA separator is needed because the machine takes one input list, while our relations and algorithms\ntake two or three bit strings. Self-delimiting encodings would avoid it at the cost of a length\nprefix; a separator symbol is the simpler convention and is fixed here once. ", - "end_line": 25, - "is_class": false, - "kind": "inductive", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym" - ], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "name": "PCP.Algebraic.Hadamard.testQueries_length", - "module": "PCP.Algebraic.HadamardTest", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem testQueries_length (hr : 1 ≤ r) (s : TestRandomness t r) :\n (testQueries hr s).length = 2 * r + 4\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {t r : ℕ}", - "line": 89, - "end_line": 92, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "axioms": [], - "doc": null, - "end_line": 139, - "is_class": false, - "kind": "def", - "line": 137, - "module": "PCP.Algebraic.Hadamard", - "name": "PCP.Algebraic.Hadamard.linearEncode", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nnoncomputable def linearEncode (x : Fin t → ZMod 2) :\n (Fin t → ZMod 2) →ₗ[ZMod 2] ZMod 2 :=\n ∑ i, x i • LinearMap.proj i", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 180, - "is_class": false, - "kind": "theorem", - "line": 173, - "module": "PCP.Algebraic.Hadamard", - "name": "PCP.Algebraic.Hadamard.relativeDistance_linearEncode", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem relativeDistance_linearEncode (x y : Fin t → ZMod 2) (hxy : x ≠ y) :\n relativeDistance (linearEncode x) (linearEncode y) = (1 : ℚ) / 2", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 88, - "is_class": false, - "kind": "def", - "line": 82, - "module": "PCP.Reduction.FiniteBooleanConstraints", - "name": "PCP.Reduction.FiniteBooleanConstraints.clauses", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ndef clauses (relation : C → Pattern k → Bool) (scope : C → Fin k → V) :\n Clause C k → Fin 3 → Literal (Variable V C k)\n | (e, p, .inl (i, j)) => orGate (flagLiteral e p i.succ)\n (flagLiteral e p i.castSucc) (differenceLiteral scope e p i) j\n | (e, p, .inr j) => if j.val = 0 then\n ![negate (flagLiteral e p 0), .const false, .const false]\n else ![.const (relation e p), flagLiteral e p (Fin.last k), .const false]", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 62, - "is_class": false, - "kind": "theorem", - "line": 47, - "module": "PCP.Reduction.FiniteBooleanConstraints", - "name": "PCP.Reduction.FiniteBooleanConstraints.orGate_iff", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem orGate_iff (z x y : Literal W) (a : W → Bool) :\n (∀ j, ClauseHolds (orGate z x y j) a) ↔ z.eval a = (x.eval a || y.eval a)", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 64, - "is_class": false, - "kind": "def", - "line": 63, - "module": "PCP.Algebraic.SetMultilinear", - "name": "PCP.Algebraic.SetMultilinear.evaluationPoint", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ndef evaluationPoint (x : R) : Variables m c → R :=\n fun ij => x ^ ((ij.2 : ℕ) * m ^ (ij.1 : ℕ))", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 107, - "is_class": false, - "kind": "theorem", - "line": 101, - "module": "PCP.Algebraic.SetMultilinear", - "name": "PCP.Algebraic.SetMultilinear.eval_encode", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem eval_encode (P : Polynomial R) (hP : P.natDegree < m ^ c) (x : R) :\n MvPolynomial.eval (evaluationPoint m c x) (encode m c P) = P.eval x", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 32, - "is_class": false, - "kind": "abbrev", - "line": 32, - "module": "PCP.Algebraic.EncodedLineLowDegreeTest", - "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nabbrev Auxiliary (F σ : Type*) (m c t : ℕ) := Lines F σ → RowOracle F m c t", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 45, - "is_class": false, - "kind": "structure", - "line": 37, - "module": "PCP.Algebraic.ThreeColorVerifier", - "name": "PCP.Algebraic.ThreeColorVerifier.Proof", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nstructure Proof (F : Type*) (n m c t : ℕ) where\n color : Vertex F n → Coefficients t 3 → ZMod 2\n validCert : PairPoint F n → Coefficients t 1 → ZMod 2\n difference : PairPoint F n → Coefficients t 3 → ZMod 2\n properCert : ProperPoint F n → Coefficients t 1 → ZMod 2\n colorLines : EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t\n validLines : EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t\n differenceLines : EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t\n properLines : EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 136, - "is_class": false, - "kind": "inductive", - "line": 124, - "module": "PCP.Algebraic.ThreeColorVerifier", - "name": "PCP.Algebraic.ThreeColorVerifier.Query", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ninductive Query (F : Type*) (n m c t : ℕ) where\n | color : Vertex F n → Coefficients t 3 → Query F n m c t\n | validCert : PairPoint F n → Coefficients t 1 → Query F n m c t\n | difference : PairPoint F n → Coefficients t 3 → Query F n m c t\n | properCert : ProperPoint F n → Coefficients t 1 → Query F n m c t\n | colorLine : (Vertex F n × Vertex F n) → BinaryLocalCorrection.InnerPoint F m c →\n Coefficients t 1 → Query F n m c t\n | validLine : (PairPoint F n × PairPoint F n) → BinaryLocalCorrection.InnerPoint F m c →\n Coefficients t 1 → Query F n m c t\n | differenceLine : (PairPoint F n × PairPoint F n) → BinaryLocalCorrection.InnerPoint F m c →\n Coefficients t 1 → Query F n m c t\n | properLine : (ProperPoint F n × ProperPoint F n) → BinaryLocalCorrection.InnerPoint F m c →\n Coefficients t 1 → Query F n m c t", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 147, - "is_class": false, - "kind": "def", - "line": 139, - "module": "PCP.Algebraic.ThreeColorVerifier", - "name": "PCP.Algebraic.ThreeColorVerifier.read", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ndef read (π : Proof F n m c t) : Query F n m c t → ZMod 2\n | .color x q => π.color x q\n | .validCert x q => π.validCert x q\n | .difference x q => π.difference x q\n | .properCert x q => π.properCert x q\n | .colorLine uv x q => π.colorLines uv x q\n | .validLine uv x q => π.validLines uv x q\n | .differenceLine uv x q => π.differenceLines uv x q\n | .properLine uv x q => π.properLines uv x q", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 59, - "is_class": false, - "kind": "def", - "line": 45, - "module": "PCP.Algebraic.BinaryLocalCorrection", - "name": "PCP.Algebraic.BinaryLocalCorrection.run", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nnoncomputable def run (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → Coefficients t 1 → ZMod 2)\n (H : (σ → F) → RowOracle F m c t) (a b : σ → F) (z : Fˣ)\n (v : InnerPoint F m c) (w : Fin t → ZMod 2) (s : InnerSeed F m c t) :\n Option (ZMod 2) := by", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 151, - "is_class": false, - "kind": "theorem", - "line": 149, - "module": "PCP.Algebraic.SetMultilinear", - "name": "PCP.Algebraic.SetMultilinear.totalDegree_encode_le", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem totalDegree_encode_le (P : Polynomial R) :\n (encode m c P).totalDegree ≤ c", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "def", - "line": 84, - "module": "PCP.Algebraic.ThreeColorVerifier", - "name": "PCP.Algebraic.ThreeColorVerifier.BranchSeed", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ndef BranchSeed (F : Type*) [Monoid F] (n m c t : ℕ) : Fin 7 → Type _ :=\n ![EncodedLineLowDegreeTest.Sample F (Fin n) m c t 3,\n EncodedLineLowDegreeTest.Sample F (Fin n ⊕ Fin n) m c t 1,\n EncodedLineLowDegreeTest.Sample F (Fin n ⊕ Fin n) m c t 3,\n EncodedLineLowDegreeTest.Sample F (Fin (n + n) ⊕ Fin (n + n)) m c t 1,\n DerivedZeroOnGrid.TestSample F n m c t 3,\n DerivedZeroOnGrid.TestSample F (n + n) m c t 3,\n ((Vertex F n × Vertex F n) × (Fin t → ZMod 2))]", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 115, - "is_class": false, - "kind": "def", - "line": 97, - "module": "PCP.Algebraic.ThreeColorVerifier", - "name": "PCP.Algebraic.ThreeColorVerifier.branchTest", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nnoncomputable def branchTest (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → H))\n (π : Proof F n m c t) (i : Fin 7) : BranchSeed F n m c t i → Bool := by", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 121, - "is_class": false, - "kind": "def", - "line": 118, - "module": "PCP.Algebraic.ThreeColorVerifier", - "name": "PCP.Algebraic.ThreeColorVerifier.test", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nnoncomputable def test (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → H))\n (π : Proof F n m c t) : Sample F n m c t → Bool :=\n FiniteConjunction.test (branchTest ρ nodes ζ H G π)", - "type_dependencies": [], - "value_dependencies": [] - } - ] + "PCP.Algebraic.PointLineConstants.smallError" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) (a_2 : PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.color a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "One variable for each possible digit in each block. ", + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.Variables", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.PointLineTest.correction.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] {inst_4 : DecidableEq σ} [inst_5 : DecidableEq σ]\n (table table_1 : PCP.Algebraic.PointLineTest.LineTable F σ c),\n table = table_1 →\n ∀ (x x_1 : σ → F),\n x = x_1 → PCP.Algebraic.PointLineTest.correction table x = PCP.Algebraic.PointLineTest.correction table_1 x_1", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "Eq", + "PCP.Algebraic.PointLineTest.correction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Theorem B.1, with the witness bundled as an actual binary linear map. ", + "end_line": 318, + "is_class": false, + "kind": "theorem", + "line": 313, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.exists_linearMap_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (H : (ι → ZMod 2) → ZMod 2),\n ∃ L, PCP.Algebraic.relativeDistance H ⇑L ≤ PCP.Algebraic.BLR.rejectionProbability H", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Exists", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.rejectionProbability", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The linear map on the paper's actual domain of polynomials of degree at most `d`. ", + "end_line": 203, + "is_class": false, + "kind": "definition", + "line": 200, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] →\n (m : ℕ) →\n [NeZero m] →\n (c d : ℕ) → ↥(Polynomial.degreeLE R ↑d) →ₗ[R] MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Subtype", + "Polynomial", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearMap.comp", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.SetMultilinear.boundedEncode._proof_1", + "PCP.Algebraic.SetMultilinear.encode", + "Submodule.subtype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 435, + "is_class": false, + "kind": "theorem", + "line": 431, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 1 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.validCert π.validLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Sum", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "DecidableEq PCP.Machine.Sym", + "type_dependencies": [ + "DecidableEq", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "PCP.Machine.instDecidableEqSym.decEq" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Zero rejection characterizes exactly the codewords. ", + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 72, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.testRejectionRate_eq_zero_iff_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.testRejectionRate hr H = 0 ↔ ∃ x, H = ⇑(PCP.Algebraic.Hadamard.encode r x)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Iff", + "Eq", + "Rat", + "PCP.Algebraic.Hadamard.testRejectionRate", + "Rat.instOfNat", + "Exists", + "Fin", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every satisfying ternary assignment restricts to a solution of the original relations. ", + "end_line": 167, + "is_class": false, + "kind": "theorem", + "line": 157, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.satisfies_implies", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {k : ℕ} (relation : C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool)\n (scope : C → Fin k → V) (a : PCP.Reduction.FiniteBooleanConstraints.Variable V C k → Bool),\n PCP.Reduction.ThreeSATToColor.Satisfies (PCP.Reduction.FiniteBooleanConstraints.clauses relation scope) a →\n PCP.Reduction.FiniteBooleanConstraints.LocalHolds relation scope (a ∘ Sum.inl)", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.ThreeSATToColor.Satisfies", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.clauses", + "PCP.Reduction.FiniteBooleanConstraints.LocalHolds", + "Function.comp", + "Sum.inl", + "PCP.Reduction.FiniteBooleanConstraints.Aux" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_mul_right", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (c : ℚ) (f : α → ℚ),\n (PCP.Algebraic.BLR.average fun x => f x * c) = PCP.Algebraic.BLR.average f * c", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate_nodes._simp_1_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b ≠ 0) = (a ≠ b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "Ne", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 61, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Algebraic.Hadamard", + "name": "_private.PCP.Algebraic.Hadamard.0.PCP.Algebraic.Hadamard.add_nonzero_eq_zero_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : ZMod 2), b ≠ 0 → (a + b = 0 ↔ a ≠ 0)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Ne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Iff", + "Eq", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.negate.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{W : Type u_1} →\n (motive : PCP.Reduction.NAEThreeColor.Literal W → Sort u_2) →\n (x : PCP.Reduction.NAEThreeColor.Literal W) →\n ((b : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const b)) →\n ((v : W) → (b : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var v b)) → motive x", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.Literal.casesOn" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Option (ZMod 2) → Option (ZMod 2) → Option (ZMod 2) → Sort u_1) (x x_1 x_2 : Option (ZMod 2))\n (h_1 : (p m₀ mZ : ZMod 2) → motive (some p) (some m₀) (some mZ))\n (h_2 : (x x_3 x_4 : Option (ZMod 2)) → motive x x_3 x_4),\n (∀ (p m₀ mZ : ZMod 2), x = some p → x_1 = some m₀ → x_2 = some mZ → False) →\n (match x, x_1, x_2 with\n | some p, some m₀, some mZ => h_1 p m₀ mZ\n | x, x_4, x_5 => h_2 x x_4 x_5) =\n h_2 x x_1 x_2", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "False", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 270, + "is_class": false, + "kind": "definition", + "line": 269, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} → [Field F] → [Fintype F] → [DecidableEq F] → [Fintype σ] → [DecidableEq σ] → ℕ → F → ((σ → F) → F) → ℚ", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Rat" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "Pi.instFintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 53, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_add", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (f g : α → ℚ),\n (PCP.Algebraic.BLR.average fun x => f x + g x) = PCP.Algebraic.BLR.average f + PCP.Algebraic.BLR.average g", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 81, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n IsPrimitiveRoot ζ (Fintype.card F - 1) → ∀ (i : Fin (c + 1)), PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i ≠ 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Ne", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Binary relations on bit strings decidable in polynomial time. ", + "end_line": 81, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.PolyTimeRel", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → (List Bool → List Bool → Bool) → Prop", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool" + ], + "value_dependencies": [ + "PCP.CostModel" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 448, + "is_class": false, + "kind": "theorem", + "line": 444, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_three", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 3 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.properCert π.properLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Sum", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ) (a : ι → ZMod 2),\n PCP.Algebraic.BLR.fourier f a = PCP.Algebraic.BLR.average fun x => f x * PCP.Algebraic.BLR.character a x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "PCP.Algebraic.BLR.fourier._proof_1", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 442, + "is_class": false, + "kind": "theorem", + "line": 437, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_two", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 2 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.difference π.differenceLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Sum", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "Decidable.byContradiction", + "LE.le", + "instLENat", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 27, + "is_class": false, + "kind": "theorem", + "line": 24, + "module": "PCP.Algebraic.BLR", + "name": "_private.PCP.Algebraic.BLR.0.PCP.Algebraic.BLR.binary_cases", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : ZMod 2), b = 0 ∨ b = 1", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Or", + "Eq", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The exponent vector of a basis image. ", + "end_line": 159, + "is_class": false, + "kind": "definition", + "line": 157, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents", + "provenance": "lean", + "structural_dependencies": [], + "type": "(m : ℕ) → [NeZero m] → (c : ℕ) → ℕ → PCP.Algebraic.SetMultilinear.Variables m c →₀ ℕ", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.sum", + "Fin", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "Finsupp.single", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Formal polynomial recovery. The exponent bound is essential. ", + "end_line": 98, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c → (PCP.Algebraic.SetMultilinear.decode m c) ((PCP.Algebraic.SetMultilinear.encode m c) P) = P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "LinearMap", + "RingHom.id", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Substitute powers of `Y` for the block variables, before evaluating `Y`. ", + "end_line": 69, + "is_class": false, + "kind": "definition", + "line": 66, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] → (m c : ℕ) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R →+* Polynomial R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial.eval₂Hom", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.SetMultilinear.Variables", + "Polynomial.commSemiring", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.semiring", + "Polynomial.X", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.linear", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} → PCP.Algebraic.Hadamard.TestRandomness t r → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Prod.fst", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Prod.snd", + "Prod" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 3", + "type_dependencies": [ + "LE.le", + "Nat", + "instLENat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 94, + "is_class": false, + "kind": "theorem", + "line": 94, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.flag_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {k : ℕ} (x p : PCP.Reduction.FiniteBooleanConstraints.Pattern k),\n PCP.Reduction.FiniteBooleanConstraints.flag x p 0 = false", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Eq", + "Bool", + "PCP.Reduction.FiniteBooleanConstraints.flag", + "OfNat.ofNat", + "instOfNatNat", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Encoding an ordinary finite graph gives the intended completeness statement. ", + "end_line": 63, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.completeAt_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (G : SimpleGraph (Fin N)) [inst : DecidableRel G.Adj],\n G.Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CompleteAt (PCP.Algebraic.ThreeColorEncoding.encode G)", + "type_dependencies": [ + "Nat", + "SimpleGraph", + "Fin", + "DecidableRel", + "SimpleGraph.Adj", + "SimpleGraph.Colorable", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.CompleteAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "PCP.Algebraic.ThreeColorEncoding.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.bitsOfFin.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), PCP.bitsOfFin k r = List.map (fun j => (↑r).testBit j) (List.range k)", + "type_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "List", + "Bool", + "PCP.bitsOfFin", + "List.map", + "Nat.testBit", + "Fin.val", + "List.range" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Encoding of an argument pair: `x`, separator, `w`. ", + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodePair", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool × List Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Prod", + "List", + "Bool", + "HAppend.hAppend", + "PCP.Machine.Sym", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The relation is polynomial-time checkable. ", + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.check_polyTime", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L), P self.check", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "PCP.NPCertificate.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n PCP.Algebraic.SetMultilinear.encode m c = PCP.Algebraic.SetMultilinear.encode m c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False", + "type_dependencies": [ + "Zero", + "OfNat", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "NeZero", + "Eq", + "Zero.toOfNat0", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {d : ℕ} →\n {accept : Bool} →\n {d' : ℕ} →\n {accept' : Bool} →\n d = d' → PCP.QueryTree.leaf accept ≍ PCP.QueryTree.leaf accept' → (d = d' → accept = accept' → P) → P", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "HEq", + "PCP.QueryTree", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [ + "Nat", + "Bool", + "Eq", + "HEq", + "PCP.QueryTree", + "PCP.QueryTree.leaf", + "id", + "PCP.QueryTree.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.smallError_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 < PCP.Algebraic.GeneratorLowDegreeTest.smallError c", + "type_dependencies": [ + "Nat", + "LT.lt", + "Rat", + "Rat.instLT", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.GeneratorLowDegreeTest.smallError" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) →\n ((color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t) →\n (validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t) →\n (properLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t) →\n motive\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines }) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {d addr : ℕ} →\n {onFalse onTrue : PCP.QueryTree d} →\n {d' addr' : ℕ} →\n {onFalse' onTrue' : PCP.QueryTree d'} →\n d + 1 = d' + 1 →\n PCP.QueryTree.query addr onFalse onTrue ≍ PCP.QueryTree.query addr' onFalse' onTrue' →\n (d = d' → addr = addr' → onFalse ≍ onFalse' → onTrue ≍ onTrue' → P) → P", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HEq", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HEq", + "PCP.QueryTree.query", + "id", + "PCP.QueryTree.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The tester constructs a nearby field function and an actual formal line table,\nwith point-line rejection controlled by its own rejection. No smallness is needed here. ", + "end_line": 319, + "is_class": false, + "kind": "theorem", + "line": 243, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.exists_decoded_table", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n ∃ g T,\n PCP.Algebraic.relativeDistance (fun p => f p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ (g x)) ≤\n 28 * PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ (g x)))) ≤\n 28 * PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ∧\n PCP.Algebraic.PointLineTest.rejectionRate g T ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Exists", + "PCP.Algebraic.PointLineTest.LineTable", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "And", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 114, + "is_class": false, + "kind": "theorem", + "line": 109, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_le_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.accProb x π ≤ 1", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Verifier.accProb", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The reduced product queried in the `k+2` iteration. ", + "end_line": 54, + "is_class": false, + "kind": "definition", + "line": 52, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.productQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} →\n PCP.Algebraic.Hadamard.TestRandomness t r → Fin (r - 1) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.mixedProduct", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.Hadamard.TestRandomness.productDegree_le", + "PCP.Algebraic.Hadamard.TestRandomness.linear", + "PCP.Algebraic.Hadamard.TestRandomness.factor" + ] + }, + { + "axioms": [], + "doc": "Encoding of an argument triple: input, random string, answers so far. ", + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeTriple", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool × List Bool × List Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Prod", + "List", + "Bool", + "HAppend.hAppend", + "PCP.Machine.Sym", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r), PCP.Algebraic.Hadamard.homogeneousIndex hr = PCP.Algebraic.Hadamard.homogeneousIndex hr", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.homogeneousIndex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "The actual three-literal formula for the supplied family of local relations. ", + "end_line": 88, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.clauses", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {k : ℕ} →\n (C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool) →\n (C → Fin k → V) →\n PCP.Reduction.FiniteBooleanConstraints.Clause C k →\n Fin 3 → PCP.Reduction.NAEThreeColor.Literal (PCP.Reduction.FiniteBooleanConstraints.Variable V C k)", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.Variable" + ], + "value_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.clauses.match_1", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.orGate", + "PCP.Reduction.FiniteBooleanConstraints.flagLiteral", + "Fin.succ", + "Fin.castSucc", + "PCP.Reduction.FiniteBooleanConstraints.differenceLiteral", + "ite", + "Eq", + "Fin.val", + "instDecidableEqNat", + "Matrix.vecCons", + "PCP.Reduction.FiniteBooleanConstraints.negate", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.instOfNat", + "PCP.Reduction.FiniteBooleanConstraints.clauses._proof_1", + "PCP.Reduction.NAEThreeColor.Literal.const", + "Bool.false", + "Matrix.vecEmpty", + "Fin.last" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 31, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Complexity.CostModel", + "name": "PCP.length_bitsOfFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), (PCP.bitsOfFin k r).length = k", + "type_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "List.length", + "Bool", + "PCP.bitsOfFin" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness at `x` with error `s`: every proof is accepted with probability at most `s`. ", + "end_line": 134, + "is_class": false, + "kind": "definition", + "line": 133, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.SoundAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → ℚ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Rat" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Rat", + "PCP.ProofOracle", + "LE.le", + "Rat.instLE", + "PCP.Verifier.accProb" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 383, + "is_class": false, + "kind": "definition", + "line": 383, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeTestSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n [Fintype F] → [DecidableEq F] → {k r : ℕ} → Fintype (PCP.Algebraic.DerivedZeroOnGrid.TestSample F k m c t r)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Fin", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.ThreeColorVerifier.instFintypeGridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "recursor", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n {a : ℕ} → (t : PCP.QueryTree a) → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n {inst_3 : DecidableEq F} [inst_4 : DecidableEq F] [inst_5 : Fintype σ] {inst_6 : DecidableEq σ}\n [inst_7 : DecidableEq σ] (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (nodes nodes_1 : Fin (c + 1) → F),\n nodes = nodes_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (f f_1 : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n f = f_1 →\n ∀ (H H_1 : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t),\n H = H_1 →\n ∀ (a a_1 : σ → F),\n a = a_1 →\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a =\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ_1 nodes_1 ζ_1 f_1 H_1 a_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 143, + "is_class": false, + "kind": "definition", + "line": 143, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n [Fintype F] → [Fintype σ] → [DecidableEq σ] → Fintype (PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "instFintypeProd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 109, + "is_class": false, + "kind": "theorem", + "line": 100, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.flag_eq_false_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {k : ℕ} (x p : PCP.Reduction.FiniteBooleanConstraints.Pattern k),\n PCP.Reduction.FiniteBooleanConstraints.flag x p k = false ↔ x = p", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Iff", + "Eq", + "Bool", + "PCP.Reduction.FiniteBooleanConstraints.flag", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} {accept accept_1 : Bool}, PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1 → accept = accept_1", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "PCP.QueryTree", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properGridQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3) →\n ((x : Fin (n + n) → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((fst : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F (n + n)) →\n (x : Fin (n + n) ⊕ Fin (n + n) → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (fst, Sum.inl (x, q)))) →\n ((a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F (n + n)) →\n (b : Fin (n + n) ⊕ Fin (n + n) → F) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr (a, Sum.inr (b, x, q)))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes_injective._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [inst : Fintype F],\n 2 * c < Fintype.card F → ∀ ⦃i : Fin (c + 1)⦄, 1 < Fintype.card F → ¬↑i < Fintype.card F - 1 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "Fin.val", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Nat" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Read one indexed primary or auxiliary bit. ", + "end_line": 84, + "is_class": false, + "kind": "definition", + "line": 80, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1", + "Prod", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 242, + "is_class": false, + "kind": "theorem", + "line": 225, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F} [Finite σ],\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : (σ → F) → F),\n (∀ (u v : σ → F), f u = PCP.Algebraic.GeneratorLowDegreeTest.correct c ζ f u v) →\n ∃ P, P.totalDegree ≤ c ∧ ∀ (x : σ → F), (MvPolynomial.eval x) P = f x", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Finite", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.correct", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → ℕ → Sort (max 1 u)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "cond", + "Nat.ble", + "PULift", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual normalized rejection over the complete finite seed. ", + "end_line": 149, + "is_class": false, + "kind": "definition", + "line": 145, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n [Fintype F] →\n [Fintype σ] →\n [DecidableEq σ] →\n 1 ≤ r →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample", + "instDecidableEqBool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The homogeneous-linear variant of the element distance identity. ", + "end_line": 180, + "is_class": false, + "kind": "theorem", + "line": 172, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_linearEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x y : Fin t → ZMod 2),\n x ≠ y →\n PCP.Algebraic.relativeDistance ⇑(PCP.Algebraic.Hadamard.linearEncode x) ⇑(PCP.Algebraic.Hadamard.linearEncode y) =\n 1 / 2", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Ne", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "One step of an adaptive verifier algorithm.\n\n`alg x r as` is given the input `x`, the random string `r` as a bit list, and the answer bits\nreceived so far (oldest first). It returns either `.inl b`, halting with decision `b`, or\n`.inr a`, naming the next proof address to query.\n\nThis is the algorithmic counterpart of `QueryTree`: a decision tree is what the algorithm *does*,\nthis is the algorithm itself, and a cost model measures the latter. ", + "end_line": 24, + "is_class": false, + "kind": "definition", + "line": 16, + "module": "PCP.Complexity.CostModel", + "name": "PCP.VerifierAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "constructor", + "line": 131, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 105, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] [Nonempty α] (f g : α → ZMod 2),\n (PCP.Algebraic.BLR.average fun x => PCP.Algebraic.BLR.sign (f x) * PCP.Algebraic.BLR.sign (g x)) =\n 1 - 2 * PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.average", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.sign", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "ZMod.decidableEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The concrete three-color graph for a family of fixed-arity Boolean constraints. ", + "end_line": 198, + "is_class": false, + "kind": "definition", + "line": 196, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.graph", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {k : ℕ} →\n (C → PCP.Reduction.FiniteBooleanConstraints.Pattern k → Bool) →\n (C → Fin k → V) →\n SimpleGraph\n (PCP.Reduction.NAEThreeColor.Vertex\n (PCP.Reduction.FiniteBooleanConstraints.Variable V C k ⊕\n PCP.Reduction.FiniteBooleanConstraints.Clause C k)\n (PCP.Reduction.FiniteBooleanConstraints.Clause C k × Bool))", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "SimpleGraph", + "PCP.Reduction.NAEThreeColor.Vertex", + "Sum", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "Prod" + ], + "value_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Bool", + "Fin", + "PCP.Reduction.ThreeSATToColor.graph", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "PCP.Reduction.FiniteBooleanConstraints.clauses" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)),\n 5 * ((H.card - 1) * n) < m ^ c →\n ∀ (P : MvPolynomial (Fin n) F) (MVal : MvPolynomial (Fin n ⊕ Fin n) F)\n (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n MVal.totalDegree ≤ 3 * ((H.card - 1) * n) → ¬MVal.totalDegree < m ^ c → False", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.productDegree_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {r : ℕ} (k : Fin (r - 1)), ¬1 + (↑k + 1) ≤ r → False", + "type_dependencies": [ + "Nat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.flag.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {k : ℕ} (x p : PCP.Reduction.FiniteBooleanConstraints.Pattern k) (n : ℕ),\n PCP.Reduction.FiniteBooleanConstraints.flag x p n =\n (List.range n).any fun j => if hj : j < k then x ⟨j, hj⟩ ^^ p ⟨j, hj⟩ else false", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "Eq", + "Bool", + "PCP.Reduction.FiniteBooleanConstraints.flag", + "List.any", + "List.range", + "dite", + "LT.lt", + "instLTNat", + "Nat.decLt", + "Bool.xor", + "Fin.mk", + "Not", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 45, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.readsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.ReadsBelow x\n (Polynomial.eval x.length PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "Polynomial.eval", + "Nat", + "Nat.instSemiring", + "List.length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 33, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_empty", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (i : σ), PCP.Algebraic.GridVanishing.coordinate ∅ i = 1", + "type_dependencies": [ + "CommRing", + "Eq", + "MvPolynomial", + "CommRing.toCommSemiring", + "PCP.Algebraic.GridVanishing.coordinate", + "EmptyCollection.emptyCollection", + "Finset", + "Finset.instEmptyCollection", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidAlgebra.zero", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 469, + "is_class": false, + "kind": "theorem", + "line": 460, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_five", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 5 =\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ\n (fun x => PCP.Algebraic.HadamardDerivedOracle.weightedCubic (PCP.Algebraic.ThreeColorVerifier.edgeValue H G x)) ⋯\n nodes ζ H (PCP.Algebraic.ThreeColorVerifier.flatDifference π) π.properCert\n (PCP.Algebraic.ThreeColorVerifier.properAuxiliary π)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_weightedCubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 458, + "is_class": false, + "kind": "theorem", + "line": 450, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_four", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 4 =\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ (fun x => PCP.Algebraic.HadamardDerivedOracle.cubic) ⋯ nodes ζ H\n π.color π.validCert (PCP.Algebraic.ThreeColorVerifier.validAuxiliary π)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_cubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testAccepts.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H H_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n H = H_1 →\n ∀ (s s_1 : PCP.Algebraic.Hadamard.TestRandomness t r),\n s = s_1 → PCP.Algebraic.Hadamard.testAccepts hr H s = PCP.Algebraic.Hadamard.testAccepts hr H_1 s_1", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Eq", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.Hadamard.testAccepts" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.sep.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "sizeOf PCP.Machine.Sym.sep = 1", + "type_dependencies": [ + "Eq", + "Nat", + "SizeOf.sizeOf", + "PCP.Machine.Sym", + "PCP.Machine.Sym._sizeOf_inst", + "PCP.Machine.Sym.sep", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "definition", + "line": 44, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Sum", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.decodedAt.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (Q : (σ → F) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F)\n (parameter : Fˣ → F) (s : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n PCP.Algebraic.BinaryLocalCorrection.decodedAt ρ Q parameter s =\n (PCP.Algebraic.Hadamard.linearEncode\n (ρ (Polynomial.eval (parameter s.2.1) ((PCP.Algebraic.SetMultilinear.decode m c) (Q s.1)))))\n s.2.2.1.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.decodedAt", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A nonzero binary additive functional is one on exactly half the domain. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 77, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_addHom_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : AddCommGroup V] [inst_1 : Fintype V] (L : V →+ ZMod 2) (e : V),\n L e ≠ 0 → PCP.Algebraic.relativeDistance (⇑L) 0 = 1 / 2", + "type_dependencies": [ + "AddCommGroup", + "Fintype", + "AddMonoidHom", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "AddMonoidWithOne.toAddMonoid", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Ne", + "DFunLike.coe", + "AddMonoidHom.instFunLike", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "ZMod.decidableEq", + "Pi.instZero", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instInhabitedSym.default", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym", + "type_dependencies": [ + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "PCP.Machine.Sym.bit", + "Inhabited.default", + "Bool", + "instInhabitedBool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ f H s =\n (PCP.Algebraic.Hadamard.test hr (f s.1.1) s.2.2.2.1 &&\n PCP.Algebraic.BinaryLowDegreeTest.test PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1 ρ nodes (H s.1)\n s.2.2.2.2 &&\n decide\n (PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H s =\n f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2.2.1.2)))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "Bool.and", + "PCP.Algebraic.Hadamard.test", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "Decidable.decide", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t : ℕ} {σ : Type u_2},\n PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv =\n { toFun := fun s => (s.2.1, s.2.2.1, (s.2.2.2.1, s.1), s.2.2.2.2),\n invFun := fun s => (s.2.2.1.2, s.1, s.2.1, s.2.2.1.1, s.2.2.2), left_inv := ⋯, right_inv := ⋯ }", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "Equiv", + "Prod", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv", + "Equiv.mk", + "Prod.mk", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_2" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A uniform finite average; the empty-domain average is zero. ", + "end_line": 49, + "is_class": false, + "kind": "definition", + "line": 47, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average", + "provenance": "lean", + "structural_dependencies": [], + "type": "{α : Type u_1} → [Fintype α] → (α → ℚ) → ℚ", + "type_dependencies": [ + "Fintype", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "Rat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.distance_sample_comparison", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] {A : Type u_3} [inst_5 : DecidableEq A]\n (k l : (σ → F) × Fˣ → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k (s.1, s.2.1) s.2.2.1.2) fun s => l (s.1, s.2.1) s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "instFintypeProd", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 250, + "is_class": false, + "kind": "theorem", + "line": 244, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_properGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.properGridQuery q) =\n PCP.Algebraic.DerivedZeroOnGrid.read (PCP.Algebraic.ThreeColorVerifier.flatDifference π) π.properCert\n (PCP.Algebraic.ThreeColorVerifier.properAuxiliary π) q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery", + "PCP.Algebraic.DerivedZeroOnGrid.read", + "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "constructor", + "line": 133, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A supplied anchor table is exactly the paper's generator table. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → {c : ℕ} → [Fintype F] → (Fin (c + 1) → F) → Prop", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Exists", + "And", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.base", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} → PCP.Algebraic.Hadamard.TestRandomness t r → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Prod.fst", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_const._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] [Nonempty α], (Fintype.card α = 0) = False", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Eq", + "Nat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Per-branch query budgets in the same order as `BranchSeed`. ", + "end_line": 320, + "is_class": false, + "kind": "definition", + "line": 318, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueryBound", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Fin 7 → ℕ", + "type_dependencies": [ + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "Matrix.vecCons", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Matrix.vecEmpty" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : ZMod 2), PCP.Algebraic.BLR.sign b = if b = 0 then 1 else -1", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.sign", + "ite", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "ZMod.decidableEq", + "Rat.instOfNat", + "Neg.neg", + "Rat.instNeg" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n PCP.QueryTree.below (motive := fun x x_2 => PCP.ProofOracle → Bool) x_1 → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.eval.match_1", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "ite", + "Eq", + "Bool.true", + "instDecidableEqBool", + "PProd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Full coefficient-oracle proximity suffices, with the factor two for homogeneous labels. ", + "end_line": 356, + "is_class": false, + "kind": "theorem", + "line": 333, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le_full_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {D : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) {δ : ℚ},\n PCP.Algebraic.relativeDistance (fun p => f p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction 1 fun x => ρ ((MvPolynomial.eval x) P)) ≤\n δ →\n ∀ (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a)\n fun s =>\n some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2.2.1.2)) ≤\n PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a +\n 2 * δ +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "Option.instDecidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 141, + "is_class": false, + "kind": "definition", + "line": 141, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instNonemptyInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F] {m c : ℕ}, Nonempty (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The unique prefix-comparison values supply all auxiliary bits explicitly. ", + "end_line": 171, + "is_class": false, + "kind": "definition", + "line": 169, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "PCP.Reduction.FiniteBooleanConstraints.extend", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} → {k : ℕ} → (C → Fin k → V) → (V → Bool) → PCP.Reduction.FiniteBooleanConstraints.Variable V C k → Bool", + "type_dependencies": [ + "Nat", + "Fin", + "Bool", + "PCP.Reduction.FiniteBooleanConstraints.Variable" + ], + "value_dependencies": [ + "Nat", + "Fin", + "Bool", + "Sum.elim", + "PCP.Reduction.FiniteBooleanConstraints.Aux", + "PCP.Reduction.FiniteBooleanConstraints.flag", + "Prod.fst", + "Prod", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Prod.snd", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n t : ℕ} →\n (motive : PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3 → Sort u_2) →\n (x : PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3) →\n ((x : Fin n → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inr (x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "Sum", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "Sum", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.TestRandomness.factorQuery.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (s : PCP.Algebraic.Hadamard.TestRandomness t r) (k : Fin (r - 1)),\n s.factorQuery k = (PCP.Algebraic.BinaryPolynomialSpace.embed ⋯) (s.factor k)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.Hadamard.TestRandomness", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.Hadamard.TestRandomness.factorQuery", + "DFunLike.coe", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.embed", + "PCP.Algebraic.Hadamard.TestRandomness.factorDegree_le", + "PCP.Algebraic.Hadamard.TestRandomness.factor" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (a_2 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries)\n (randomness_1 : ℕ → ℕ) (queries_1 : ℕ)\n (run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1),\n ({ randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 }) =\n (randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1)", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "And", + "HEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ), 0 < n → n ≤ c + 1 → ¬n - 1 < c + 1 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A decision really uses only the locations in the declared query list. ", + "end_line": 118, + "is_class": false, + "kind": "theorem", + "line": 99, + "module": "PCP.Algebraic.HadamardTest", + "name": "PCP.Algebraic.Hadamard.testAccepts_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (s : PCP.Algebraic.Hadamard.TestRandomness t r)\n (H H' : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n (∀ p ∈ PCP.Algebraic.Hadamard.testQueries hr s, H p = H' p) →\n (PCP.Algebraic.Hadamard.testAccepts hr H s ↔ PCP.Algebraic.Hadamard.testAccepts hr H' s)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.Hadamard.testQueries", + "Eq", + "Iff", + "PCP.Algebraic.Hadamard.testAccepts" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "definition", + "line": 43, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Sum", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a =\n PCP.Algebraic.AffineLineSampling.fraction fun s =>\n PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a s = none", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Eq", + "Rat", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "PCP.Algebraic.AffineLineSampling.fraction", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_2", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.brecOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} → (t : PCP.QueryTree a) → ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PProd", + "PCP.QueryTree.brecOn.go" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : Type u_1) (motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u_2) (a : V) (a_1 : Bool)\n (h_1 : (a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a))\n (h_2 : (a : V) → (a_2 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_2)),\n (match PCP.Reduction.NAEThreeColor.Literal.var a a_1 with\n | PCP.Reduction.NAEThreeColor.Literal.const a => h_1 a\n | PCP.Reduction.NAEThreeColor.Literal.var a a_2 => h_2 a a_2) =\n h_2 a a_1", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Eq", + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → {a : ℕ} → PCP.QueryTree a → {a' : ℕ} → PCP.QueryTree a' → Sort u", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.casesOn", + "Bool", + "Eq", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 212, + "is_class": false, + "kind": "theorem", + "line": 205, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_boundedEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c →\n ∀ (P : ↥(Polynomial.degreeLE R ↑d)),\n (PCP.Algebraic.SetMultilinear.decode m c) ((PCP.Algebraic.SetMultilinear.boundedEncode m c d) P) = ↑P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "LinearMap", + "RingHom.id", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.boundedEncode", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.FiniteBooleanConstraints", + "name": "_private.PCP.Reduction.FiniteBooleanConstraints.0.PCP.Reduction.FiniteBooleanConstraints.negate.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{W : Type u_1} →\n (motive : PCP.Reduction.NAEThreeColor.Literal W → Sort u_2) →\n (x : PCP.Reduction.NAEThreeColor.Literal W) →\n ((b : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const b)) →\n ((v : W) → (b : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var v b)) → motive x", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [ + "PCP.Reduction.FiniteBooleanConstraints.negate.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The corresponding true bit in a chosen decoded polynomial row. ", + "end_line": 118, + "is_class": false, + "kind": "definition", + "line": 114, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.decodedAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n ((σ → F) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F) →\n (Fˣ → F) → PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} {m c : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (P : MvPolynomial (Fin n) F) (MVal : MvPolynomial (Fin n ⊕ Fin n) F)\n (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n MProp.totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree +\n 3 * (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree ≤ 2 * ((H.card - 1) * n) →\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree ≤ (H.card - 1) * n →\n ¬MProp.totalDegree ≤ 5 * ((H.card - 1) * n) → False", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Preorder.toLE", + "Nat.instPreorder", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : ℕ) → (x_1 : PCP.QueryTree x) → PCP.QueryTree.below x_1 → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "Finset", + "PCP.QueryTree.addresses.match_1", + "Bool", + "PCP.QueryTree.leaf", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "PProd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The honest auxiliary encoded line at a fixed requested outer point. ", + "end_line": 126, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.honestTable", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n [NeZero m] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n MvPolynomial σ F → (σ → F) → (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Polynomial", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.encode", + "PCP.Algebraic.PolynomialLine.restrict" + ] + }, + { + "axioms": [], + "doc": "Encoding of a Boolean result. ", + "end_line": 48, + "is_class": false, + "kind": "definition", + "line": 47, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeBool", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "Bool", + "List", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Bool", + "List.cons", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "List.nil" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False", + "type_dependencies": [ + "AddMonoidWithOne", + "CharZero", + "Nat", + "Eq", + "HAdd.hAdd", + "instHAdd", + "AddSemigroup.toAdd", + "AddMonoid.toAddSemigroup", + "AddMonoidWithOne.toAddMonoid", + "Nat.cast", + "AddMonoidWithOne.toNatCast", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "Zero.toOfNat0", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "¬1 ≤ 3 → False", + "type_dependencies": [ + "Not", + "LE.le", + "Nat", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The tape alphabet: a bit, or a separator between arguments.\n\nA separator is needed because the machine takes one input list, while our relations and algorithms\ntake two or three bit strings. Self-delimiting encodings would avoid it at the cost of a length\nprefix; a separator symbol is the simpler convention and is fixed here once. ", + "end_line": 25, + "is_class": false, + "kind": "inductive", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym" + ], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [] + } + ], + "lean_version": "4.35.0-rc2", + "modules": [ + "PCP.Algebraic.BLR", + "PCP.Algebraic.BinaryLocalCorrection", + "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "PCP.Algebraic.BinaryZeroOnGridSoundness", + "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "PCP.Algebraic.EncodedLineLowDegreeTest", + "PCP.Algebraic.GeneratorLowDegreeTest", + "PCP.Algebraic.GridVanishing", + "PCP.Algebraic.Hadamard", + "PCP.Algebraic.HadamardSoundness", + "PCP.Algebraic.HadamardTest", + "PCP.Algebraic.PointLineSoundness", + "PCP.Algebraic.SetMultilinear", + "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "PCP.Algebraic.ThreeColorGrid", + "PCP.Algebraic.ThreeColorVerifier", + "PCP.Algebraic.ThreeColorVerifierCompleteness", + "PCP.Algebraic.ThreeColorVerifierSoundness", + "PCP.Complexity.CostModel", + "PCP.Complexity.Machine", + "PCP.Complexity.NP", + "PCP.Complexity.ThreeColorRuntime", + "PCP.Reduction.FiniteBooleanConstraints", + "PCP.ReverseConcrete", + "PCP.Theorem", + "PCP.Verifier.Definition" + ], + "provenance": { + "kind": "lean", + "text": "Read by Lean 4.35.0-rc2 from the authors' compiled modules." + } } diff --git a/papers/pcp-exposition/links.json b/papers/pcp-exposition/links.json index 490d6eb..f3b822f 100644 --- a/papers/pcp-exposition/links.json +++ b/papers/pcp-exposition/links.json @@ -527,7 +527,91 @@ "PCP.Algebraic.SetMultilinear.totalDegree_encode_le": "Constant digit-encoding degree", "PCP.Algebraic.ThreeColorVerifier.BranchSeed": "Seven branch seed types", "PCP.Algebraic.ThreeColorVerifier.branchTest": "Seven concrete branch tests", - "PCP.Algebraic.ThreeColorVerifier.test": "Conjunction of the seven checks" + "PCP.Algebraic.ThreeColorVerifier.test": "Conjunction of the seven checks", + "PCP.Algebraic.BLR.rejectionProbability": "Rejection rate of the BLR test", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint": "Points of the inner encoding", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle": "Binary table of one encoded row", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed": "Randomness of the inner test", + "PCP.Algebraic.BinaryLocalCorrection.Query": "Query locations of local correction", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant": "Loss constant of local correction", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant": "Line error factor of the line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant": "Proximity factor of the line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines": "Lines as point and direction", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample": "Randomness of the encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query": "Query locations of the encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected": "Corrected comparison bit", + "PCP.Algebraic.EncodedLineLowDegreeTest.test": "The encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries": "Query list of the encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint": "Finitely many inner points (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed": "Finitely many inner seeds (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed": "Finitely many seed pairs (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample": "Finitely many samples (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate": "Rejection rate of the encoded-line test", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes": "Powers of the generator as nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights": "Lagrange weights at zero", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes": "Nodes from a primitive root", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate": "Inner weighted test rejection rate", + "PCP.Algebraic.GridVanishing.coordinate": "Vanishing polynomial of one coordinate", + "PCP.Algebraic.GridVanishing.VanishesOn": "Vanishing on the grid", + "PCP.Algebraic.Hadamard.encode": "The Hadamard encoding", + "PCP.Algebraic.Hadamard.encodeFunction": "Hadamard encoding of a function", + "PCP.Algebraic.Hadamard.homogeneousIndex": "Linear queries among degree-r queries", + "PCP.Algebraic.Hadamard.TestRandomness": "Randomness of the Hadamard test", + "PCP.Algebraic.Hadamard.TestRandomness.base": "Base point of a Hadamard seed", + "PCP.Algebraic.Hadamard.TestRandomness.auxiliary": "Second point of a Hadamard seed", + "PCP.Algebraic.Hadamard.TestRandomness.linear": "Linear query of a Hadamard seed", + "PCP.Algebraic.Hadamard.TestRandomness.factor": "Factor queries of a Hadamard seed", + "PCP.Algebraic.Hadamard.TestRandomness.factorDegree_le": "Factor degree at most r", + "PCP.Algebraic.Hadamard.TestRandomness.productDegree_le": "Product degree at most r", + "PCP.Algebraic.Hadamard.TestRandomness.linearQuery": "Linear query in the full domain", + "PCP.Algebraic.Hadamard.TestRandomness.factorQuery": "Factor query in the full domain", + "PCP.Algebraic.Hadamard.TestRandomness.productQuery": "Reduced product query", + "PCP.Algebraic.Hadamard.testAccepts": "Acceptance of the Hadamard test", + "PCP.Algebraic.Hadamard.test": "The Hadamard test", + "PCP.Algebraic.Hadamard.testQueries": "Query list of the Hadamard test", + "PCP.Algebraic.SetMultilinear.Variables": "Variables of the digit encoding", + "PCP.Algebraic.SetMultilinear.digitMonomial": "Digit monomial for a power", + "PCP.Algebraic.SetMultilinear.encode": "The set-multilinear digit encoding", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions": "Fixed repetition count", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier": "The amplified verifier", + "PCP.Algebraic.ThreeColorGrid.validPolynomial": "Vertex constraint polynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial": "Edge constraint polynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension": "Low-degree extension of the edges", + "PCP.Algebraic.ThreeColorVerifier.Vertex": "Points for one vertex", + "PCP.Algebraic.ThreeColorVerifier.PairPoint": "Points for a pair of vertices", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint": "Points for the edge certificate", + "PCP.Algebraic.ThreeColorVerifier.flatten": "Flattening two vertex blocks", + "PCP.Algebraic.ThreeColorVerifier.edgeValue": "Adjacency extension at a point", + "PCP.Algebraic.ThreeColorVerifier.flatDifference": "Difference table on flat coordinates", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary": "Line tables for the vertex certificate", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary": "Line tables for the edge certificate", + "PCP.Algebraic.ThreeColorVerifier.Sample": "Randomness of the graph verifier", + "PCP.Algebraic.ThreeColorVerifier.colorQuery": "Tagging colour-table queries", + "PCP.Algebraic.ThreeColorVerifier.validQuery": "Tagging vertex-certificate queries", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery": "Tagging difference-table queries", + "PCP.Algebraic.ThreeColorVerifier.properQuery": "Tagging edge-certificate queries", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery": "Tagging vertex grid-check queries", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery": "Tagging edge grid-check queries", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery": "Tagging difference-check queries", + "PCP.Algebraic.ThreeColorVerifier.branchQueries": "Query lists of the seven branches", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint": "Finitely many inner points (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed": "Finitely many inner seeds (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeProdTestRandomnessInnerSeed": "Finitely many seed pairs (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeSampleOfDecidableEq": "Finitely many line samples (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeCallSeedOfDecidableEq": "Finitely many call seeds (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeGridRandomness": "Finitely many grid seeds (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeTestSample": "Finitely many ZERO samples (verifier)", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype": "Finite seed space of each branch", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate": "Rejection rate of the graph verifier", + "PCP.Reduction.FiniteBooleanConstraints.negate": "Negating a literal", + "PCP.Reduction.FiniteBooleanConstraints.ClauseHolds": "A three-literal clause holds", + "PCP.Reduction.FiniteBooleanConstraints.orGate": "The three OR-gate clauses", + "PCP.Reduction.FiniteBooleanConstraints.Pattern": "Boolean input patterns", + "PCP.Reduction.FiniteBooleanConstraints.Aux": "Auxiliary prefix flags", + "PCP.Reduction.FiniteBooleanConstraints.Variable": "Variables of the clause formula", + "PCP.Reduction.FiniteBooleanConstraints.Clause": "Clauses of the Boolean reduction", + "PCP.Reduction.FiniteBooleanConstraints.flagLiteral": "Literal for a prefix flag", + "PCP.Reduction.FiniteBooleanConstraints.differenceLiteral": "Literal for a pattern mismatch" }, "fidelity_held": "The selected source has not yet been compared against elaborated Lean statements for this page." } diff --git a/papers/pcp-exposition/paper.toml b/papers/pcp-exposition/paper.toml index ae97db8..38f1b1a 100644 --- a/papers/pcp-exposition/paper.toml +++ b/papers/pcp-exposition/paper.toml @@ -16,7 +16,7 @@ source = "https://github.com/troyjlee/tcs-formalizations/tree/a0ce13ed0fa264f051 source_name = "tcs-formalizations at a0ce13e" source_lines = "https://github.com/troyjlee/tcs-formalizations/blob/a0ce13ed0fa264f051c1278e039596ce65557fa4/{path}#L{line}-L{end}" licence = "Apache-2.0" -scope = "Selected source excerpts appear alongside retained Lean statements and the extracted reading-guide interface. Each declaration shows its source status. Proof dependencies and axiom reports are available only for records with the relevant extraction." +scope = "Lean 4.35.0-rc2 compiled the listed modules of the authors' project, and each declaration's statement, dependencies and axioms shown here are Lean's own report from those compiled modules. The links from the paper's sentences to the Lean, the plain titles and the notes were made with AI and have not been reviewed by the authors." [reading] language = "lean" diff --git a/papers/pcp-full-argument/generated/lean.json b/papers/pcp-full-argument/generated/lean.json index 2cf6858..889083f 100644 --- a/papers/pcp-full-argument/generated/lean.json +++ b/papers/pcp-full-argument/generated/lean.json @@ -1,8318 +1,79861 @@ { - "modules": [ - "PCP.Algebraic.BLR", - "PCP.Algebraic.BerlekampWelchCertificate", - "PCP.Algebraic.BinaryDifferenceConsistency", - "PCP.Algebraic.BinaryLocalCorrection", - "PCP.Algebraic.BinaryLocalCorrectionSoundness", - "PCP.Algebraic.BinaryLocalRowDecoding", - "PCP.Algebraic.BinaryStandardLocalCorrection", - "PCP.Algebraic.BinaryZeroOnGridCorrection", - "PCP.Algebraic.BinaryZeroOnGridSoundness", - "PCP.Algebraic.BivariateAgreement", - "PCP.Algebraic.BivariateAgreementBoost", - "PCP.Algebraic.BivariateAgreementFromRectangle", - "PCP.Algebraic.BivariateCleanRectangle", - "PCP.Algebraic.BivariateColumnSelection", - "PCP.Algebraic.BivariateCrossingSoundness", - "PCP.Algebraic.CandidateCrossing", - "PCP.Algebraic.DerivedZeroOnGridSoundness", - "PCP.Algebraic.EncodedLineLowDegreeSoundness", - "PCP.Algebraic.EncodedLineLowDegreeTest", - "PCP.Algebraic.GeneratorLowDegreeTest", - "PCP.Algebraic.GridInterpolation", - "PCP.Algebraic.GridVanishing", - "PCP.Algebraic.Hadamard", - "PCP.Algebraic.HadamardComposition", - "PCP.Algebraic.HadamardCorrection", - "PCP.Algebraic.HadamardDerivedOracle", - "PCP.Algebraic.HadamardRowDecoding", - "PCP.Algebraic.HadamardSoundness", - "PCP.Algebraic.LineTableLocalCorrection", - "PCP.Algebraic.PointLineConstant", - "PCP.Algebraic.PointLineConstants", - "PCP.Algebraic.PointLineCorrection", - "PCP.Algebraic.PointLineCrossing", - "PCP.Algebraic.PointLineEndpointConsistency", - "PCP.Algebraic.PointLineParameterError", + "declarations": [ + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {t : ℕ} →\n ℕ →\n F →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (σ → F) →\n (σ → F) → (Fin t → ZMod 2) → List ((σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "List", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "List.ofFn", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_2", + "PCP.Algebraic.HadamardWeights.scaleLabel", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 75, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.averageRejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {t r : ℕ} [inst : Fintype ι] (hr : 1 ≤ r)\n (H : ι → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n 0 ≤ PCP.Algebraic.Hadamard.averageRejectionRate hr H", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.Hadamard.averageRejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Numeric field codes in the order determined by the supplied binary coordinates. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 62, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldCode", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → PCP.Algebraic.ThreeColorFields.FieldFamily k ≃ Fin (2 ^ (4 * (k + 1)))", + "type_dependencies": [ + "Nat", + "Equiv", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "Equiv.trans", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "ZMod", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "LinearEquiv.toEquiv", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instField", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instModuleZModOfNatNatElement", + "Pi.Function.module", + "Semiring.toModule", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorFields.fieldCode._proof_1", + "PCP.Algebraic.ThreeColorFields.coordinates", + "Equiv.symm", + "PCP.Algebraic.BinarySeedPadding.Seed", + "PCP.Algebraic.BinarySeedPadding.finSeedEquiv" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 69, + "is_class": false, + "kind": "theorem", + "line": 68, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.inputPoly_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (q : Polynomial ℕ) (n : ℕ), Polynomial.eval n (PCP.Machine.NPTableau.inputPoly q) = n + Polynomial.eval n q + 1", + "type_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "Polynomial.eval", + "PCP.Machine.NPTableau.inputPoly", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Reading the first `N` bits of an oracle back out reproduces it below `N`. ", + "end_line": 219, + "is_class": false, + "kind": "theorem", + "line": 216, + "module": "PCP.Verifier.Definition", + "name": "PCP.oracleOfWitness_prefix", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (π : PCP.ProofOracle) (N : ℕ) {j : ℕ}, j < N → PCP.oracleOfWitness (List.map π (List.range N)) j = π j", + "type_dependencies": [ + "PCP.ProofOracle", + "Nat", + "LT.lt", + "instLTNat", + "Eq", + "Bool", + "PCP.oracleOfWitness", + "List.map", + "List.range" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.boolColor._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (2 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "A proof oracle is an infinite Boolean string; `π a` is the bit at address `a`. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Verifier.Definition", + "name": "PCP.ProofOracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "Nat", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_C", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (a : R),\n (PCP.Algebraic.SetMultilinear.encode m c) (Polynomial.C a) = a • PCP.Algebraic.SetMultilinear.digitMonomial m c 0", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "RingHom", + "RingHom.instFunLike", + "Polynomial.C", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The independent inner test's average rejection is visible in actual rejection. ", + "end_line": 162, + "is_class": false, + "kind": "theorem", + "line": 137, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.average_inner_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (Finset.univ.expect fun b => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate ⋯ ρ nodes (H b)) ≤\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "LE.le", + "Rat", + "Rat.instLE", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "Pi.instFintype", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.SetMultilinear.Variables", + "instFintypeProd", + "Fin.fintype", + "instDecidableEqProd", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Removing all global errors from a large set leaves more than `d` agreements. ", + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 33, + "module": "PCP.Algebraic.BivariateAgreementFromRectangle", + "name": "PCP.Algebraic.BivariateAgreementFromRectangle.card_agreements_gt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {I : Type u_1} {A : Type u_2} [inst : Fintype I] [Nonempty I] [inst_2 : DecidableEq A] (f g : I → A) (B : Finset I)\n {d : ℕ} {ε : ℚ},\n PCP.Algebraic.relativeDistance f g ≤ ε → ε * ↑(Fintype.card I) + ↑d < ↑B.card → d < {i ∈ B | f i = g i}.card", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Finset", + "Nat", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "LT.lt", + "Rat.instLT", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Finset.card", + "instLTNat", + "Finset.filter", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.costPoly", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} → PCP.Machine.NPTableau.Checker R → Polynomial ℕ → ℕ → ℕ → ℕ → ℕ → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatAtLeastTwo", + "Polynomial.instNatCast", + "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_1", + "Polynomial.X", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatNat", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Distinct bounded-degree polynomials agree on at most `D` nonzero parameters. ", + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.agreement_on_units_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {D : ℕ} (p q : Polynomial F),\n p.natDegree ≤ D →\n q.natDegree ≤ D →\n p ≠ q →\n (PCP.Algebraic.relativeAgreement (fun l => Polynomial.eval (↑l) p) fun l => Polynomial.eval (↑l) q) ≤\n ↑D / ↑(Fintype.card Fˣ)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Ne", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeAgreement", + "Units", + "Semiring.toMonoid", + "instFintypeUnitsOfDecidableEq", + "Polynomial.eval", + "Units.val", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_prod._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),\n ∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a", + "type_dependencies": [ + "DivisionSemiring", + "Finset", + "Eq", + "Finset.sum", + "Semiring.toAddCommMonoid", + "DivisionSemiring.toSemiring", + "HDiv.hDiv", + "instHDiv", + "DivInvMonoid.toDiv", + "GroupWithZero.toDivInvMonoid", + "DivisionSemiring.toGroupWithZero" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodePair.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : List Bool × List Bool),\n PCP.Machine.encodePair p = PCP.Machine.ofBits p.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits p.2", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Logarithmic randomness as an upper bound: at most `a * ⌈log₂ (n + 2)⌉ + b` fair bits on\ninputs of length `n`.\n\n**This is too weak to be an efficiency hypothesis on its own.** An upper bound does not make\n`randomness` computable, and `Verifier.randomness` is an unrestricted function `ℕ → ℕ`. Take\n`randomness n = if f n then 1 else 0` for arbitrary `f`: the\nbound `LogRandomness 0 1` holds, yet the budget smuggles in an arbitrary Boolean function of the\ninput length, which an algorithm recovers just by measuring the length of the random string it is\nhanded. Use `CanonicalRandomness` wherever efficiency is at stake. ", + "end_line": 146, + "is_class": false, + "kind": "definition", + "line": 136, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.LogRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ → ℕ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "LE.le", + "instLENat", + "PCP.Verifier.randomness", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 48, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.fraction_shared_fst", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (E : W × S → Prop),\n (PCP.Algebraic.AffineLineSampling.fraction fun s => E (s.1, s.2.1)) = PCP.Algebraic.AffineLineSampling.fraction E", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.AffineLineSampling.fraction", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator_spec._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ),\n 16 ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) →\n ¬0 < Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) - 1 → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "Not", + "LT.lt", + "instLTNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → ℕ → Type (max (max u_3 u_4) u_4 u_3)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (hP : P.natDegree ≤ r) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (R : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n PCP.Algebraic.HadamardDerivedOracle.queries ρ P hP L R = [PCP.Algebraic.HadamardComposition.query ρ P L hP + R, R]", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardDerivedOracle.answer._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "List", + "PCP.Algebraic.HadamardDerivedOracle.queries", + "List.cons", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Distrib.toAdd", + "instDistribOfSemiring", + "PCP.Algebraic.HadamardComposition.query", + "List.nil" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every finite field has the full multiplicative generator required by the test. ", + "end_line": 149, + "is_class": false, + "kind": "theorem", + "line": 144, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_generator", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F], ∃ ζ, IsPrimitiveRoot ζ (Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Fintype", + "Exists", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "Nat", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s =\n (List.ofFn fun i => PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i (s i)).flatten", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Eq", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.queries", + "List.flatten", + "List.ofFn", + "PCP.Algebraic.ThreeColorVerifier.branchQueries" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_X_inl", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R) (i : σ),\n (PCP.Algebraic.GridVanishing.substitute Y) (MvPolynomial.X (Sum.inl i)) = MvPolynomial.X i", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "MvPolynomial.X", + "Sum.inl" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "theorem", + "line": 29, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "0 < PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "type_dependencies": [ + "LT.lt", + "Nat", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.decodedTable._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c : ℕ} [NeZero m]\n (Q : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F),\n (∀ (uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ), (Q uv).totalDegree ≤ c) →\n ∀ (uv : (σ → F) × (σ → F)), ((PCP.Algebraic.SetMultilinear.decode m c) (Q uv)).natDegree ≤ c * m ^ c", + "type_dependencies": [ + "Field", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Prod", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 68, + "is_class": false, + "kind": "theorem", + "line": 66, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.sixteen_le_card", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), 16 ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Witness bits and all tableau symbols, including control and delimiters. ", + "end_line": 66, + "is_class": false, + "kind": "definition", + "line": 63, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.sizePoly", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} → PCP.Machine.NPTableau.Checker R → Polynomial ℕ → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "PCP.Machine.NPTableau.timePoly", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatAtLeastTwo", + "Polynomial.instNatCast", + "PCP.Machine.NPTableau.sizePoly._proof_1", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "Fintype.card", + "Turing.FinTM2.K", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.kFin", + "PCP.Machine.NPTableau.spacePoly" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Averaging minimum line errors gives the actual all-parameter rejection rate. ", + "end_line": 83, + "is_class": false, + "kind": "theorem", + "line": 78, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.mean_decodedLineError_eq_rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (f : (σ → F) → F),\n (Finset.univ.expect fun uv => PCP.Algebraic.PointLineTest.decodedLineError c f uv) =\n PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable c f)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "Finset.expect", + "Prod", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.PointLineTest.decodedLineError", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineTest.decodedTable" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.const.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {a a_1 : Bool},\n PCP.Reduction.NAEThreeColor.Literal.const a = PCP.Reduction.NAEThreeColor.Literal.const a_1 → a = a_1", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.const" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 275, + "is_class": false, + "kind": "theorem", + "line": 270, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.canonical_represents", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {T B : ℕ} (initial : tm.Cfg) (hs : PCP.Machine.StackSupported tm initial.stk),\n PCP.Machine.mass initial.stk + PCP.Machine.machinePushBound tm * T ≤ B →\n ∀ (i : Fin (T + 1)),\n PCP.Machine.TableauCells.Represents ((PCP.Machine.TableauCells.canonicalAssignment tm T B initial hs).1 i)\n ((PCP.Machine.TableauCells.canonicalAssignment tm T B initial hs).2 i) (PCP.Machine.boundedEval tm (↑i) initial)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.mass", + "Turing.FinTM2.kFin", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Machine.machinePushBound", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.TableauCells.Represents", + "Prod.fst", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "PCP.Machine.TableauCells.canonicalAssignment", + "Prod.snd", + "PCP.Machine.boundedEval", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "constructor", + "line": 79, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.CostModel" + ], + "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The supplied vertex index becomes a base-grid-alphabet address. ", + "end_line": 119, + "is_class": false, + "kind": "definition", + "line": 114, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n [inst : Fintype V] →\n optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V) →\n V ↪\n Fin\n (PCP.Algebraic.ThreeColorParameters.size\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))) →\n ↥(PCP.Algebraic.ThreeColorParameters.grid (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))", + "type_dependencies": [ + "Fintype", + "optParam", + "Equiv", + "Fin", + "Fintype.card", + "Fintype.equivFin", + "Function.Embedding", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid" + ], + "value_dependencies": [ + "Fintype", + "Equiv", + "Fin", + "Fintype.card", + "Function.Embedding.trans", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid", + "Equiv.toEmbedding", + "PCP.Algebraic.ThreeColorGridIndex.embedding", + "PCP.Algebraic.ThreeColorParameters.gridCode", + "PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 36, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.inputSlot", + "provenance": "lean", + "structural_dependencies": [], + "type": "{a d : ℕ} → Fin d → Fin a → Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.arity" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.slot", + "Fin.castLE", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.FiniteDomainConstraints.inputSlot._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.extensionDegree_pos._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), ¬0 < 4 * (k + 1) → False", + "type_dependencies": [ + "Nat", + "Not", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.witnessList_packWitness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : ℕ} (w : List Bool) (hw : w.length ≤ W),\n PCP.Machine.NPTableau.witnessList (PCP.Machine.NPTableau.packWitness w hw) = w", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "LE.le", + "instLENat", + "List.length", + "Eq", + "PCP.Machine.NPTableau.witnessList", + "PCP.Machine.NPTableau.packWitness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Satisfiability of the finite constraints is exactly existence of a bounded accepting witness. ", + "end_line": 152, + "is_class": false, + "kind": "theorem", + "line": 141, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.exists_accepts_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (x : List Bool),\n (∃ a, PCP.Machine.NPTableau.Accepts h q x a) ↔ ∃ w, w.length ≤ Polynomial.eval x.length q ∧ R x w = true", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "PCP.Machine.NPTableau.Assignment", + "PCP.Machine.NPTableau.Accepts", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Each edge is listed in one orientation; `graph` adds its reverse. ", + "end_line": 103, + "is_class": false, + "kind": "definition", + "line": 96, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n (C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) →\n PCP.Reduction.NAEThreeColor.Vertex V C → PCP.Reduction.NAEThreeColor.Vertex V C → Prop", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Vertex" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.direct.match_1", + "Ne", + "Prod", + "Bool", + "Eq", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1", + "And", + "PCP.Reduction.NAEThreeColor.literalVertex", + "False" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 374, + "is_class": false, + "kind": "definition", + "line": 374, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.row_mismatch_mul_le._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] (p : ι → Prop) [inst_1 : DecidablePred p]\n (f : ι → M), (∑ a ∈ s, if p a then f a else 0) = ∑ a ∈ s with p a, f a", + "type_dependencies": [ + "Finset", + "AddCommMonoid", + "DecidablePred", + "Eq", + "Finset.sum", + "ite", + "OfNat.ofNat", + "Zero.toOfNat0", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddCommMonoid.toAddMonoid", + "Finset.filter" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A verifier algorithm is polynomial-time when some `FinTM2` machine computes its step function\nwithin a polynomial number of steps in the encoded input length. ", + "end_line": 73, + "is_class": false, + "kind": "definition", + "line": 69, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.PolyTimeAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.VerifierAlg → Prop", + "type_dependencies": [ + "PCP.VerifierAlg" + ], + "value_dependencies": [ + "PCP.VerifierAlg", + "Nonempty", + "Turing.TM2ComputableInPolyTime", + "Prod", + "List", + "Bool", + "Sum", + "Nat", + "PCP.Machine.Sym", + "PCP.Machine.encodeTriple", + "PCP.Machine.encodeAnswer", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Distinct messages have exactly one-half relative distance. ", + "end_line": 96, + "is_class": false, + "kind": "theorem", + "line": 87, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ},\n 1 ≤ r →\n ∀ (x y : Fin t → ZMod 2),\n x ≠ y →\n PCP.Algebraic.relativeDistance ⇑(PCP.Algebraic.Hadamard.encode r x) ⇑(PCP.Algebraic.Hadamard.encode r y) = 1 / 2", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Ne", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 388, + "is_class": false, + "kind": "theorem", + "line": 388, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyGridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t k : ℕ}, Nonempty (PCP.Algebraic.DerivedZeroOnGrid.GridRandomness F k m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] → [(a : List Bool) → SizeOf (L a)] → PCP.NPCertificate P L → ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "PCP.NPCertificate", + "Nat" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "PCP.NPCertificate", + "PCP.NPCertificate.rec", + "Nat", + "Polynomial", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "Polynomial._sizeOf_inst", + "instSizeOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨0, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 3 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 18 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "Decidable.byContradiction", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Claim 3.7: one degree-`r` binary query evaluates the affine observation of `P(u)`. ", + "end_line": 166, + "is_class": false, + "kind": "theorem", + "line": 160, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.evaluate_query", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (hP : P.natDegree ≤ r) (u : F),\n (PCP.Algebraic.BinaryPolynomialSpace.evaluate (ρ u)) (PCP.Algebraic.HadamardComposition.query ρ P L hP) =\n (PCP.Algebraic.BinaryPolynomialSpace.evaluate (ρ (Polynomial.eval u P))) L", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.evaluate", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.HadamardComposition.query", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.packWitness", + "provenance": "lean", + "structural_dependencies": [], + "type": "{W : ℕ} → (w : List Bool) → w.length ≤ W → PCP.Machine.NPTableau.BoundedWitness W", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "LE.le", + "instLENat", + "List.length", + "PCP.Machine.NPTableau.BoundedWitness" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "LE.le", + "instLENat", + "List.length", + "Sigma.mk", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin.val", + "Fin.mk", + "PCP.Machine.NPTableau.packWitness._proof_1", + "List.get" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "If the oracles agree on every address the tree can reach, the tree cannot tell them apart. ", + "end_line": 77, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (T : PCP.QueryTree d) {π π' : PCP.ProofOracle}, (∀ a ∈ T.addresses, π a = π' a) → T.eval π = T.eval π'", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual field-valued procedure has the same accepted-wrong guarantee. ", + "end_line": 265, + "is_class": false, + "kind": "theorem", + "line": 248, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.correct_wrong_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {D : ℕ} (T : (σ → F) → Polynomial F),\n (∀ (b : σ → F), (T b).natDegree ≤ D) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n ∀ (a : σ → F) (f : (σ → F) → F),\n (PCP.Algebraic.AffineLineSampling.fraction fun s =>\n PCP.Algebraic.LineTableLocalCorrection.correct T f a s.1 s.2 ≠ none ∧\n PCP.Algebraic.LineTableLocalCorrection.correct T f a s.1 s.2 ≠ some ((MvPolynomial.eval a) P)) ≤\n (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) + ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.AffineLineSampling.fraction", + "Prod", + "Units", + "Semiring.toMonoid", + "instFintypeProd", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "And", + "Ne", + "Option", + "PCP.Algebraic.LineTableLocalCorrection.correct", + "Prod.fst", + "Prod.snd", + "Option.none", + "Option.some", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "PCP.Algebraic.relativeDistance", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Transfer to the grid verifier with honestly derived primary answers,\nusing the actual fresh randomized marginal. ", + "end_line": 198, + "is_class": false, + "kind": "theorem", + "line": 185, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejection_transfer", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (Q : (Fin n → F) → Polynomial F)\n (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) (f : (Fin n → F) → F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval (f x) (Q x))))) M A ≤\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ Q hQ nodes ζ H p M A +\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ p f", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Rat.instAdd", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Field.toCommRing", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each concrete branch has the claimed count, including fresh derived-read seeds. ", + "end_line": 359, + "is_class": false, + "kind": "theorem", + "line": 322, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (i : Fin 7)\n (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i),\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i s).length ≤\n PCP.Algebraic.ThreeColorVerifier.branchQueryBound c i", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "PCP.Algebraic.ThreeColorVerifier.branchQueryBound" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.brecOn.go", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t ×' PCP.QueryTree.below t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PProd" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.QueryTree.rec", + "PProd", + "Bool", + "PProd.mk", + "PCP.QueryTree.leaf", + "PUnit", + "PUnit.unit", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 97, + "is_class": false, + "kind": "theorem", + "line": 90, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.degreeOf_interpolate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽] [inst_1 : DecidableEq 𝔽] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n (H : Finset 𝔽) (f : (σ → ↥H) → 𝔽) (i : σ),\n MvPolynomial.degreeOf i ((PCP.Algebraic.GridInterpolation.interpolate H) f) ≤ H.card - 1", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.degreeOf", + "Semifield.toCommSemiring", + "Field.toSemifield", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.GridInterpolation.interpolate", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 1 →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Polynomial bound on witness length. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.witnessBound", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness_avoids", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Fin 3 → Bool),\n PCP.Reduction.NAEThreeColor.NAE b →\n ∀ (i : Fin 3),\n PCP.Reduction.NAEThreeColor.triangleWitness (b 0) (b 1) (b 2) i ≠ PCP.Reduction.NAEThreeColor.boolColor (b i)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Bool", + "PCP.Reduction.NAEThreeColor.NAE", + "Ne", + "PCP.Reduction.NAEThreeColor.triangleWitness", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Reduction.NAEThreeColor.boolColor" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 481, + "is_class": false, + "kind": "theorem", + "line": 471, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_six", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 6 =\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate ⋯ π.color π.difference", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "Fin.fintype", + "instDecidableEqFin", + "Decidable.byContradiction", + "LE.le", + "instLENat", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 72, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u} →\n (t : PCP.Reduction.NAEThreeColor.Literal V) →\n ((a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a)) →\n ((a : V) → (a_1 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)) → motive t", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.Literal.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A symbolic change of representation to polynomials in `X` with coefficients in `F[Y]`. ", + "end_line": 74, + "is_class": false, + "kind": "definition", + "line": 71, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.symbolicX", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : Field F] → MvPolynomial (Fin 2) F →+* Polynomial (Polynomial F)", + "type_dependencies": [ + "Field", + "RingHom", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial", + "CommSemiring.toSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [ + "Field", + "MvPolynomial.eval₂Hom", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial.semiring", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Polynomial.commSemiring", + "RingHom.comp", + "Semiring.toNonAssocSemiring", + "Polynomial.C", + "Matrix.vecCons", + "Polynomial.X", + "DFunLike.coe", + "RingHom", + "RingHom.instFunLike", + "Matrix.vecEmpty" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.ProbabilisticCrossing.errors.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {inst_2 : DecidableEq F} [inst_3 : DecidableEq F] (d d_1 : ℕ),\n d = d_1 →\n ∀ (f f_1 : F × F → F),\n f = f_1 →\n ∀ (x x_1 : F),\n x = x_1 →\n ∀ (y y_1 : F),\n y = y_1 →\n ∀ (a a_1 : Fin 4),\n a = a_1 →\n PCP.Algebraic.ProbabilisticCrossing.errors d f x y a =\n PCP.Algebraic.ProbabilisticCrossing.errors d_1 f_1 x_1 y_1 a_1", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Prod", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Rat", + "PCP.Algebraic.ProbabilisticCrossing.errors" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 76, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → [DecidableEq V] → (x x_1 : PCP.Reduction.NAEThreeColor.Literal V) → Decidable (x = x_1)", + "type_dependencies": [ + "DecidableEq", + "PCP.Reduction.NAEThreeColor.Literal", + "Decidable", + "Eq" + ], + "value_dependencies": [ + "DecidableEq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq.match_1", + "Decidable", + "Eq", + "Bool", + "dite", + "PCP.Reduction.NAEThreeColor.Literal.const", + "instDecidableEqBool", + "Eq.ndrec", + "Decidable.isTrue", + "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_1", + "Not", + "Decidable.isFalse", + "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_2", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_3", + "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_4", + "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_5", + "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_6", + "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_7" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 389, + "is_class": false, + "kind": "theorem", + "line": 389, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyTestSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t k r : ℕ}, Nonempty (PCP.Algebraic.DerivedZeroOnGrid.TestSample F k m c t r)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.triangleWitness.match_1.eq_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Bool → Bool → Bool → Sort u_1) (x x_1 x_2 : Bool) (h_1 : Unit → motive false false true)\n (h_2 : Unit → motive true true false) (h_3 : (x : Bool) → motive false true x)\n (h_4 : (x x_3 x_4 : Bool) → motive x x_3 x_4),\n (x = false → x_1 = false → x_2 = true → False) →\n (x = true → x_1 = true → x_2 = false → False) →\n (x = false → x_1 = true → False) →\n (match x, x_1, x_2 with\n | false, false, true => h_1 ()\n | true, true, false => h_2 ()\n | false, true, x => h_3 x\n | x, x_6, x_7 => h_4 x x_6 x_7) =\n h_4 x x_1 x_2", + "type_dependencies": [ + "Bool", + "Unit", + "Bool.false", + "Bool.true", + "Eq", + "False", + "PCP.Reduction.NAEThreeColor.triangleWitness.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.query.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (_hP : P.natDegree ≤ r),\n PCP.Algebraic.HadamardComposition.query ρ P L _hP =\n PCP.Algebraic.BinaryPolynomialSpace.coefficients\n (PCP.Algebraic.multilinearReduction (PCP.Algebraic.HadamardComposition.formalQuery ρ P L))", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "PCP.Algebraic.HadamardComposition.query", + "PCP.Algebraic.BinaryPolynomialSpace.coefficients", + "DFunLike.coe", + "LinearMap", + "MvPolynomial", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.multilinearReduction", + "PCP.Algebraic.HadamardComposition.formalQuery" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct.eq_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (e : C) (i : Fin 3) (f : C)\n (j : Fin 3),\n PCP.Reduction.NAEThreeColor.direct Q (Sum.inr (Sum.inr (e, i))) (Sum.inr (Sum.inr (f, j))) = (e = f ∧ i ≠ j)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "PCP.Reduction.NAEThreeColor.direct", + "Sum.inr", + "Sum", + "Prod", + "Bool", + "Prod.mk", + "And", + "Ne" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "A language over the binary alphabet: inputs are bit strings. ", + "end_line": 15, + "is_class": false, + "kind": "definition", + "line": 14, + "module": "PCP.Complexity.NP", + "name": "PCP.Language", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "List", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "definition", + "line": 19, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {t : ℕ} →\n ℕ →\n F →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (σ → F) → (σ → F) → (Fin t → ZMod 2) → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Finset.sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset.univ", + "Fin.fintype", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_2", + "PCP.Algebraic.HadamardWeights.scaleLabel", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (d : ℕ) (f t : PCP.QueryTree d),\n (f.addresses ∪ t.addresses).card ≤ f.addresses.card + t.addresses.card →\n ¬(f.addresses ∪ t.addresses).card + 1 ≤ 1 + (f.addresses.card + t.addresses.card) → False", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "LE.le", + "instLENat", + "Finset.card", + "Union.union", + "Finset", + "Finset.instUnion", + "instDecidableEqNat", + "PCP.QueryTree.addresses", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Uniform binary strings and whole-field seeds have exactly the same distribution. ", + "end_line": 110, + "is_class": false, + "kind": "definition", + "line": 107, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.seedEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "(N : ℕ) → PCP.Algebraic.ThreeColorBinaryVerifier.RawSeed N ≃ PCP.Algebraic.ThreeColorBinaryVerifier.Seed N", + "type_dependencies": [ + "Nat", + "Equiv", + "PCP.Algebraic.ThreeColorBinaryVerifier.RawSeed", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorSeedIndex.equiv", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorParameters.fieldIndex", + "PCP.Algebraic.ThreeColorBinaryVerifier.fieldIndex._proof_1", + "PCP.Algebraic.BinaryMaterializedField.instAlgebraZModOfNatNatElement", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorParameters.coordinates", + "PCP.Algebraic.ThreeColorParameters.size" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.relation.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {a d : ℕ} →\n (motive :\n PCP.Reduction.FiniteDomainConstraints.Constraint V C →\n PCP.Reduction.FiniteBooleanConstraints.Pattern (PCP.Reduction.FiniteDomainConstraints.arity a d) →\n Sort u_3) →\n (x : PCP.Reduction.FiniteDomainConstraints.Constraint V C) →\n (x_1 : PCP.Reduction.FiniteBooleanConstraints.Pattern (PCP.Reduction.FiniteDomainConstraints.arity a d)) →\n ((e : C) →\n (p : PCP.Reduction.FiniteBooleanConstraints.Pattern (PCP.Reduction.FiniteDomainConstraints.arity a d)) →\n motive (Sum.inl e) p) →\n ((val : V) →\n (p :\n PCP.Reduction.FiniteBooleanConstraints.Pattern\n (PCP.Reduction.FiniteDomainConstraints.arity a d)) →\n motive (Sum.inr val) p) →\n motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "PCP.Reduction.FiniteDomainConstraints.arity", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "PCP.Reduction.FiniteDomainConstraints.arity", + "Sum.inl", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.pairDisagreement.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {A : Type u_2} [inst : Fintype V] {inst_1 : DecidableEq A} [inst_2 : DecidableEq A] (f f_1 : V → A),\n f = f_1 → PCP.Algebraic.PointLineTest.pairDisagreement f = PCP.Algebraic.PointLineTest.pairDisagreement f_1", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.PointLineTest.pairDisagreement" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instReprSym.repr", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym → ℕ → Format", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "Std.Format" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "PCP.Machine.instFintypeSym.match_5", + "Std.Format", + "Bool", + "Repr.addAppParen", + "Std.Format.group", + "Std.Format.nest", + "ite", + "Int", + "GE.ge", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.decLe", + "instOfNat", + "HAppend.hAppend", + "instHAppendOfAppend", + "Std.Format.instAppend", + "Std.Format.text", + "Std.Format.line", + "reprArg", + "instReprBool", + "Std.Format.FlattenBehavior.allOrNone", + "Unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.scope.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ} (s : C → Fin d → V)\n (x : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) (e : C),\n PCP.Reduction.FiniteDomainConstraints.scope s (Sum.inl e) x =\n (if h : ↑(finProdFinEquiv.symm x).1 < d then Sum.inl (s e ⟨↑(finProdFinEquiv.symm x).1, h⟩) else Sum.inr (),\n (finProdFinEquiv.symm x).2)", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.arity", + "Eq", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.scope", + "Sum.inl", + "Prod.mk", + "Sum", + "Unit", + "dite", + "LT.lt", + "instLTNat", + "Fin.val", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Prod.fst", + "DFunLike.coe", + "Equiv", + "HMul.hMul", + "instHMul", + "instMulNat", + "Prod", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "finProdFinEquiv", + "Nat.decLt", + "Fin.mk", + "Not", + "Sum.inr", + "Unit.unit", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A failed comparison also forces rejection, regardless of the inner test's outcome. ", + "end_line": 178, + "is_class": false, + "kind": "theorem", + "line": 164, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.comparison_error_le_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H fun z => ↑z) fun s =>\n f (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2.1) ((PCP.Algebraic.Hadamard.homogeneousIndex ⋯) s.2.2.1.2)) ≤\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All mathematical field parameters for the fixed inner degree four are supplied together. ", + "end_line": 177, + "is_class": false, + "kind": "theorem", + "line": 170, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.chosen_parameters", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ),\n M ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) ∧\n Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) ≤ 16 * max 1 M ∧\n Function.Injective ⇑(PCP.Algebraic.ThreeColorFields.nodes (PCP.Algebraic.ThreeColorFields.index M)) ∧\n PCP.Algebraic.StandardLocalCorrection.GoodNodes 4\n (PCP.Algebraic.ThreeColorFields.generator (PCP.Algebraic.ThreeColorFields.index M)) ∧\n IsPrimitiveRoot (PCP.Algebraic.ThreeColorFields.cubeRoot (PCP.Algebraic.ThreeColorFields.index M)) 3", + "type_dependencies": [ + "Nat", + "And", + "LE.le", + "instLENat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Function.Injective", + "Fin", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "DFunLike.coe", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorFields.nodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorFields.cubeRoot" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Vertex", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Observation 3.8's second identity, sampling homogeneous linear queries. ", + "end_line": 194, + "is_class": false, + "kind": "theorem", + "line": 182, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_homogeneous_queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} {ι : Type u_1} [inst : Fintype ι] (hr : 1 ≤ r) (f g : ι → Fin t → ZMod 2),\n (PCP.Algebraic.relativeDistance\n (fun p => (PCP.Algebraic.Hadamard.encode r (f p.1)) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2)) fun p =>\n (PCP.Algebraic.Hadamard.encode r (g p.1)) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2)) =\n 1 / 2 * PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "Prod.fst", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Prod.snd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Fintype.decidablePiFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A row code of distance at least `1 - τ` loses at most `τ` when an entire\nrow is charged for any disagreement. No positivity of `1 - τ` is needed. ", + "end_line": 70, + "is_class": false, + "kind": "theorem", + "line": 62, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.row_mismatch_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {I : Type u_1} {J : Type u_2} {A : Type u_3} [inst : Fintype I] [inst_1 : Fintype J] [inst_2 : DecidableEq A]\n (R S : I → J → A) {τ : ℚ},\n 0 ≤ τ →\n (∀ (i : I), R i ≠ S i → 1 - τ ≤ PCP.Algebraic.relativeDistance (R i) (S i)) →\n PCP.Algebraic.relativeDistance R S ≤ (PCP.Algebraic.relativeDistance (fun p => R p.1 p.2) fun p => S p.1 p.2) + τ", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Rat", + "LE.le", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "Ne", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "PCP.Algebraic.relativeDistance", + "Fintype.decidablePiFintype", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 67, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.totalDegree_interpolateSlices_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n d : ℕ} {a : Fin (d + 1) → F},\n Function.Injective a →\n ∀ (P : Fin (d + 1) → MvPolynomial (Fin n) F),\n (∀ (i : Fin (d + 1)), (P i).totalDegree ≤ d) →\n (PCP.Algebraic.PolynomialLine.interpolateSlices a P).totalDegree ≤ 2 * d", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.PolynomialLine.interpolateSlices", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Physical bit addresses in the finite proof word; invalid parameters make no reads. ", + "end_line": 171, + "is_class": false, + "kind": "definition", + "line": 165, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n [inst : Fintype V] →\n SimpleGraph V →\n PCP.Algebraic.ThreeColorBinaryVerifier.Seed (Fintype.card V) →\n optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V) →\n List (Fin (PCP.Algebraic.ThreeColorBinaryVerifier.proofLength (Fintype.card V)))", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "Fintype.card", + "optParam", + "Equiv", + "Fin", + "Fintype.equivFin", + "List", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength" + ], + "value_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "Fintype.card", + "Equiv", + "Fin", + "Nat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "List.map", + "PCP.Algebraic.ThreeColorBinaryVerifier.Address", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "DFunLike.coe", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv", + "PCP.Algebraic.ThreeColorFullFieldSampling.queries", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorParameters.fieldIndex", + "PCP.Algebraic.ThreeColorBinaryVerifier.test._proof_1", + "PCP.Algebraic.BinaryMaterializedField.instAlgebraZModOfNatNatElement", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorParameters.coordinates", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorParameters.nodes", + "PCP.Algebraic.ThreeColorParameters.generator", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.RawSeed", + "Equiv.symm", + "PCP.Algebraic.ThreeColorBinaryVerifier.seedEquiv" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Plurality minimizes disagreement among all constant predictions. ", + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 44, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.Plurality.minimizes", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {A : Type u_2} [inst : Fintype R] [inst_1 : Finite A] [inst_2 : Nonempty A] [inst_3 : DecidableEq A]\n (w : R → A) (a : A),\n (PCP.Algebraic.relativeDistance w fun x => PCP.Algebraic.Plurality.value w) ≤\n PCP.Algebraic.relativeDistance w fun x => a", + "type_dependencies": [ + "Fintype", + "Finite", + "Nonempty", + "DecidableEq", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.Plurality.value" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Exact finite-cell characterization of the concrete bounded source computation. ", + "end_line": 305, + "is_class": false, + "kind": "theorem", + "line": 284, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.exists_satisfies_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (tm : Turing.FinTM2) (T B : ℕ) (initial final : tm.Cfg),\n PCP.Machine.StackSupported tm initial.stk →\n PCP.Machine.mass initial.stk + PCP.Machine.machinePushBound tm * T ≤ B →\n (∀ (k : tm.K), (final.stk k).length ≤ B) →\n ((∃ a, PCP.Machine.TableauCells.Satisfies tm T B initial final a) ↔\n PCP.Machine.boundedEval tm T initial = final)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.mass", + "Turing.FinTM2.kFin", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Machine.machinePushBound", + "List.length", + "Iff", + "Exists", + "PCP.Machine.TableauCells.Assignment", + "PCP.Machine.TableauCells.Satisfies", + "Eq", + "PCP.Machine.boundedEval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Extend an honest finite algebraic word by false outside its actual address space. ", + "end_line": 74, + "is_class": false, + "kind": "definition", + "line": 70, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.proofOracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : List Bool) →\n PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x) →\n PCP.ProofOracle", + "type_dependencies": [ + "List", + "Bool", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "PCP.ProofOracle" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "Nat", + "dite", + "LT.lt", + "instLTNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Nat.decLt", + "DFunLike.coe", + "Equiv", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.BinarySeedPadding.boolEquiv", + "Fin.mk", + "Not", + "Bool.false" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → ℕ", + "type_dependencies": [ + "PCP.CostModel", + "Nat" + ], + "value_dependencies": [ + "PCP.CostModel", + "PCP.CostModel.rec", + "Nat", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Verifier algorithms running in polynomial time. ", + "end_line": 83, + "is_class": false, + "kind": "definition", + "line": 83, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.PolyTimeAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → PCP.VerifierAlg → Prop", + "type_dependencies": [ + "PCP.CostModel", + "PCP.VerifierAlg" + ], + "value_dependencies": [ + "PCP.CostModel" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeTest.0.PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p)) →\n ((p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr" + ], + "value_dependencies": [ + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk", + "PCP.NPCertificate.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The exact seed length is bounded by a fixed multiple of the input-size logarithm. ", + "end_line": 91, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), PCP.Algebraic.ThreeColorBinaryVerifier.randomBits N ≤ 32000000 * (Nat.clog 2 N + 1)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval._sunfold", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "PCP.QueryTree.eval.match_1", + "Bool", + "ite", + "Eq", + "Bool.true", + "instDecidableEqBool", + "PCP.QueryTree.eval" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Arbitrary point-dependent weights preserve the bound, including every zero-weight point. ", + "end_line": 266, + "is_class": false, + "kind": "theorem", + "line": 255, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.weightedCubic_homogeneous_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} [inst_2 : Nontrivial F] {I : Type u_2}\n [inst_3 : Fintype I] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (E : I → F)\n (H : I → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) (f : I → F),\n (PCP.Algebraic.relativeDistance\n (fun s =>\n PCP.Algebraic.HadamardDerivedOracle.answer ρ (PCP.Algebraic.HadamardDerivedOracle.weightedCubic (E s.1)) ⋯\n (H s.1) ((PCP.Algebraic.Hadamard.homogeneousIndex ⋯) s.2.1) s.2.2)\n fun s => (PCP.Algebraic.Hadamard.linearEncode (ρ (E s.1 * (f s.1 ^ 3 - 1)))) s.2.1) ≤\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ H f", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Nontrivial", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.decidableEq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "Prod.fst", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_weightedCubic_le", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "le_refl", + "Nat.instPreorder", + "Prod.snd", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Finite choice of a bitstring of any length up to `W`, including zero. ", + "end_line": 31, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.BoundedWitness", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sigma", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin.val", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.test_soundness._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {r : ℕ}, 2 ≤ r → ¬1 + (r - 1) ≤ r → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "The `k`-bit binary expansion of a random string index, least significant bit first. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Complexity.CostModel", + "name": "PCP.bitsOfFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → Fin (2 ^ k) → List Bool", + "type_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List", + "Bool" + ], + "value_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.map", + "Bool", + "Nat.testBit", + "Fin.val", + "List.range" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨3, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 1 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 14 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The budget satisfies the model's exact canonical-randomness requirement. ", + "end_line": 114, + "is_class": false, + "kind": "theorem", + "line": 113, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.canonicalRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.CanonicalRandomness 32000000 32000000", + "type_dependencies": [ + "PCP.Verifier.CanonicalRandomness", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "OfNat.ofNat", + "Nat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {color : PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t}\n {validLines differenceLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t}\n {properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t}\n {color_1 :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {validCert_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {difference_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {properCert_1 :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {colorLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t}\n {validLines_1 differenceLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t}\n {properLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t},\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines } =\n { color := color_1, validCert := validCert_1, difference := difference_1, properCert := properCert_1,\n colorLines := colorLines_1, validLines := validLines_1, differenceLines := differenceLines_1,\n properLines := properLines_1 } →\n color = color_1 ∧\n validCert = validCert_1 ∧\n difference = difference_1 ∧\n properCert = properCert_1 ∧\n colorLines = colorLines_1 ∧\n validLines = validLines_1 ∧ differenceLines = differenceLines_1 ∧ properLines = properLines_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "theorem", + "line": 123, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_eq_zero_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c → ((PCP.Algebraic.SetMultilinear.encode m c) P = 0 ↔ P = 0)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Iff", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Polynomial.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.BLR.sign 1 = -1", + "type_dependencies": [ + "Eq", + "Rat", + "PCP.Algebraic.BLR.sign", + "OfNat.ofNat", + "ZMod", + "Nat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Neg.neg", + "Rat.instNeg", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Least numeric code of a full multiplicative generator. ", + "end_line": 95, + "is_class": false, + "kind": "definition", + "line": 92, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → PCP.Algebraic.ThreeColorFields.FieldFamily k", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorFields.FieldFamily" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.FiniteGeneratorSearch.root", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Equiv.decidableEq", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.ThreeColorFields.fieldCode", + "instDecidableEqFin", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 183, + "is_class": false, + "kind": "theorem", + "line": 181, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_clause", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (e : C) {i j : Fin 3},\n i ≠ j →\n (PCP.Reduction.NAEThreeColor.graph Q).Adj (PCP.Reduction.NAEThreeColor.clauseVertex e i)\n (PCP.Reduction.NAEThreeColor.clauseVertex e j)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Ne", + "SimpleGraph.Adj", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "PCP.Reduction.NAEThreeColor.clauseVertex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.edgeValue.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (x : Fin (n + n) → F),\n PCP.Algebraic.ThreeColorVerifier.edgeValue H G x =\n (MvPolynomial.eval (x ∘ ⇑(PCP.Algebraic.ThreeColorVerifier.flatten n)))\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Function.comp", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_mul_left", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (c : ℚ) (f : α → ℚ),\n (PCP.Algebraic.BLR.average fun x => c * f x) = c * PCP.Algebraic.BLR.average f", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Mathematical guarantees for one verifier on all encoded inputs.\nNo efficient implementation or NP-completeness result is asserted here. ", + "end_line": 174, + "is_class": false, + "kind": "theorem", + "line": 166, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.verification_guarantees", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.queries = 187 ∧\n PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.CanonicalRandomness 32000000 32000000 ∧\n (∀ (x : List Bool),\n PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.ReadsBelow x\n (Polynomial.eval x.length PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound)) ∧\n (∀ (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.CompleteAt x) ∧\n ∀ (x : List Bool),\n ¬(PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.SoundAt x\n (1 - PCP.Algebraic.ThreeColorBinaryVerifier.gap)", + "type_dependencies": [ + "And", + "Eq", + "Nat", + "PCP.Verifier.queries", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "Nat.instSemiring", + "List.length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HSub.hSub", + "Rat", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a : V) (a_1 : Bool) (b : V) (b_1 : Bool),\n ¬a = b → PCP.Reduction.NAEThreeColor.Literal.var a a_1 = PCP.Reduction.NAEThreeColor.Literal.var b b_1 → False", + "type_dependencies": [ + "Bool", + "Not", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.var", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 53, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.coe_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} (H : Finset F) (a b : σ → ↥H),\n (fun i => ↑(Sum.elim a b i)) = Sum.elim (fun i => ↑(a i)) fun i => ↑(b i)", + "type_dependencies": [ + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "Sum", + "Subtype.val", + "Sum.elim" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.difference" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual rejection with the newly sampled primary correction seed. ", + "end_line": 183, + "is_class": false, + "kind": "definition", + "line": 177, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t r : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Q : (Fin n → F) → Polynomial F) →\n (∀ (x : Fin n → F), (Q x).natDegree ≤ r) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n ((Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Option", + "Prod", + "instFintypeProd", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeGridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed._proof_1", + "Option.instDecidableEq", + "instDecidableEqProd", + "ZMod.decidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "Option.some", + "Prod.mk", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 105, + "is_class": false, + "kind": "definition", + "line": 104, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.RawSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.size", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual input-and-seed decision tree, with its original 187-bit query budget. ", + "end_line": 89, + "is_class": false, + "kind": "definition", + "line": 83, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.tree", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : List Bool) → Fin (2 ^ PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget x.length) → PCP.QueryTree 187", + "type_dependencies": [ + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "List.length", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "List.length", + "PCP.QueryTree.compileWordBounded", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Fintype.card", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "Fin.fintype", + "PCP.Algebraic.ThreeColorBinaryVerifier.queries", + "PCP.Algebraic.ThreeColorEncoding.graph", + "PCP.Algebraic.ThreeColorCanonicalVerifier.sample", + "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode", + "PCP.Algebraic.ThreeColorBinaryVerifier.test", + "PCP.Algebraic.ThreeColorCanonicalVerifier.fieldWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.tree._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Ignore precisely the excess bits of the canonical random string. ", + "end_line": 59, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : List Bool) →\n Fin (2 ^ PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget x.length) →\n PCP.Algebraic.ThreeColorBinaryVerifier.Seed (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x)", + "type_dependencies": [ + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "List.length", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder" + ], + "value_dependencies": [ + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "List.length", + "PCP.Algebraic.BinarySeedPadding.prefix", + "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBits_le_budget", + "DFunLike.coe", + "Equiv", + "PCP.Algebraic.BinarySeedPadding.Seed", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.BinarySeedPadding.finSeedEquiv" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d), (PCP.QueryTree.query a f t).addresses = insert a (f.addresses ∪ t.addresses)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "Finset", + "PCP.QueryTree.addresses", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 56, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodeTriple", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (t : List Bool × List Bool × List Bool),\n (PCP.Machine.encodeTriple t).length = t.1.length + t.2.1.length + t.2.2.length + 2", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "Nat", + "List.length", + "PCP.Machine.Sym", + "PCP.Machine.encodeTriple", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(P : (List Bool → List Bool → Bool) → Prop) →\n (L : PCP.Language) →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] →\n [(a : List Bool) → SizeOf (L a)] → SizeOf (PCP.NPCertificate P L)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "SizeOf.mk", + "PCP.NPCertificate", + "PCP.NPCertificate._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n 0 ≤ PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "LE.le", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 54, + "is_class": false, + "kind": "definition", + "line": 53, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.size", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 32, + "is_class": false, + "kind": "theorem", + "line": 31, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_variableCoeff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (x : Fin t → ZMod 2) (hr : 1 ≤ r) (i : Fin t),\n (PCP.Algebraic.Hadamard.encode r x) (PCP.Algebraic.BinaryPolynomialSpace.variableCoeff hr i) = x i", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness against an honestly encoded outer polynomial. The distance on\nthe left counts both `none` and an incorrect returned bit as failures. The inner\npolynomials are decoded from arbitrary received rows without a small-error premise. ", + "end_line": 313, + "is_class": false, + "kind": "theorem", + "line": 219, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {D : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) {δ : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) ≤\n δ →\n ∀ (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a)\n fun s =>\n some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2.2.1.2)) ≤\n PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a +\n δ +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "PCP.Algebraic.Hadamard.linearEncode", + "Prod.snd", + "Prod.fst", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Both required root orders divide the multiplicative group order. ", + "end_line": 73, + "is_class": false, + "kind": "theorem", + "line": 70, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fifteen_dvd_card_sub_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), 15 ∣ Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) - 1", + "type_dependencies": [ + "Nat", + "Dvd.dvd", + "Nat.instDvd", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The common field family for the degree-four tester and the three colors. ", + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.FieldFamily", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryMaterializedField.Element", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Acceptance probability, as an exact rational: the fraction of the `2 ^ randomness` equally\nlikely random strings on which `V` accepts. ", + "end_line": 104, + "is_class": false, + "kind": "definition", + "line": 101, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → PCP.ProofOracle → ℚ", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Rat" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.acceptingRandomness", + "Rat.instPowNat", + "Rat.instOfNat" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} → ℕ → Sort (max 1 u)", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "cond", + "Nat.ble", + "PULift", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 126, + "is_class": false, + "kind": "definition", + "line": 126, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.validCert a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "A ternary clause accepts exactly the nonconstant Boolean triples. ", + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.NAE", + "provenance": "lean", + "structural_dependencies": [], + "type": "(Fin 3 → Bool) → Prop", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Bool" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Bool", + "Or", + "Ne", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a : Bool), PCP.Reduction.NAEThreeColor.Literal.const a = PCP.Reduction.NAEThreeColor.Literal.const a", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.const" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_2.else_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {motive : Bool → Sort u} (t : Bool) (false : motive false) («else» : Nat.hasNotBit 1 t.ctorIdx → motive t)\n (h : Nat.hasNotBit 1 t.ctorIdx),\n PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_2 t false «else» = «else» h", + "type_dependencies": [ + "Bool", + "Bool.false", + "Nat.hasNotBit", + "Bool.ctorIdx", + "Eq", + "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_2" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness for every seed of the actual seven-branch conjunction. ", + "end_line": 98, + "is_class": false, + "kind": "theorem", + "line": 82, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.test_honestProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (P : MvPolynomial (Fin n) F)\n (MVal : MvPolynomial (Fin n ⊕ Fin n) F) (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n P.totalDegree < m ^ c →\n MVal.totalDegree < m ^ c →\n MProp.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal →\n PCP.Algebraic.GridVanishing.IsCertificate H\n ((MvPolynomial.rename ⇑(PCP.Algebraic.ThreeColorVerifier.flatten n))\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)))\n MProp →\n ∀ (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G\n (PCP.Algebraic.ThreeColorVerifier.honestProof ρ P MVal MProp) s =\n true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "DFunLike.coe", + "AlgHom", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "PCP.Algebraic.ThreeColorVerifier.honestProof", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.completeAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CompleteAt x", + "type_dependencies": [ + "List", + "Bool", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Verifier.CompleteAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V],\n Fintype.card V ≤\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)) ^\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))", + "type_dependencies": [ + "Fintype", + "LE.le", + "Nat", + "instLENat", + "Fintype.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness with an explicit upper bound on the rejection probability. ", + "end_line": 325, + "is_class": false, + "kind": "theorem", + "line": 320, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.exists_linearMap_distance_le_of_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (H : (ι → ZMod 2) → ZMod 2) {ε : ℚ},\n PCP.Algebraic.BLR.rejectionProbability H ≤ ε → ∃ L, PCP.Algebraic.relativeDistance H ⇑L ≤ ε", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.BLR.rejectionProbability", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Exists", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.relativeDistance", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap.instFunLike" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness at `x`: some proof is accepted with probability 1. ", + "end_line": 131, + "is_class": false, + "kind": "definition", + "line": 130, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CompleteAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → Prop", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Exists", + "PCP.ProofOracle", + "Eq", + "Rat", + "PCP.Verifier.accProb", + "OfNat.ofNat", + "Rat.instOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Exact normalized rejection of the seven-check finite verifier. ", + "end_line": 405, + "is_class": false, + "kind": "definition", + "line": 401, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F → (H : Finset F) → SimpleGraph (Fin n → ↥H) → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.FiniteConjunction.rejectionRate", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.fintype", + "instDecidableEqFin", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)),\n sizeOf\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n 1", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "SizeOf.sizeOf", + "PCP.CostModel", + "PCP.CostModel._sizeOf_inst", + "PCP.CostModel.mk", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardCorrection", + "name": "PCP.Algebraic.Hadamard.selfCorrect.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {W : Type u_2} [inst : AddCommGroup V] [inst_1 : AddCommGroup W] (w : V → W) (P R : V),\n PCP.Algebraic.Hadamard.selfCorrect w P R = w (P + R) - w R", + "type_dependencies": [ + "AddCommGroup", + "Eq", + "PCP.Algebraic.Hadamard.selfCorrect", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "HAdd.hAdd", + "instHAdd", + "AddCommMagma.toAdd", + "AddCommSemigroup.toAddCommMagma", + "AddCommMonoid.toAddCommSemigroup", + "AddCommGroup.toAddCommMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 52, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.scope_firstSlot", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ} (s : C → Fin d → V) (v : V) (j : Fin a),\n PCP.Reduction.FiniteDomainConstraints.scope s (Sum.inr v) (PCP.Reduction.FiniteDomainConstraints.firstSlot j) =\n (Sum.inl v, j)", + "type_dependencies": [ + "Nat", + "Fin", + "Eq", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.scope", + "Sum.inr", + "PCP.Reduction.FiniteDomainConstraints.firstSlot", + "Prod.mk", + "Sum", + "Unit", + "Sum.inl" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.const.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : SizeOf V] (a : Bool), sizeOf (PCP.Reduction.NAEThreeColor.Literal.const a) = 1 + sizeOf a", + "type_dependencies": [ + "SizeOf", + "Bool", + "Eq", + "Nat", + "SizeOf.sizeOf", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal._sizeOf_inst", + "PCP.Reduction.NAEThreeColor.Literal.const", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Bool._sizeOf_inst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n PCP.Algebraic.ThreeColorParameterChoice.exponent N * 2 ^ PCP.Algebraic.ThreeColorParameterChoice.exponent N ≤\n 32 * (Nat.clog 2 N + 1) →\n ¬132000 *\n (PCP.Algebraic.ThreeColorParameterChoice.exponent N *\n 2 ^ PCP.Algebraic.ThreeColorParameterChoice.exponent N) ≤\n 4224000 * (Nat.clog 2 N + 1) →\n False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Nat.clog", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.canonicalAssignment.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (tm : Turing.FinTM2) (T B : ℕ) (initial initial_1 : tm.Cfg) (e_initial : initial = initial_1)\n (hs : PCP.Machine.StackSupported tm initial.stk),\n PCP.Machine.TableauCells.canonicalAssignment tm T B initial hs =\n PCP.Machine.TableauCells.canonicalAssignment tm T B initial_1 ⋯", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "Eq", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.TableauCells.Assignment", + "PCP.Machine.TableauCells.canonicalAssignment", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Apply a binary linear functional to every formal coefficient. This operation\nis linear, but is deliberately not assumed to preserve multiplication. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.mapCoefficients", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : CommRing F] →\n [inst_1 : Algebra (ZMod 2) F] → (F →ₗ[ZMod 2] ZMod 2) → MvPolynomial σ F → MvPolynomial σ (ZMod 2)", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Algebra.toModule", + "Semiring.toModule", + "MvPolynomial" + ], + "value_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Algebra.toModule", + "Semiring.toModule", + "MvPolynomial", + "Finset.sum", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "AddMonoidAlgebra.instAddCommMonoid", + "MvPolynomial.support", + "DFunLike.coe", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "MvPolynomial.monomial", + "instMulZeroClassOfSemiring", + "Finsupp.instFunLike", + "AddMonoidAlgebra.coeff" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "recursor", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n (t : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) → motive t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The common label keeps its uniform marginal when the two independent call seeds are added. ", + "end_line": 83, + "is_class": false, + "kind": "theorem", + "line": 74, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.distance_lift_labels", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} {S : Type u_3} {A : Type u_4} [inst : Fintype X] [inst_1 : Fintype W]\n [inst_2 : Fintype S] [Nonempty S] [inst_4 : DecidableEq A] (f g : X × W → A),\n (PCP.Algebraic.relativeDistance (fun s => f (s.1, s.2.1)) fun s => g (s.1, s.2.1)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual all-parameter rejection probability equals the error of these predictions. ", + "end_line": 128, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.prediction_error_eq_rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ c),\n (PCP.Algebraic.relativeDistance (fun s => f s.1) fun s => PCP.Algebraic.PointLineTest.prediction table s.1 s.2) =\n PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "Prod.fst", + "PCP.Algebraic.PointLineTest.prediction", + "Prod.snd", + "PCP.Algebraic.PointLineTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Pack the actual supported symbols, filling unused positions by `none`. ", + "end_line": 53, + "is_class": false, + "kind": "definition", + "line": 49, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.encodeCells", + "provenance": "lean", + "structural_dependencies": [], + "type": "{tm : Turing.FinTM2} →\n (B : ℕ) → (c : tm.Cfg) → PCP.Machine.StackSupported tm c.stk → PCP.Machine.TableauCells.Cells tm B", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.TableauCells.Cells" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "Fin", + "dite", + "Option", + "PCP.Machine.ComputationTableau.Symbol", + "LT.lt", + "instLTNat", + "Fin.val", + "List.length", + "Nat.decLt", + "Option.some", + "Subtype.mk", + "PCP.Machine.Supported", + "GetElem.getElem", + "List", + "List.instGetElemNatLtLength", + "PCP.Machine.TableauCells.encodeCells._proof_1", + "Not", + "Option.none" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The randomness budget is **exactly** `a * ⌈log₂ (n + 2)⌉ + b`.\n\nTwo constants determine the whole budget, so it is computable by construction and carries no\ninformation of its own. This is the \"canonical computable budget\" repair: it closes the hole that\n`LogRandomness` leaves open, and it is without loss of generality because a verifier that wants\nfewer bits can ignore the surplus. ", + "end_line": 155, + "is_class": false, + "kind": "definition", + "line": 148, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CanonicalRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ → ℕ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "Eq", + "PCP.Verifier.randomness", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 375, + "is_class": false, + "kind": "definition", + "line": 375, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.exists_program._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) [DecidableEq h.tm.Λ]\n [DecidableEq h.tm.σ] [(k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)],\n PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk →\n ∀ {k a : ℕ} (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (P : PCP.Lang.Prog)\n (A C D : ℕ) (x : List Bool),\n PCP.Lang.listSize\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q) x) ≤\n A * (2 * x.length + 1) →\n ¬PCP.Lang.listSize\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q)\n x) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1 ≤\n A * (2 * x.length + 1) + Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1 →\n False", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Lang.Prog", + "LE.le", + "instLENat", + "PCP.Lang.listSize", + "PCP.Machine.NPTableauSource.input", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "In every dimension, an arbitrary degree-zero table yields a nearby constant function. ", + "end_line": 157, + "is_class": false, + "kind": "theorem", + "line": 152, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.exists_constant_close_degree_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ 0),\n ∃ a, (PCP.Algebraic.relativeDistance f fun x => a) ≤ 2 * PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Exists", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.PointLineTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.tree._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool) (r : Fin (2 ^ PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget x.length)),\n (PCP.Algebraic.ThreeColorBinaryVerifier.queries (PCP.Algebraic.ThreeColorEncoding.graph x)\n (PCP.Algebraic.ThreeColorCanonicalVerifier.sample x r)\n (PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode x)).length ≤\n 187", + "type_dependencies": [ + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "List.length", + "LE.le", + "instLENat", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Fintype.card", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "Fin.fintype", + "PCP.Algebraic.ThreeColorBinaryVerifier.queries", + "PCP.Algebraic.ThreeColorEncoding.graph", + "PCP.Algebraic.ThreeColorCanonicalVerifier.sample", + "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 80, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.decode_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (π : PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof N),\n PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof (PCP.Algebraic.ThreeColorBinaryVerifier.encodeProof π) = π", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof", + "Eq", + "PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof", + "PCP.Algebraic.ThreeColorBinaryVerifier.encodeProof" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Correlation with a Walsh character is precisely the agreement bias. ", + "end_line": 303, + "is_class": false, + "kind": "theorem", + "line": 300, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier_sign_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (H : (ι → ZMod 2) → ZMod 2) (a : ι → ZMod 2),\n PCP.Algebraic.BLR.fourier (fun x => PCP.Algebraic.BLR.sign (H x)) a =\n 1 - 2 * PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.BLR.linearForm a)", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.sign", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Normalized rational Walsh coefficient. ", + "end_line": 194, + "is_class": false, + "kind": "definition", + "line": 192, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier", + "provenance": "lean", + "structural_dependencies": [], + "type": "{ι : Type u_1} → [Fintype ι] → [DecidableEq ι] → ((ι → ZMod 2) → ℚ) → (ι → ZMod 2) → ℚ", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "PCP.Algebraic.BLR.fourier._proof_1", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.coeff_series._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {n : ℕ} {a b : Fin n}, (↑a = ↑b) = (a = b)", + "type_dependencies": [ + "Nat", + "Fin", + "Eq", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b c : Bool), Function.Injective (PCP.Reduction.NAEThreeColor.triangleWitness a b c)", + "type_dependencies": [ + "Bool", + "Function.Injective", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.triangleWitness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The virtual point-line rejection factor, after both binary decoding steps. ", + "end_line": 47, + "is_class": false, + "kind": "definition", + "line": 45, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "Rat", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instAddNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The NP checking relation induced by a verifier: accept `(x, w)` when the finite witness `w`,\nread as a proof, makes `V` accept on *every* random string.\n\nThis is decidable because the random space `Fin (2 ^ randomness)` is finite, which is the whole\npoint: perfect completeness turns into a finite check. Whether it is *polynomial-time* decidable\nis a separate question, answered by `CostModel.polyTimeRel_finiteWitnessCheck`. ", + "end_line": 210, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Verifier.Definition", + "name": "PCP.finiteWitnessCheck", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → List Bool → Bool", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Decidable.decide", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Eq", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "PCP.oracleOfWitness", + "Bool.true", + "Nat.decidableForallFin", + "instDecidableEqBool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Package a family of coefficient polynomials into one polynomial in two blocks. ", + "end_line": 77, + "is_class": false, + "kind": "definition", + "line": 75, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → [Fintype σ] → (σ → MvPolynomial σ R) → MvPolynomial (σ ⊕ σ) R", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum" + ], + "value_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Finset.sum", + "Sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "DFunLike.coe", + "AlgHom", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Sum.inl", + "MvPolynomial.X", + "Sum.inr" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n (motive : PCP.Reduction.NAEThreeColor.Literal V → PCP.Reduction.NAEThreeColor.Literal V → Sort u_2) →\n (x x_1 : PCP.Reduction.NAEThreeColor.Literal V) →\n ((a b : Bool) →\n motive (PCP.Reduction.NAEThreeColor.Literal.const a) (PCP.Reduction.NAEThreeColor.Literal.const b)) →\n ((a : Bool) →\n (a_1 : V) →\n (a_2 : Bool) →\n motive (PCP.Reduction.NAEThreeColor.Literal.const a)\n (PCP.Reduction.NAEThreeColor.Literal.var a_1 a_2)) →\n ((a : V) →\n (a_1 a_2 : Bool) →\n motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)\n (PCP.Reduction.NAEThreeColor.Literal.const a_2)) →\n ((a : V) →\n (a_1 : Bool) →\n (b : V) →\n (b_1 : Bool) →\n motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)\n (PCP.Reduction.NAEThreeColor.Literal.var b b_1)) →\n motive x x_1", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.Literal.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 22, + "is_class": false, + "kind": "theorem", + "line": 20, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.goodNodes_of_generator", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} {ζ : F} [inst_1 : Fintype F],\n 2 * c < Fintype.card F → IsPrimitiveRoot ζ (Fintype.card F - 1) → PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 212, + "is_class": false, + "kind": "theorem", + "line": 210, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.decode_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x y : Fin 3),\n x ≠ 2 →\n y ≠ 2 →\n x ≠ y →\n x = PCP.Reduction.NAEThreeColor.boolColor (decide (x = 1)) ∧\n y = PCP.Reduction.NAEThreeColor.boolColor !decide (x = 1)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Ne", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "And", + "Eq", + "PCP.Reduction.NAEThreeColor.boolColor", + "Decidable.decide", + "instDecidableEqFin", + "Bool.not" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "On a row with at most `e` errors, the certificate numerator is exactly the\nrow polynomial times the certificate locator. The identity includes zero slices. ", + "end_line": 156, + "is_class": false, + "kind": "theorem", + "line": 139, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.certificate_row_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype I] {d e : ℕ} (a : I → F),\n Function.Injective a →\n ∀ (C : I → Polynomial F) (R : F → Polynomial F) (E N : MvPolynomial (Fin 2) F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n MvPolynomial.degreeOf 0 E ≤ e →\n MvPolynomial.degreeOf 0 N ≤ d + e →\n (∀ (i : I),\n PCP.Algebraic.PointLineCrossing.rowPolynomial N (a i) =\n C i * PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i)) →\n d + 2 * e < Fintype.card I →\n ∀ (y : F),\n (PCP.Algebraic.BerlekampWelch.errors a (fun i => Polynomial.eval y (C i)) (R y)).card ≤ e →\n PCP.Algebraic.PointLineCrossing.columnPolynomial N y =\n R y * PCP.Algebraic.PointLineCrossing.columnPolynomial E y", + "type_dependencies": [ + "Field", + "Fintype", + "Nat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial.degreeOf", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "LT.lt", + "instLTNat", + "instMulNat", + "Fintype.card", + "Finset.card", + "PCP.Algebraic.BerlekampWelch.errors", + "Polynomial.eval", + "PCP.Algebraic.PointLineCrossing.columnPolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The low-degree extension of the input graph's zero-one adjacency table. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 59, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [Fintype σ] → [DecidableEq σ] → [DecidableEq F] → (H : Finset F) → SimpleGraph (σ → ↥H) → MvPolynomial (σ ⊕ σ) F", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Sum", + "MvPolynomial", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.GridInterpolation.interpolate", + "instFintypeSum", + "instDecidableEqSum", + "ite", + "SimpleGraph.Adj", + "Sum.inl", + "Sum.inr", + "Classical.propDecidable", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 68, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.distance_shared_snd", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} {A : Type u_4} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S]\n [inst_3 : DecidableEq A] (f g : W × S → A),\n (PCP.Algebraic.relativeDistance (fun s => f (s.1, s.2.2)) fun s => g (s.1, s.2.2)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A binary relation on bit strings is polynomial-time when some `FinTM2` machine computes it\nwithin a polynomial number of steps in the encoded input length. ", + "end_line": 67, + "is_class": false, + "kind": "definition", + "line": 64, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.PolyTimeRel", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → List Bool → Bool) → Prop", + "type_dependencies": [ + "List", + "Bool" + ], + "value_dependencies": [ + "List", + "Bool", + "Nonempty", + "Turing.TM2ComputableInPolyTime", + "Prod", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each prefix position is linked to its corresponding individual stack cell. ", + "end_line": 92, + "is_class": false, + "kind": "definition", + "line": 90, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.Linked", + "provenance": "lean", + "structural_dependencies": [], + "type": "{tm : Turing.FinTM2} → {B : ℕ} → PCP.Machine.TableauCells.Prefix tm → PCP.Machine.TableauCells.Cells tm B → Prop", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "Fin", + "PCP.Machine.TM2Locality.machineWindow", + "Eq", + "Option", + "Turing.FinTM2.Γ", + "GetElem?.getElem?", + "List", + "LT.lt", + "instLTNat", + "List.length", + "List.instGetElem?NatLtLength", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.ComputationTableau.decodeRow", + "Fin.val", + "PCP.Machine.TableauCells.readCell" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Auxiliary inner rejection is another normalized marginal of actual rejection. ", + "end_line": 145, + "is_class": false, + "kind": "theorem", + "line": 114, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.inner_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n (Finset.univ.expect fun uv => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate ⋯ ρ nodes (H uv)) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "Finset.expect", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.SetMultilinear.Variables", + "Fin.fintype", + "instDecidableEqProd", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "definition", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ),\n ¬n ≤ c + 1 → ∀ (i : Fin (c + 1)), ↑i < c → ¬↑i + 1 + (n - (c + 1)) < n → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "LT.lt", + "instLTNat", + "Fin.val", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 153, + "is_class": false, + "kind": "theorem", + "line": 151, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character_add", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x y : ι → ZMod 2),\n PCP.Algebraic.BLR.character a (x + y) = PCP.Algebraic.BLR.character a x * PCP.Algebraic.BLR.character a y", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.character", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "constructor", + "line": 127, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.witnessList", + "provenance": "lean", + "structural_dependencies": [], + "type": "{W : ℕ} → PCP.Machine.NPTableau.BoundedWitness W → List Bool", + "type_dependencies": [ + "Nat", + "PCP.Machine.NPTableau.BoundedWitness", + "List", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.Machine.NPTableau.BoundedWitness", + "List.ofFn", + "Bool", + "Fin.val", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Sigma.fst", + "Fin", + "Sigma.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The tree reads at most `d` bits along any branch: its address set has at most `2 ^ d - 1`\nelements, and along a single run at most `d` queries are made. ", + "end_line": 65, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (T : PCP.QueryTree d), T.addresses.card < 2 ^ d", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "theorem", + "line": 132, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.readsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.ReadsBelow x\n (Polynomial.eval x.length PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "Polynomial.eval", + "Nat", + "Nat.instSemiring", + "List.length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The full bit-input construction has one program and proved polynomial cost and output size. ", + "end_line": 116, + "is_class": false, + "kind": "theorem", + "line": 62, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.exists_program", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n ∃ P pc ps,\n ∀ (x : List Bool),\n P.run (List.map Bool.toNat x) = List.map Bool.toNat (PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x) ∧\n P.cost (List.map Bool.toNat x) ≤ Polynomial.eval x.length pc ∧\n PCP.Lang.listSize (P.run (List.map Bool.toNat x)) ≤ Polynomial.eval x.length ps", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "Exists", + "PCP.Lang.Prog", + "And", + "Eq", + "PCP.Lang.Prog.run", + "List.map", + "Bool.toNat", + "PCP.Reduction.NPThreeColorRuntime.encode", + "LE.le", + "instLENat", + "PCP.Lang.Prog.cost", + "Polynomial.eval", + "List.length", + "PCP.Lang.listSize" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The section 5 procedure; `none` denotes rejection. ", + "end_line": 59, + "is_class": false, + "kind": "definition", + "line": 44, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n (σ → F) →\n (σ → F) →\n Fˣ →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n (Fin t → ZMod 2) → PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t → Option (ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Option" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "ite", + "Option", + "Eq", + "Bool", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "Bool.true", + "instDecidableEqBool", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq", + "Option.some", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Option.none" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual bounded query of Claim 3.7, stored in finite binary coefficient coordinates. ", + "end_line": 150, + "is_class": false, + "kind": "definition", + "line": 146, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.query", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : CommRing F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (P : Polynomial F) →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 →\n P.natDegree ≤ r → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "Polynomial.natDegree" + ], + "value_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.coefficients", + "DFunLike.coe", + "LinearMap", + "MvPolynomial", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.multilinearReduction", + "PCP.Algebraic.HadamardComposition.formalQuery" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.firstSlot._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ}, 0 < max 1 d", + "type_dependencies": [ + "Nat", + "LT.lt", + "Preorder.toLT", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Reindexing the actual full corrector sample separates its uniform requested label. ", + "end_line": 244, + "is_class": false, + "kind": "theorem", + "line": 209, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.call_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (M : MvPolynomial (Fin n ⊕ Fin n) F),\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n {δ : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δ →\n ∀ (a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n),\n (PCP.Algebraic.relativeDistance\n (fun ws => PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M' A a ws.1 ws.2)\n fun ws => some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) M))) ws.1)) ≤\n (PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.AffineLineSampling.fraction fun ws =>\n PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M' A a ws.1 ws.2 = none) +\n δ +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.relativeDistance", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeCallSeedSumFin_1", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "Prod.fst", + "Prod.snd", + "Option.some", + "PCP.Algebraic.Hadamard.linearEncode", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.AffineLineSampling.fraction", + "Eq", + "Option.none", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Rat.instOfNat", + "HSub.hSub", + "instHSub", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 133, + "is_class": false, + "kind": "theorem", + "line": 132, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2), (PCP.Algebraic.BLR.linearForm a) x = ∑ i, a i * x i", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm", + "Finset.sum", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 385, + "is_class": false, + "kind": "theorem", + "line": 385, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F] {m c t : ℕ}, Nonempty (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.eval_substitute", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R) (M : MvPolynomial (σ ⊕ σ) R) (x : σ → R),\n (MvPolynomial.eval x) ((PCP.Algebraic.GridVanishing.substitute Y) M) =\n (MvPolynomial.eval (Sum.elim x fun i => (MvPolynomial.eval x) (Y i))) M", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.GridVanishing.substitute", + "Sum.elim" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate_eq_check_distance._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b ≠ 0) = (a ≠ b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "Ne", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.5, in Boolean coordinates. ", + "end_line": 26, + "is_class": false, + "kind": "definition", + "line": 24, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t : ℕ} → (r : ℕ) → (Fin t → ZMod 2) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r →ₗ[ZMod 2] ZMod 2", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.evaluate" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Shift the line center so a fresh parameter reaches the original fixed point. ", + "end_line": 44, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.parameterShiftEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → F → ((σ → F) × (σ → F)) × F ≃ ((σ → F) × (σ → F)) × F", + "type_dependencies": [ + "Field", + "Equiv", + "Prod" + ], + "value_dependencies": [ + "Field", + "Equiv.mk", + "Prod", + "Prod.mk", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Prod.snd", + "Pi.instSub", + "PCP.Algebraic.PointLineTest.parameterShiftEquiv._proof_1", + "PCP.Algebraic.PointLineTest.parameterShiftEquiv._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A polynomial of individual degree below the grid size is determined on that grid. ", + "end_line": 143, + "is_class": false, + "kind": "theorem", + "line": 112, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.eq_zero_of_eval_grid_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] {m : ℕ} (H : Finset 𝔽) (p : MvPolynomial (Fin m) 𝔽),\n (∀ (i : Fin m), MvPolynomial.degreeOf i p < H.card) →\n (∀ (a : Fin m → ↥H), (MvPolynomial.eval fun i => ↑(a i)) p = 0) → p = 0", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LT.lt", + "instLTNat", + "MvPolynomial.degreeOf", + "Finset.card", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.expect_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : Fintype B] (k : A × B → ℚ),\n (Finset.univ.expect fun p => k p) = Finset.univ.expect fun a => Finset.univ.expect fun b => k (a, b)", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The local constraints force every cell and control value to equal the true computation. ", + "end_line": 254, + "is_class": false, + "kind": "theorem", + "line": 234, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.satisfies_represents", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {T B : ℕ} {initial final : tm.Cfg} {a : PCP.Machine.TableauCells.Assignment tm T B},\n PCP.Machine.TableauCells.Satisfies tm T B initial final a →\n PCP.Machine.mass initial.stk + PCP.Machine.machinePushBound tm * T ≤ B →\n ∀ (i : Fin (T + 1)), PCP.Machine.TableauCells.Represents (a.1 i) (a.2 i) (PCP.Machine.boundedEval tm (↑i) initial)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Assignment", + "PCP.Machine.TableauCells.Satisfies", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.mass", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.kFin", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Machine.machinePushBound", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.TableauCells.Represents", + "Prod.fst", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Prod.snd", + "PCP.Machine.boundedEval", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language}\n [inst : (a : List Bool → List Bool → Bool) → SizeOf (P a)] [inst_1 : (a : List Bool) → SizeOf (L a)]\n (witnessBound : Polynomial ℕ) (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true),\n sizeOf { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n 1 + sizeOf witnessBound + sizeOf check_polyTime", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "SizeOf.sizeOf", + "PCP.NPCertificate", + "PCP.NPCertificate._sizeOf_inst", + "PCP.NPCertificate.mk", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial._sizeOf_inst", + "instSizeOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Stop and accept (`true`) or reject (`false`). ", + "end_line": 35, + "is_class": false, + "kind": "constructor", + "line": 34, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf", + "provenance": "lean", + "structural_dependencies": [ + "PCP.QueryTree" + ], + "type": "{d : ℕ} → Bool → PCP.QueryTree d", + "type_dependencies": [ + "Nat", + "Bool", + "PCP.QueryTree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The existence and uniqueness part of Fact 2.4, for a nonempty grid alphabet. ", + "end_line": 183, + "is_class": false, + "kind": "theorem", + "line": 169, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.existsUnique_extension", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] {m : ℕ} (H : Finset 𝔽),\n H.Nonempty →\n ∀ (f : (Fin m → ↥H) → 𝔽),\n ∃! p,\n (∀ (i : Fin m), MvPolynomial.degreeOf i p ≤ H.card - 1) ∧\n ∀ (a : Fin m → ↥H), (MvPolynomial.eval fun i => ↑(a i)) p = f a", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "Finset.Nonempty", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "ExistsUnique", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.degreeOf", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 73, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.eval_interpolateSlices", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n d : ℕ} (a : Fin (d + 1) → F) (P : Fin (d + 1) → MvPolynomial (Fin n) F) (x : F)\n (y : Fin n → F),\n (MvPolynomial.eval (Fin.cons x y)) (PCP.Algebraic.PolynomialLine.interpolateSlices a P) =\n ∑ i, Polynomial.eval x (Lagrange.basis Finset.univ a i) * (MvPolynomial.eval y) (P i)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Fin.cons", + "PCP.Algebraic.PolynomialLine.interpolateSlices", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "Polynomial.eval", + "Lagrange.basis", + "instDecidableEqFin" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Close polynomial columns control the comparison error on every fixed `Y` row. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.BivariateAgreementBoost", + "name": "PCP.Algebraic.BivariateAgreementBoost.transverse_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (f : F × F → F)\n (C : F → Polynomial F),\n (∀ (x : F), (C x).natDegree ≤ d) →\n ∀ (P : MvPolynomial (Fin 2) F),\n (∀ (j : Fin 2), MvPolynomial.degreeOf j P ≤ d) →\n ∀ {ε ρ : ℚ},\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.2 (C z.1)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => (MvPolynomial.eval ![z.1, z.2]) P) ≤ ρ →\n ∀ (y : F),\n (PCP.Algebraic.relativeDistance (fun x => Polynomial.eval y (C x)) fun x =>\n (MvPolynomial.eval ![x, y]) P) ≤\n ε + ρ + ↑d / ↑(Fintype.card F)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Prod", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial.degreeOf", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "Prod.snd", + "Prod.fst", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 175, + "is_class": false, + "kind": "theorem", + "line": 173, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_variable_base", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (v : V) (b : Bool),\n (PCP.Reduction.NAEThreeColor.graph Q).Adj (PCP.Reduction.NAEThreeColor.variableVertex v b)\n (PCP.Reduction.NAEThreeColor.base 2)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "SimpleGraph.Adj", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "PCP.Reduction.NAEThreeColor.variableVertex", + "PCP.Reduction.NAEThreeColor.base", + "Fin.instOfNat", + "Nat.instNeZeroSucc" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 63, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.queries_of_not_valid", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t),\n ¬PCP.Algebraic.ThreeColorFullFieldSampling.Valid s →\n PCP.Algebraic.ThreeColorFullFieldSampling.queries ρ nodes ζ H G s = []", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "Not", + "PCP.Algebraic.ThreeColorFullFieldSampling.Valid", + "Eq", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorFullFieldSampling.queries", + "List.nil" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 88, + "is_class": false, + "kind": "theorem", + "line": 82, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.boundary_represents", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} {p : PCP.Machine.TableauCells.Prefix tm} {s : PCP.Machine.TableauCells.Cells tm B}\n {c : tm.Cfg},\n PCP.Machine.TableauCells.Boundary p s c →\n (∀ (k : tm.K), (c.stk k).length ≤ B) → PCP.Machine.TableauCells.Represents p s c", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Boundary", + "Turing.FinTM2.K", + "LE.le", + "instLENat", + "List.length", + "Turing.FinTM2.Γ", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.TableauCells.Represents" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Arbitrary received homogeneous-bit answers can be used as the comparator.\nTheir actual global point-and-label error is added without an independence assumption. ", + "end_line": 378, + "is_class": false, + "kind": "theorem", + "line": 354, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.binary_origin_error_le_comparison_add_oracle_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : DecidableEq F] {t : ℕ} {σ : Type u_3} [inst_1 : Field F] [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] {D : ℕ} (ρ : F → Fin t → ZMod 2),\n Function.Injective ρ →\n ∀ (T : (σ → F) → Polynomial F),\n (∀ (b : σ → F), (T b).natDegree ≤ D) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n ∀ (a : σ → F) (H : (σ → F) → (Fin t → ZMod 2) → ZMod 2),\n (PCP.Algebraic.relativeDistance\n (fun s => (PCP.Algebraic.Hadamard.linearEncode (ρ (Polynomial.eval 0 (T s.1)))) s.2) fun s =>\n (PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2) ≤\n ((PCP.Algebraic.relativeDistance\n (fun s => (PCP.Algebraic.Hadamard.linearEncode (ρ (Polynomial.eval (↑s.1.2) (T s.1.1)))) s.2)\n fun s => H (PCP.Algebraic.PolynomialLine.point a s.1.1 ↑s.1.2) s.2) +\n PCP.Algebraic.relativeDistance (fun s => H s.1 s.2) fun s =>\n (PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval s.1) P))) s.2) +\n ↑D / ↑(Fintype.card F - 1) / 2", + "type_dependencies": [ + "DecidableEq", + "Nat", + "Field", + "Fintype", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Polynomial.eval", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Prod.fst", + "Prod.snd", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Units", + "Semiring.toMonoid", + "instFintypeUnitsOfDecidableEq", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {t r : ℕ} →\n (motive : PCP.Algebraic.BinaryDifferenceConsistency.Query F σ t r → Sort u_3) →\n (x : PCP.Algebraic.BinaryDifferenceConsistency.Query F σ t r) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p)) →\n ((p : (σ ⊕ σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inr p)) → motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Sum", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Sum", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n PCP.Algebraic.ThreeColorEncoding.vertexCount x = PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "Nat", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.affineSamplingEquiv.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {V : Type u_2} [inst : DivisionRing 𝔽] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module 𝔽 V]\n (u u_1 : V),\n u = u_1 →\n ∀ (a a_1 : 𝔽) (e_a : a = a_1) (ha : a ≠ 0),\n PCP.Algebraic.affineSamplingEquiv u a ha = PCP.Algebraic.affineSamplingEquiv u_1 a_1 ⋯", + "type_dependencies": [ + "DivisionRing", + "AddCommGroup", + "Module", + "Ring.toSemiring", + "DivisionRing.toRing", + "AddCommGroup.toAddCommMonoid", + "Eq", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Equiv", + "PCP.Algebraic.affineSamplingEquiv", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Original solutions satisfy both the relation constraints and every one-hot validity check. ", + "end_line": 88, + "is_class": false, + "kind": "theorem", + "line": 72, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.encodeAssignment_holds", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ} (R : C → (Fin d → Fin a) → Bool) (s : C → Fin d → V) (x : V → Fin a),\n PCP.Reduction.FiniteDomainConstraints.Holds R s x →\n PCP.Reduction.FiniteBooleanConstraints.LocalHolds (PCP.Reduction.FiniteDomainConstraints.relation R)\n (PCP.Reduction.FiniteDomainConstraints.scope s) (PCP.Reduction.FiniteDomainConstraints.encodeAssignment x)", + "type_dependencies": [ + "Nat", + "Fin", + "Bool", + "PCP.Reduction.FiniteDomainConstraints.Holds", + "PCP.Reduction.FiniteBooleanConstraints.LocalHolds", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.relation", + "PCP.Reduction.FiniteDomainConstraints.scope", + "PCP.Reduction.FiniteDomainConstraints.encodeAssignment" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_clause_literal._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u} (r : V → V → Prop) (v w : V), (SimpleGraph.fromRel r).Adj v w = (v ≠ w ∧ (r v w ∨ r w v))", + "type_dependencies": [ + "Eq", + "SimpleGraph.Adj", + "SimpleGraph.fromRel", + "And", + "Ne", + "Or" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The two grid equations are precisely the vertex and edge constraints. ", + "end_line": 114, + "is_class": false, + "kind": "theorem", + "line": 90, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.constraints_iff_satisfies", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)) (P : MvPolynomial σ F),\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) ∧\n PCP.Algebraic.GridVanishing.VanishesOn H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)) ↔\n PCP.Algebraic.ThreeColorAlgebra.Satisfies G fun a => (MvPolynomial.eval fun i => ↑(a i)) P", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Iff", + "And", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "Sum", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.ThreeColorAlgebra.Satisfies", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match d + 1, PCP.QueryTree.query a f t with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_2 d a f t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.addresses.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 75, + "is_class": false, + "kind": "definition", + "line": 75, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.var.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u} →\n (t : PCP.Reduction.NAEThreeColor.Literal V) →\n t.ctorIdx = 1 → ((a : V) → (a_1 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)) → motive t", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "Nat", + "PCP.Reduction.NAEThreeColor.Literal.ctorIdx", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "Nat", + "PCP.Reduction.NAEThreeColor.Literal.ctorIdx", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.Literal.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.encodeProof.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (π : PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof N)\n (i : Fin (PCP.Algebraic.ThreeColorBinaryVerifier.proofLength N)),\n PCP.Algebraic.ThreeColorBinaryVerifier.encodeProof π i =\n PCP.Algebraic.ThreeColorVerifier.read π ((PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv N).symm i)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Eq", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.encodeProof", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "DFunLike.coe", + "Equiv", + "PCP.Algebraic.ThreeColorBinaryVerifier.Address", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 26, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.predict", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {V : Type u_2} →\n {I : Type u_3} →\n [inst : Field F] →\n [inst_1 : AddCommGroup V] → [_root_.Module F V] → [Fintype I] → (I → F) → (I → F) → (V → F) → V → V → F", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype" + ], + "value_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HAdd.hAdd", + "instHAdd", + "AddCommMagma.toAdd", + "AddCommSemigroup.toAddCommMagma", + "AddCommMonoid.toAddCommSemigroup", + "HSMul.hSMul", + "instHSMul", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodePair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : List Bool × List Bool), (PCP.Machine.encodePair p).length = p.1.length + p.2.length + 1", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "Nat", + "List.length", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a : V) (a_1 a_2 : Bool),\n PCP.Reduction.NAEThreeColor.Literal.var a a_1 = PCP.Reduction.NAEThreeColor.Literal.const a_2 → False", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.Literal.const", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 174, + "is_class": false, + "kind": "theorem", + "line": 160, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_character", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (a : ι → ZMod 2),\n PCP.Algebraic.BLR.average (PCP.Algebraic.BLR.character a) = if a = 0 then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BLR.character", + "ite", + "Zero.toOfNat0", + "Pi.instZero", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Fintype.decidablePiFintype", + "ZMod.decidableEq", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The affine query after substituting the coordinate polynomials. ", + "end_line": 129, + "is_class": false, + "kind": "definition", + "line": 125, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.formalQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : CommRing F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n Polynomial F → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → MvPolynomial (Fin t) (ZMod 2)", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "MvPolynomial" + ], + "value_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "AddMonoidAlgebra.commSemiring", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval₂Hom", + "MvPolynomial.C", + "PCP.Algebraic.HadamardComposition.outputCoordinate", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "AddMonoidAlgebra.instAddCommMonoid", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.polynomial" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every received row admits an actual bounded-degree polynomial satisfying\nboth distance bounds; there is no small-rejection hypothesis. ", + "end_line": 144, + "is_class": false, + "kind": "theorem", + "line": 106, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.exists_polynomial_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {c t r : ℕ},\n 2 * c < Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (a : Fin (c + 1) → F),\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes a →\n ∀ (H : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n ∃ Q,\n Q.totalDegree ≤ c ∧\n PCP.Algebraic.relativeDistance (fun p => H p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ ((MvPolynomial.eval x) Q)) ≤\n PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c *\n PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr H fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) Q)))) ≤\n PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c *\n PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "theorem", + "line": 78, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.generator_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {ζ : F}, IsPrimitiveRoot ζ (Fintype.card F - 1) → ζ ≠ 0", + "type_dependencies": [ + "Field", + "Fintype", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "Nat", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat", + "Ne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The concrete returned verdict depends only on the stated query list. ", + "end_line": 128, + "is_class": false, + "kind": "theorem", + "line": 108, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.check_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (s : PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t)\n (p p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A A' : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n (∀ q ∈ PCP.Algebraic.BinaryZeroOnGridCorrection.queries ρ nodes ζ H s,\n PCP.Algebraic.BinaryZeroOnGridCorrection.read p M A q =\n PCP.Algebraic.BinaryZeroOnGridCorrection.read p' M' A' q) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.check ρ nodes ζ H p M A s =\n PCP.Algebraic.BinaryZeroOnGridCorrection.check ρ nodes ζ H p' M' A' s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.BinaryZeroOnGridCorrection.queries", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.read", + "Option", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 24, + "is_class": false, + "kind": "constructor", + "line": 24, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.sep", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Machine.Sym" + ], + "type": "PCP.Machine.Sym", + "type_dependencies": [ + "PCP.Machine.Sym" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 52, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The three field elements representing the ordinary finite color set. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.colorValue", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → F → Fin 3 → F", + "type_dependencies": [ + "Field", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest encodings give the requested affine observation for every seed. ", + "end_line": 65, + "is_class": false, + "kind": "theorem", + "line": 57, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.answer_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (hP : P.natDegree ≤ r) (u : F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (R : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n PCP.Algebraic.HadamardDerivedOracle.answer ρ P hP (⇑(PCP.Algebraic.Hadamard.encode r (ρ u))) L R =\n (PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval u P))) L", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 120, + "is_class": false, + "kind": "theorem", + "line": 117, + "module": "PCP.Complexity.NPTableau", + "name": "_private.PCP.Complexity.NPTableau.0.PCP.Machine.NPTableau.haltList_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (tm : Turing.FinTM2), Function.Injective (Turing.haltList tm)", + "type_dependencies": [ + "Turing.FinTM2", + "Function.Injective", + "List", + "Turing.FinTM2.Γ", + "Turing.FinTM2.k₁", + "Turing.FinTM2.Cfg", + "Turing.haltList" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness with an explicit identity for the derived outer polynomial. ", + "end_line": 164, + "is_class": false, + "kind": "theorem", + "line": 151, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r)\n {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {H : Finset F} (f : (Fin n → F) → F) (P : MvPolynomial (Fin n) F),\n (∀ (x : Fin n → F), Polynomial.eval (f x) (Q x) = (MvPolynomial.eval x) P) →\n ∀ (M : MvPolynomial (Fin n ⊕ Fin n) F),\n M.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H P M →\n ∀ (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x))))\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M))))\n (PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M) s =\n some (0, 0)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "MvPolynomial", + "Eq", + "Polynomial.eval", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary", + "Option.some", + "Prod.mk", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueryBound.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ),\n PCP.Algebraic.ThreeColorVerifier.branchQueryBound c =\n ![2 * c + 18, 2 * c + 14, 2 * c + 18, 2 * c + 14, 6 * c + 20, 6 * c + 20, 3]", + "type_dependencies": [ + "Nat", + "Eq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.branchQueryBound", + "Matrix.vecCons", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 48, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.queries_pad", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorFullFieldSampling.queries ρ nodes ζ H G (PCP.Algebraic.ThreeColorFullFieldSampling.pad s) =\n PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Eq", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorFullFieldSampling.queries", + "PCP.Algebraic.ThreeColorFullFieldSampling.pad", + "PCP.Algebraic.ThreeColorVerifier.queries" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "definition", + "line": 128, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 3 →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool) (π : PCP.ProofOracle),\n PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord x π =\n PCP.Algebraic.ThreeColorCanonicalVerifier.fieldWord\n (PCP.QueryTree.wordOfOracle\n (PCP.Algebraic.ThreeColorBinaryVerifier.proofLength (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x)) π)", + "type_dependencies": [ + "List", + "Bool", + "PCP.ProofOracle", + "Eq", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.fieldWord", + "PCP.QueryTree.wordOfOracle", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.axisRestrict.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : DecidableEq σ] (u : σ → F) (i : σ),\n PCP.Algebraic.PointLineCrossing.axisRestrict u i =\n MvPolynomial.eval₂Hom Polynomial.C fun j => if j = i then Polynomial.X else Polynomial.C (u j)", + "type_dependencies": [ + "Field", + "DecidableEq", + "Eq", + "RingHom", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "PCP.Algebraic.PointLineCrossing.axisRestrict", + "MvPolynomial.eval₂Hom", + "Polynomial.commSemiring", + "Polynomial.C", + "ite", + "Polynomial.X", + "DFunLike.coe", + "RingHom.instFunLike" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a : Bool) (a_1 : V) (a_2 : Bool),\n PCP.Reduction.NAEThreeColor.Literal.const a = PCP.Reduction.NAEThreeColor.Literal.var a_1 a_2 → False", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 182, + "is_class": false, + "kind": "definition", + "line": 180, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.Query.difference" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.encodeCells._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} (B : ℕ) (c : tm.Cfg),\n PCP.Machine.StackSupported tm c.stk →\n ∀ (k : tm.K) (j : Fin B) (h : ↑j < (c.stk k).length), PCP.Machine.Supported tm k (c.stk k)[↑j]", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "Fin", + "LT.lt", + "instLTNat", + "Fin.val", + "List.length", + "PCP.Machine.Supported", + "GetElem.getElem", + "List", + "List.instGetElemNatLtLength" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : Bool), ¬a = b → PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit b → False", + "type_dependencies": [ + "Bool", + "Not", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) → Function.Injective (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Function.Injective", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n (PCP.Algebraic.SetMultilinear.encode m c) P =\n ∑ k ∈ P.support, P.coeff k • PCP.Algebraic.SetMultilinear.digitMonomial m c k", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Finset.sum", + "Polynomial.support", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "instMulZeroClassOfSemiring", + "Finsupp.instFunLike", + "Polynomial.coeff", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "theorem", + "line": 75, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.spacePoly_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (n : ℕ),\n Polynomial.eval n (PCP.Machine.NPTableau.spacePoly h q) =\n n + Polynomial.eval n q + 1 +\n PCP.Machine.machinePushBound h.tm * Polynomial.eval n (PCP.Machine.NPTableau.timePoly h q)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "Polynomial.eval", + "PCP.Machine.NPTableau.spacePoly", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Machine.machinePushBound", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "PCP.Machine.NPTableau.timePoly" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 416, + "is_class": false, + "kind": "theorem", + "line": 413, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n 0 ≤ PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "LE.le", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t r : ℕ} →\n [Fintype F] →\n Fintype (PCP.Algebraic.Hadamard.TestRandomness t r × PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 227, + "is_class": false, + "kind": "theorem", + "line": 222, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.eval_rowPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (P : MvPolynomial (Fin 2) F) (x y : F),\n Polynomial.eval y (PCP.Algebraic.PointLineCrossing.rowPolynomial P x) = (MvPolynomial.eval ![x, y]) P", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Polynomial.eval", + "CommSemiring.toSemiring", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 89, + "is_class": false, + "kind": "definition", + "line": 89, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.variableVertex", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → {C : Type u_2} → V → Bool → PCP.Reduction.NAEThreeColor.Vertex V C", + "type_dependencies": [ + "Bool", + "PCP.Reduction.NAEThreeColor.Vertex" + ], + "value_dependencies": [ + "Bool", + "Sum.inr", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum", + "Prod", + "Sum.inl", + "Prod.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same control value and all padded cells determine a represented configuration. ", + "end_line": 178, + "is_class": false, + "kind": "theorem", + "line": 171, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.represents_unique", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} {p : PCP.Machine.TableauCells.Prefix tm} {s : PCP.Machine.TableauCells.Cells tm B}\n {c d : tm.Cfg}, PCP.Machine.TableauCells.Represents p s c → PCP.Machine.TableauCells.Represents p s d → c = d", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Represents", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each branch accepts the same honest eight-table proof for every seed. ", + "end_line": 79, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest_honestProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (P : MvPolynomial (Fin n) F)\n (MVal : MvPolynomial (Fin n ⊕ Fin n) F) (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n P.totalDegree < m ^ c →\n MVal.totalDegree < m ^ c →\n MProp.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal →\n PCP.Algebraic.GridVanishing.IsCertificate H\n ((MvPolynomial.rename ⇑(PCP.Algebraic.ThreeColorVerifier.flatten n))\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)))\n MProp →\n ∀ (i : Fin 7) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i),\n PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G\n (PCP.Algebraic.ThreeColorVerifier.honestProof ρ P MVal MProp) i s =\n true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "DFunLike.coe", + "AlgHom", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.branchTest", + "PCP.Algebraic.ThreeColorVerifier.honestProof", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.witnessList_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : ℕ} (w : PCP.Machine.NPTableau.BoundedWitness W), (PCP.Machine.NPTableau.witnessList w).length ≤ W", + "type_dependencies": [ + "Nat", + "PCP.Machine.NPTableau.BoundedWitness", + "LE.le", + "instLENat", + "List.length", + "Bool", + "PCP.Machine.NPTableau.witnessList" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The probability that a nonzero polynomial vanishes, in rational normalization. ", + "end_line": 32, + "is_class": false, + "kind": "theorem", + "line": 28, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.eval_zero_agreement_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] [inst_2 : DecidableEq 𝔽] {m : ℕ} (p : MvPolynomial (Fin m) 𝔽),\n p ≠ 0 → PCP.Algebraic.relativeAgreement (fun x => (MvPolynomial.eval x) p) 0 ≤ ↑p.totalDegree / ↑(Fintype.card 𝔽)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeAgreement", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Pi.instZero", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "MvPolynomial.totalDegree", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness of the actual two-corrector grid verifier against nearby polynomial encodings.\nBoth proximity hypotheses are global homogeneous-query distances.\nThe auxiliary proof is arbitrary. ", + "end_line": 298, + "is_class": false, + "kind": "theorem", + "line": 246, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_lower_bound", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ p' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) ≤\n δP →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δM →\n (1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 ≤\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) *\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p' M' A +\n δP +\n 2 * δM +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "Fin.fintype", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instFintypeSum", + "instDecidableEqSum", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same honest eight tables give perfect completeness after both finite reindexings. ", + "end_line": 201, + "is_class": false, + "kind": "theorem", + "line": 191, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.exists_proof_test_eq_true", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V),\n G.Colorable 3 →\n ∀ (eV : optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V)),\n ∃ π,\n ∀ (s : PCP.Algebraic.ThreeColorBinaryVerifier.Seed (Fintype.card V)),\n PCP.Algebraic.ThreeColorBinaryVerifier.test G π s eV = true", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "SimpleGraph.Colorable", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "optParam", + "Equiv", + "Fin", + "Fintype.card", + "Fintype.equivFin", + "Exists", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorBinaryVerifier.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual corrected function agrees with almost all predictions\nat every fixed line parameter. ", + "end_line": 126, + "is_class": false, + "kind": "theorem", + "line": 106, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.PointLineEndpointConsistency.endpoint_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ}\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ],\n 0 < d →\n 1000 * d ^ 3 ≤ Fintype.card F →\n ∀ (f : (σ → F) → F) (u : σ → F) (t : F) {ε : ℚ},\n 0 < ε →\n ε ≤ 1 / 100 →\n 6 * ε + 2 * (↑d / ↑(Fintype.card F)) < 1 / 2 →\n (PCP.Algebraic.relativeDistance\n (fun v => Polynomial.eval t ↑(PCP.Algebraic.PointLineTest.decodedTable d f (u, v))) fun v =>\n PCP.Algebraic.PointLineTest.correction (PCP.Algebraic.PointLineTest.decodedTable d f)\n (PCP.Algebraic.PolynomialLine.point u v t)) ≤\n 8 *\n (4 * PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable d f) +\n 1 / ↑(Fintype.card F)) /\n ε", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "Rat", + "Rat.instLT", + "Rat.instOfNat", + "Rat.instLE", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Subtype.val", + "Polynomial", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.decodedTable", + "Prod.mk", + "PCP.Algebraic.PointLineTest.correction", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.PointLineTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The new slope and intercept depend only on the fixed reduction bound. ", + "end_line": 53, + "is_class": false, + "kind": "definition", + "line": 51, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.budget", + "provenance": "lean", + "structural_dependencies": [], + "type": "Polynomial ℕ → ℕ → ℕ → ℕ → ℕ", + "type_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Polynomial.natDegree", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial.eval" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "_private.PCP.Reduction.FiniteDomainConstraints.0.PCP.Reduction.FiniteDomainConstraints.scope.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ}\n (motive :\n PCP.Reduction.FiniteDomainConstraints.Constraint V C →\n Fin (PCP.Reduction.FiniteDomainConstraints.arity a d) → Sort u_3)\n (e : C) (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d))\n (h_1 : (e : C) → (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) → motive (Sum.inl e) n)\n (h_2 : (v : V) → (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) → motive (Sum.inr v) n),\n (match Sum.inl e, n with\n | Sum.inl e, n => h_1 e n\n | Sum.inr v, n => h_2 v n) =\n h_1 e n", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.arity", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Reduction.FiniteDomainConstraints.scope.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.encodeAssignment.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {a : ℕ} →\n (motive : PCP.Reduction.FiniteDomainConstraints.Variable V a → Sort u_2) →\n (x : PCP.Reduction.FiniteDomainConstraints.Variable V a) →\n ((v : V) → (j : Fin a) → motive (Sum.inl v, j)) →\n ((val : Unit) → (snd : Fin a) → motive (Sum.inr val, snd)) → motive x", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "Fin", + "Prod.mk", + "Sum", + "Unit", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "Fin", + "Prod.mk", + "Sum", + "Unit", + "Sum.inl", + "Sum.inr", + "Prod.casesOn", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {V : Type u_2} →\n {I : Type u_3} →\n [inst : Field F] →\n [inst_1 : AddCommGroup V] →\n [_root_.Module F V] → [Fintype I] → [DecidableEq F] → [Fintype V] → (I → F) → (I → F) → (V → F) → ℚ", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Rat" + ], + "value_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Prod.fst", + "PCP.Algebraic.WeightedConstraint.predict", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ),\n IsScalarTower R R (AddMonoidAlgebra R (PCP.Algebraic.SetMultilinear.Variables m c →₀ ℕ))", + "type_dependencies": [ + "CommSemiring", + "Nat", + "IsScalarTower", + "AddMonoidAlgebra", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddMonoidWithOne.toAddMonoid", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "AddMonoidAlgebra.instAddMonoid", + "AddMonoidAlgebra.smulZeroClass" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.encode.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q q_1 : Polynomial ℕ),\n q = q_1 →\n ∀ {inst : DecidableEq h.tm.Λ} [inst_1 : DecidableEq h.tm.Λ] {inst_2 : DecidableEq h.tm.σ}\n [inst_3 : DecidableEq h.tm.σ] {inst_4 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)}\n [inst_5 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK eK_1 : h.tm.K ≃ Fin k),\n eK = eK_1 →\n ∀ (eA eA_1 : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n eA = eA_1 →\n ∀ (x x_1 : List Bool),\n x = x_1 →\n PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x =\n PCP.Reduction.NPThreeColorRuntime.encode h q_1 hs eK_1 eA_1 x_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Reduction.NPThreeColorRuntime.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Source satisfiability over the actual finite alphabet. ", + "end_line": 58, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.Holds", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → {C : Type u_2} → {a d : ℕ} → (C → (Fin d → Fin a) → Bool) → (C → Fin d → V) → (V → Fin a) → Prop", + "type_dependencies": [ + "Nat", + "Fin", + "Bool" + ], + "value_dependencies": [ + "Nat", + "Fin", + "Bool", + "Eq", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.encode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (x : List Bool),\n PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x = PCP.Reduction.NPTableauGraphLang.encode h hs eK eA x ⋯", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "Eq", + "PCP.Reduction.NPThreeColorRuntime.encode", + "PCP.Reduction.NPTableauGraphLang.encode", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "PCP.Machine.NPCellConstraints.accepting_length_le" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Option (ZMod 2) → Option (ZMod 2) → Option (ZMod 2) → Sort u_1) →\n (p m₀ mZ : Option (ZMod 2)) →\n ((p m₀ mZ : ZMod 2) → motive (some p) (some m₀) (some mZ)) →\n ((x x_1 x_2 : Option (ZMod 2)) →\n (∀ (p m₀ mZ : ZMod 2), x = some p → x_1 = some m₀ → x_2 = some mZ → False) → motive x x_1 x_2) →\n motive p m₀ mZ", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "False" + ], + "value_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "False", + "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.splitter._sparseCasesOn_2", + "Nat.hasNotBit", + "Option.ctorIdx", + "Option.some.noConfusion", + "HEq", + "Eq.ndrec", + "absurd", + "Nat.land", + "Nat.shiftRight", + "Nat.eq_of_beq_eq_true", + "Eq.refl", + "Bool", + "Bool.true", + "Eq.symm" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeTest.0.PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p))\n (h_2 :\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inl p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_1 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The only supplied component codec is the selected field's binary coordinates. ", + "end_line": 60, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.fieldIndex", + "provenance": "lean", + "structural_dependencies": [], + "type": "(N : ℕ) →\n PCP.Algebraic.ThreeColorParameters.Field (PCP.Algebraic.ThreeColorParameterChoice.exponent N) ≃\n Fin (2 ^ PCP.Algebraic.ThreeColorParameters.binaryDimension (PCP.Algebraic.ThreeColorParameterChoice.exponent N))", + "type_dependencies": [ + "Nat", + "Equiv", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension" + ], + "value_dependencies": [ + "Nat", + "Equiv.trans", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Fin", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "LinearEquiv.toEquiv", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorParameters.fieldIndex", + "PCP.Algebraic.ThreeColorBinaryVerifier.fieldIndex._proof_1", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instModuleZModOfNatNatElement", + "Pi.Function.module", + "Semiring.toModule", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorBinaryVerifier.fieldIndex._proof_2", + "PCP.Algebraic.ThreeColorParameters.coordinates", + "Equiv.symm", + "PCP.Algebraic.BinarySeedPadding.Seed", + "PCP.Algebraic.BinarySeedPadding.finSeedEquiv" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → [SizeOf V] → PCP.Reduction.NAEThreeColor.Literal V → ℕ", + "type_dependencies": [ + "SizeOf", + "PCP.Reduction.NAEThreeColor.Literal", + "Nat" + ], + "value_dependencies": [ + "SizeOf", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.rec", + "Nat", + "Bool", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "Bool._sizeOf_inst" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(a : ℕ) → SizeOf (PCP.QueryTree a)", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "SizeOf.mk", + "PCP.QueryTree", + "PCP.QueryTree._sizeOf_1" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.const.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a a_1 : Bool),\n (PCP.Reduction.NAEThreeColor.Literal.const a = PCP.Reduction.NAEThreeColor.Literal.const a_1) = (a = a_1)", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.const" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 101, + "is_class": false, + "kind": "theorem", + "line": 93, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.weights_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) → ∀ (i : Fin (c + 1)), PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i ≠ 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Ne", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.rowPolynomial._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.spacePoly.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ),\n PCP.Machine.NPTableau.spacePoly h q =\n PCP.Machine.NPTableau.inputPoly q +\n Polynomial.C (PCP.Machine.machinePushBound h.tm) * PCP.Machine.NPTableau.timePoly h q", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "PCP.Machine.NPTableau.spacePoly", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "PCP.Machine.NPTableau.inputPoly", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "PCP.Machine.machinePushBound", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "PCP.Machine.NPTableau.timePoly" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 65, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.queries_length", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (u v : σ → F),\n (PCP.Algebraic.GeneratorLowDegreeTest.queries c ζ u v).length = c + 2", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "List.length", + "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encode._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A wrong origin value can pass comparison with the honest polynomial on\nat most `D/(|F|-1)` of the actual direction/parameter samples. ", + "end_line": 171, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.accepted_wrong_honest_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {D : ℕ} (T : (σ → F) → Polynomial F),\n (∀ (b : σ → F), (T b).natDegree ≤ D) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n ∀ (a : σ → F),\n (PCP.Algebraic.AffineLineSampling.fraction fun s =>\n Polynomial.eval (↑s.2) (T s.1) = (MvPolynomial.eval (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2)) P ∧\n Polynomial.eval 0 (T s.1) ≠ (MvPolynomial.eval a) P) ≤\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.AffineLineSampling.fraction", + "Prod", + "Units", + "Semiring.toMonoid", + "instFintypeProd", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "And", + "Eq", + "Polynomial.eval", + "Units.val", + "Prod.snd", + "Prod.fst", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.PolynomialLine.point", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries_length_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 0 (s 0)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 1 (s 1)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 2 (s 2)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 3 (s 3)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 4 (s 4)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 5 (s 5)).length +\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 6 (s 6)).length))))) ≤\n 2 * c + 18 + (2 * c + 14 + (2 * c + 18 + (2 * c + 14 + (6 * c + 20 + (6 * c + 20 + 3))))) →\n ¬(PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 0 (s 0)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 1 (s 1)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 2 (s 2)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 3 (s 3)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 4 (s 4)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 5 (s 5)).length +\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 6 (s 6)).length))))) ≤\n 20 * c + 107 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "LE.le", + "Preorder.toLE", + "Nat.instPreorder", + "AddZero.toAdd", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddCommMonoid.toAddMonoid", + "Nat.instAddCommMonoid", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "Fin.instOfNat", + "instNeZeroNatHAdd_1", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "instLENat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A polynomial with a specified finite list of coefficients. ", + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.series", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → [inst : CommRing R] → {k : ℕ} → (Fin (k + 1) → R) → Polynomial R", + "type_dependencies": [ + "CommRing", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring" + ], + "value_dependencies": [ + "CommRing", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Finset.sum", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Finset.univ", + "Fin.fintype", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toModule", + "Polynomial.module", + "LinearMap.instFunLike", + "Polynomial.monomial", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Uniform transverse error turns polynomial separation into a weighted bound\non the fraction of differing formal rows. ", + "end_line": 67, + "is_class": false, + "kind": "theorem", + "line": 29, + "module": "PCP.Algebraic.BivariateAgreementBoost", + "name": "PCP.Algebraic.BivariateAgreementBoost.rowDistance_mul_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (R C : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n ∀ (P : MvPolynomial (Fin 2) F),\n (∀ (j : Fin 2), MvPolynomial.degreeOf j P ≤ d) →\n ∀ {κ : ℚ},\n (∀ (y : F),\n (PCP.Algebraic.relativeDistance (fun x => Polynomial.eval y (C x)) fun x =>\n (MvPolynomial.eval ![x, y]) P) ≤\n κ) →\n (1 - ↑d / ↑(Fintype.card F) - κ) *\n PCP.Algebraic.relativeDistance R (PCP.Algebraic.PointLineCrossing.columnPolynomial P) ≤\n PCP.Algebraic.relativeDistance (fun z => Polynomial.eval z.1 (R z.2)) fun z => Polynomial.eval z.2 (C z.1)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial.degreeOf", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Polynomial.eval", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Polynomial.instDecidableEq", + "PCP.Algebraic.PointLineCrossing.columnPolynomial", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Exact bit count for the whole-field sampler, including every independent seed. ", + "end_line": 47, + "is_class": false, + "kind": "definition", + "line": 45, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorSeedSize.rawBits", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {σ : Type u_3} {W : Type u_1} [inst : Field F] (a : σ → F) (s : ((σ → F) × W) × Fˣ),\n (((PCP.Algebraic.affineSamplingEquiv a ↑(((PCP.Algebraic.affineSamplingEquiv a ↑s.2 ⋯).symm s.1.1, s.2), s.1.2).1.2 ⋯)\n (((PCP.Algebraic.affineSamplingEquiv a ↑s.2 ⋯).symm s.1.1, s.2), s.1.2).1.1,\n (((PCP.Algebraic.affineSamplingEquiv a ↑s.2 ⋯).symm s.1.1, s.2), s.1.2).2),\n (((PCP.Algebraic.affineSamplingEquiv a ↑s.2 ⋯).symm s.1.1, s.2), s.1.2).1.2) =\n s", + "type_dependencies": [ + "Field", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Prod.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.affineSamplingEquiv", + "Field.toDivisionRing", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Pi.Function.module", + "Ring.toSemiring", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "Units.val", + "Prod.snd", + "Prod.fst", + "Equiv.symm", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_2", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_5" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every language with a concrete polynomial-time witness checker belongs to\nthe exact pinned ComplexityLib nondeterministic-machine class. ", + "end_line": 30, + "is_class": false, + "kind": "theorem", + "line": 18, + "module": "PCP.Complexity.ReferenceNPConverse", + "name": "PCP.ReferenceNP.of_inNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : Complexity.Language}, PCP.InNP PCP.Machine.PolyTimeRel L → L ∈ Complexity.NP", + "type_dependencies": [ + "Complexity.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Membership.mem", + "Set", + "Set.instMembership", + "Complexity.NP" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (ctorIdx : ℕ) → (t : PCP.Machine.Sym) → ctorIdx = t.ctorIdx → PCP.Machine.Sym.ctorElimType ctorIdx → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "Eq", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.ctorElimType" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "Eq", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.ctorElimType", + "PCP.Machine.Sym.casesOn", + "Bool", + "PULift.down", + "PCP.Machine.Sym.bit", + "Eq.ndrec", + "PCP.Machine.Sym.sep" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The witness-checking relation. ", + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → List Bool → List Bool → Bool", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Linear interpolation from a table on the grid to a formal multivariate polynomial. ", + "end_line": 78, + "is_class": false, + "kind": "definition", + "line": 76, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.interpolate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{𝔽 : Type u_1} →\n {σ : Type u_2} →\n [inst : Field 𝔽] →\n [DecidableEq 𝔽] → [Fintype σ] → [DecidableEq σ] → (H : Finset 𝔽) → ((σ → ↥H) → 𝔽) →ₗ[𝔽] MvPolynomial σ 𝔽", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule" + ], + "value_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Finset.sum", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.addCommMonoid", + "Finset.univ", + "Pi.instFintype", + "Finset.Subtype.fintype", + "LinearMap.smulRight", + "PCP.Algebraic.GridInterpolation.interpolate._proof_1", + "LinearMap.proj", + "PCP.Algebraic.GridInterpolation.basis" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 210, + "is_class": false, + "kind": "theorem", + "line": 196, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.inversion", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ) (x : ι → ZMod 2),\n ∑ a, PCP.Algebraic.BLR.fourier f a * PCP.Algebraic.BLR.character a x = f x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.sixteen_le_card._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), ¬1 ≤ k + 1 → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every actual branch rate is bounded by the combined rate, with no branch factor. ", + "end_line": 423, + "is_class": false, + "kind": "theorem", + "line": 418, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (i : Fin 7),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π i ≤\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Convert a finite Boolean word to the binary-field alphabet used by the algebraic test. ", + "end_line": 63, + "is_class": false, + "kind": "definition", + "line": 61, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.fieldWord", + "provenance": "lean", + "structural_dependencies": [], + "type": "{N : ℕ} →\n (Fin (PCP.Algebraic.ThreeColorBinaryVerifier.proofLength N) → Bool) →\n PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord N", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Bool", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Bool", + "DFunLike.coe", + "Equiv", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.BinarySeedPadding.boolEquiv" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "definition", + "line": 23, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → t.ctorIdx = 0 → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "Bool", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.direct.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n (motive : PCP.Reduction.NAEThreeColor.Vertex V C → PCP.Reduction.NAEThreeColor.Vertex V C → Sort u_3) →\n (x x_1 : PCP.Reduction.NAEThreeColor.Vertex V C) →\n ((i j : Fin 3) → motive (Sum.inl i) (Sum.inl j)) →\n ((val : V × Bool) → (i : Fin 3) → motive (Sum.inr (Sum.inl val)) (Sum.inl i)) →\n ((v : V) →\n (b : Bool) → (w : V) → (d : Bool) → motive (Sum.inr (Sum.inl (v, b))) (Sum.inr (Sum.inl (w, d)))) →\n ((e : C) →\n (i : Fin 3) → (f : C) → (j : Fin 3) → motive (Sum.inr (Sum.inr (e, i))) (Sum.inr (Sum.inr (f, j)))) →\n ((e : C) →\n (i : Fin 3) →\n (x : PCP.Reduction.NAEThreeColor.Vertex V C) →\n (∀ (f : C) (j : Fin 3), x = Sum.inr (Sum.inr (f, j)) → False) →\n motive (Sum.inr (Sum.inr (e, i))) x) →\n ((x x_2 : PCP.Reduction.NAEThreeColor.Vertex V C) →\n (∀ (i j : Fin 3), x = Sum.inl i → x_2 = Sum.inl j → False) →\n (∀ (val : V × Bool) (i : Fin 3), x = Sum.inr (Sum.inl val) → x_2 = Sum.inl i → False) →\n (∀ (v : V) (b : Bool) (w : V) (d : Bool),\n x = Sum.inr (Sum.inl (v, b)) → x_2 = Sum.inr (Sum.inl (w, d)) → False) →\n (∀ (e : C) (i : Fin 3) (f : C) (j : Fin 3),\n x = Sum.inr (Sum.inr (e, i)) → x_2 = Sum.inr (Sum.inr (f, j)) → False) →\n (∀ (e : C) (i : Fin 3), x = Sum.inr (Sum.inr (e, i)) → False) → motive x x_2) →\n motive x x_1", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk", + "Eq", + "False" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk", + "Eq", + "False", + "Sum.casesOn", + "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_1", + "Nat.hasNotBit", + "Sum.ctorIdx", + "Sum.inl.noConfusion", + "HEq", + "Eq.ndrec", + "absurd", + "Nat.land", + "Nat.shiftRight", + "Nat.eq_of_beq_eq_true", + "Eq.refl", + "Bool.true", + "Eq.symm", + "False.elim", + "noConfusion_of_Nat", + "Prod.casesOn", + "Sum.inr.noConfusion", + "eq_of_heq", + "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_2" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {W : Type u_3} [inst : Field F] (a : σ → F) (s : ((σ → F) × Fˣ) × W),\n ↑(((PCP.Algebraic.affineSamplingEquiv a ↑s.1.2 ⋯) s.1.1, s.2), s.1.2).2 ≠ 0", + "type_dependencies": [ + "Field", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Ne", + "Units.val", + "MonoidWithZero.toMonoid", + "Semiring.toMonoidWithZero", + "Prod.snd", + "Prod.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.affineSamplingEquiv", + "Field.toDivisionRing", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Pi.Function.module", + "Ring.toSemiring", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "Prod.fst", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_1", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Acceptance depends only on the listed physical proof bits. ", + "end_line": 189, + "is_class": false, + "kind": "theorem", + "line": 180, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.test_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V)\n (π π' : PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (Fintype.card V))\n (s : PCP.Algebraic.ThreeColorBinaryVerifier.Seed (Fintype.card V))\n (eV : optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V)),\n (∀ i ∈ PCP.Algebraic.ThreeColorBinaryVerifier.queries G s eV, π i = π' i) →\n PCP.Algebraic.ThreeColorBinaryVerifier.test G π s eV = PCP.Algebraic.ThreeColorBinaryVerifier.test G π' s eV", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Fintype.card", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "optParam", + "Equiv", + "Fin", + "Fintype.equivFin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorBinaryVerifier.queries", + "Eq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Bool", + "PCP.Algebraic.ThreeColorBinaryVerifier.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.boolColor_inj._simp_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : Bool), (PCP.Reduction.NAEThreeColor.boolColor a = PCP.Reduction.NAEThreeColor.boolColor b) = (a = b)", + "type_dependencies": [ + "Bool", + "Eq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.boolColor" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Likewise for the proper certificate, after flattening the constraint coordinates. ", + "end_line": 80, + "is_class": false, + "kind": "definition", + "line": 77, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properAuxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F (n + n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines", + "Prod.mk", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 107, + "is_class": false, + "kind": "theorem", + "line": 102, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.eval_fieldPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (x : Fin t → ZMod 2),\n (MvPolynomial.eval fun i => (algebraMap (ZMod 2) F) (x i)) (PCP.Algebraic.HadamardComposition.fieldPolynomial ρ P) =\n Polynomial.eval (ρ.symm x) P", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Algebra.algebraMap", + "PCP.Algebraic.HadamardComposition.fieldPolynomial", + "Polynomial.eval", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "LinearEquiv.symm" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.firstLabelEquiv._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_2} {W : Type u_1} (x : (V × W) × V),\n ((((x.1.1, x.2), x.1.2).1.1, ((x.1.1, x.2), x.1.2).2), ((x.1.1, x.2), x.1.2).1.2) =\n ((((x.1.1, x.2), x.1.2).1.1, ((x.1.1, x.2), x.1.2).2), ((x.1.1, x.2), x.1.2).1.2)", + "type_dependencies": [ + "Prod", + "Eq", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 101, + "is_class": false, + "kind": "theorem", + "line": 94, + "module": "PCP.Complexity.TableauCells", + "name": "_private.PCP.Complexity.TableauCells.0.PCP.Machine.TableauCells.cfg_ext", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {c d : tm.Cfg}, c.l = d.l → c.var = d.var → c.stk = d.stk → c = d", + "type_dependencies": [ + "Turing.FinTM2", + "Turing.FinTM2.Cfg", + "Eq", + "Option", + "Turing.FinTM2.Λ", + "Turing.TM2.Cfg.l", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.σ", + "Turing.TM2.Cfg.var", + "List", + "Turing.TM2.Cfg.stk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_mul_sign", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : ZMod 2), PCP.Algebraic.BLR.sign a * PCP.Algebraic.BLR.sign b = if a = b then 1 else -1", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.sign", + "ite", + "ZMod.decidableEq", + "Rat.instOfNat", + "Neg.neg", + "Rat.instNeg" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Outside the declared space bound every cell is the fixed blank value. ", + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.readCell", + "provenance": "lean", + "structural_dependencies": [], + "type": "{tm : Turing.FinTM2} → {B : ℕ} → PCP.Machine.TableauCells.Cells tm B → (k : tm.K) → ℕ → Option (tm.Γ k)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "Option", + "Turing.FinTM2.Γ" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "dite", + "Option", + "Turing.FinTM2.Γ", + "LT.lt", + "instLTNat", + "Nat.decLt", + "Option.map", + "Subtype", + "PCP.Machine.Supported", + "Subtype.val", + "Fin.mk", + "Not", + "Option.none" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Encoding of a verifier algorithm's answer. A halt decision is one bit; a query is the\nseparator followed by the address in binary. ", + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeAnswer", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool ⊕ ℕ → List PCP.Machine.Sym", + "type_dependencies": [ + "Sum", + "Bool", + "Nat", + "List", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Nat", + "PCP.Machine.encodeAnswer.match_1", + "List", + "PCP.Machine.Sym", + "List.cons", + "PCP.Machine.Sym.bit", + "List.nil", + "PCP.Machine.Sym.sep", + "PCP.Machine.ofBits", + "Nat.bits" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 62, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.distance_shared_fst", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} {A : Type u_4} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S]\n [inst_3 : DecidableEq A] (f g : W × S → A),\n (PCP.Algebraic.relativeDistance (fun s => f (s.1, s.2.1)) fun s => g (s.1, s.2.1)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 93, + "is_class": false, + "kind": "theorem", + "line": 90, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.assemble_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {k : ℕ}, Function.Injective PCP.Algebraic.BerlekampWelchCertificate.assemble", + "type_dependencies": [ + "Field", + "Nat", + "Function.Injective", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "PCP.Algebraic.BerlekampWelchCertificate.assemble" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 232, + "is_class": false, + "kind": "theorem", + "line": 229, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_properQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.properQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.properCert π.properLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.properQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instFintypeSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "Fintype PCP.Machine.Sym", + "type_dependencies": [ + "Fintype", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Fintype.ofEquiv", + "PCP.Machine.Sym", + "Sum", + "Bool", + "Unit", + "instFintypeSum", + "Bool.fintype", + "PUnit.fintype", + "PCP.Machine.Sym.proxyTypeEquiv" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (0 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n PCP.Algebraic.EncodedLineLowDegreeTest.read f H (Sum.inr p) = H p.1 p.2.1 p.2.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "Sum.inr", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 31, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → ℕ → ℕ → ℕ → Type u_3", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 155, + "is_class": false, + "kind": "theorem", + "line": 152, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n 0 ≤ PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Every extension exponent is positive, including the first member. ", + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 37, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.extensionDegree_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), 0 < 4 * (k + 1)", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Any label distribution obtained from a uniform finite seed preserves the row bound.\nThe label map need not be injective, surjective, or independent of other sampled data. ", + "end_line": 96, + "is_class": false, + "kind": "theorem", + "line": 79, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.labels_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} {A : Type u_2} [inst_2 : Fintype A]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (P : Polynomial F) (hP : P.natDegree ≤ r) (u : F)\n (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (L : A → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.relativeDistance (fun s => PCP.Algebraic.HadamardDerivedOracle.answer ρ P hP H (L s.1) s.2) fun s =>\n (PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval u P))) (L s.1)) ≤\n 2 * PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.Hadamard.encode r (ρ u))", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Complete runtime certificate for the production amplified verifier. ", + "end_line": 15, + "is_class": false, + "kind": "theorem", + "line": 10, + "module": "PCP.Complexity.ThreeColorRuntime", + "name": "PCP.Lang.ThreeColorRuntime.polyTimeAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.PolyTimeAlg PCP.Algebraic.ComputableThreeColorAmplifiedQueryAlgorithm.algorithm", + "type_dependencies": [ + "PCP.Machine.PolyTimeAlg", + "PCP.Algebraic.ComputableThreeColorAmplifiedQueryAlgorithm.algorithm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "SizeOf PCP.Verifier", + "type_dependencies": [ + "SizeOf", + "PCP.Verifier" + ], + "value_dependencies": [ + "SizeOf.mk", + "PCP.Verifier", + "PCP.Verifier._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual freshly randomized derived-grid verifier has perfect completeness. ", + "end_line": 242, + "is_class": false, + "kind": "theorem", + "line": 230, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : NeZero m] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {H : Finset F} (f : (Fin n → F) → F) (P : MvPolynomial (Fin n) F),\n (∀ (x : Fin n → F), Polynomial.eval (f x) (Q x) = (MvPolynomial.eval x) P) →\n ∀ (M : MvPolynomial (Fin n ⊕ Fin n) F),\n M.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H P M →\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ Q hQ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x))))\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M))))\n (PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M) =\n 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "MvPolynomial", + "Eq", + "Polynomial.eval", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "Rat", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.assemble.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {k : ℕ} (v : Fin (k + 1) → Polynomial F),\n PCP.Algebraic.BerlekampWelchCertificate.assemble v =\n ∑ j, PCP.Algebraic.BerlekampWelchCertificate.inY (v j) * MvPolynomial.X 0 ^ ↑j", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "MvPolynomial", + "PCP.Algebraic.BerlekampWelchCertificate.assemble", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "RingHom.instFunLike", + "PCP.Algebraic.BerlekampWelchCertificate.inY", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "MvPolynomial.X", + "Fin.instOfNat", + "PCP.Algebraic.BerlekampWelchCertificate.inY._proof_1", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_monomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ) (a : R),\n (PCP.Algebraic.SetMultilinear.encode m c) ((Polynomial.monomial k) a) =\n a • PCP.Algebraic.SetMultilinear.digitMonomial m c k", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.monomial", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 74, + "is_class": false, + "kind": "constructor", + "line": 74, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.const", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal" + ], + "type": "{V : Type u_1} → Bool → PCP.Reduction.NAEThreeColor.Literal V", + "type_dependencies": [ + "Bool", + "PCP.Reduction.NAEThreeColor.Literal" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Parseval's identity, with normalized coefficients and an unnormalized dual sum. ", + "end_line": 232, + "is_class": false, + "kind": "theorem", + "line": 229, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.parseval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ),\n ∑ a, PCP.Algebraic.BLR.fourier f a ^ 2 = PCP.Algebraic.BLR.average fun x => f x ^ 2", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.average" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.queries_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.queries = PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 187", + "type_dependencies": [ + "Eq", + "Nat", + "PCP.Verifier.queries", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → ℕ", + "type_dependencies": [ + "PCP.CostModel", + "Nat" + ], + "value_dependencies": [ + "PCP.CostModel" + ] + }, + { + "axioms": [], + "doc": "A bit string as tape symbols. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.ofBits", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "List", + "Bool", + "List.map", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 73, + "is_class": false, + "kind": "theorem", + "line": 71, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.timePoly_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (n : ℕ),\n Polynomial.eval n (PCP.Machine.NPTableau.timePoly h q) = Polynomial.eval (n + Polynomial.eval n q + 1) h.time", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "Polynomial.eval", + "PCP.Machine.NPTableau.timePoly", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Turing.TM2ComputableInPolyTime.time", + "Prod", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Run the decision tree against a proof oracle. ", + "end_line": 44, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "PCP.QueryTree.brecOn", + "Bool", + "PCP.QueryTree.eval._f" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Here `R y` is a polynomial in the horizontal coordinate, and `C x` is a\npolynomial in the vertical coordinate. Their grid discrepancy averages over `x`. ", + "end_line": 90, + "is_class": false, + "kind": "theorem", + "line": 83, + "module": "PCP.Algebraic.BivariateColumnSelection", + "name": "PCP.Algebraic.BivariateColumnSelection.mean_column_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (f : F × F → F) (R C : F → Polynomial F)\n {ε : ℚ},\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.1 (R z.2)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.2 (C z.1)) ≤ ε →\n (Finset.univ.expect fun x =>\n PCP.Algebraic.relativeDistance (fun y => Polynomial.eval x (R y)) fun x_1 => Polynomial.eval x_1 (C x)) ≤\n 2 * ε", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Prod", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "Prod.fst", + "Prod.snd", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The table query is uniform on both variable blocks and the shared label. ", + "end_line": 201, + "is_class": false, + "kind": "theorem", + "line": 190, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.table_marginal", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] {t r : ℕ} (hr : 1 ≤ r)\n (g g' : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n (PCP.Algebraic.relativeDistance (fun s => g (Sum.elim s.1.1 s.1.2) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2))\n fun s => g' (Sum.elim s.1.1 s.1.2) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2)) =\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr g g'", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Sum", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "Fin", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Sum.elim", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "instFintypeSum", + "instDecidableEqSum" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.answer.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (P P_1 : Polynomial F) (e_P : P = P_1) (hP : P.natDegree ≤ r)\n (H H_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n H = H_1 →\n ∀ (L L_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n L = L_1 →\n ∀ (R R_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n R = R_1 →\n PCP.Algebraic.HadamardDerivedOracle.answer ρ P hP H L R =\n PCP.Algebraic.HadamardDerivedOracle.answer ρ_1 P_1 ⋯ H_1 L_1 R_1", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} {a_2 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.properCert a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph_adj_vertexEmbedding._simp_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V) (eV : V ≃ Fin (Fintype.card V)) (u v : V),\n (PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph G eV).Adj\n ((PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding eV) u)\n ((PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding eV) v) =\n G.Adj u v", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "Equiv", + "Fin", + "Fintype.card", + "Eq", + "SimpleGraph.Adj", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "DFunLike.coe", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.interpolateSlices._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {n : ℕ}, NeZero (n + 1)", + "type_dependencies": [ + "Nat", + "NeZero", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The four primary tables and their four shared encoded-line tables. ", + "end_line": 45, + "is_class": false, + "kind": "inductive", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 103, + "is_class": false, + "kind": "theorem", + "line": 99, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.input_space_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) {x w : List Bool},\n w.length ≤ Polynomial.eval x.length q →\n (PCP.Machine.NPTableau.input h x w).length +\n PCP.Machine.machinePushBound h.tm * Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q) ≤\n Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Turing.FinTM2.Γ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.k₀", + "PCP.Machine.NPTableau.input", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Machine.machinePushBound", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Many genuine close rows construct a bivariate numerator and nonzero locator\nwith explicit bounds in both variables; no polynomial certificate is assumed. ", + "end_line": 257, + "is_class": false, + "kind": "theorem", + "line": 235, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.exists_certificate_of_good_specializations", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] {d e D : ℕ} [inst_1 : Fintype I] (a : I → F),\n Function.Injective a →\n ∀ (columns : I → Polynomial F),\n (∀ (i : I), (columns i).natDegree ≤ D) →\n ∀ (S : Finset F),\n (d + 2 * e + 2) * D < S.card →\n (∀ y ∈ S,\n ∃ s,\n s.natDegree ≤ d ∧\n (PCP.Algebraic.BerlekampWelch.errors a (fun i => Polynomial.eval y (columns i)) s).card ≤ e) →\n d + e < Fintype.card I →\n ∃ E N,\n E ≠ 0 ∧\n MvPolynomial.degreeOf 0 E ≤ e ∧\n MvPolynomial.degreeOf 0 N ≤ d + e ∧\n MvPolynomial.degreeOf 1 E ≤ (d + 2 * e + 1) * D ∧\n MvPolynomial.degreeOf 1 N ≤ (d + 2 * e + 1) * D ∧\n ∀ (i : I),\n PCP.Algebraic.PointLineCrossing.rowPolynomial N (a i) =\n columns i * PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Finset", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Finset.card", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Exists", + "And", + "PCP.Algebraic.BerlekampWelch.errors", + "Polynomial.eval", + "Fintype.card", + "MvPolynomial", + "Fin", + "Ne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.degreeOf", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "Eq", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "Polynomial.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Enough nodes supply `d+1` distinct columns on which the locator is a nonzero\nformal polynomial. The selection is constructed from the preceding root bound. ", + "end_line": 261, + "is_class": false, + "kind": "theorem", + "line": 239, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.exists_nonzero_columns", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype I] {d e : ℕ} (a : I → F),\n Function.Injective a →\n ∀ (E : MvPolynomial (Fin 2) F),\n E ≠ 0 →\n MvPolynomial.degreeOf 0 E ≤ e →\n (∀ (j : Fin 2), MvPolynomial.degreeOf j E < Fintype.card F) →\n d + e < Fintype.card I →\n ∃ b, ∀ (i : Fin (d + 1)), PCP.Algebraic.PointLineCrossing.rowPolynomial E (a (b i)) ≠ 0", + "type_dependencies": [ + "Field", + "Fintype", + "Nat", + "Function.Injective", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Ne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "LE.le", + "instLENat", + "MvPolynomial.degreeOf", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "LT.lt", + "instLTNat", + "Fintype.card", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Exists", + "Function.Embedding", + "Polynomial", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "DFunLike.coe", + "Function.instFunLikeEmbedding", + "Polynomial.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The sufficient cubic field-size factor. ", + "end_line": 19, + "is_class": false, + "kind": "definition", + "line": 18, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.fieldFactor", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "OfNat.ofNat", + "Nat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Removing two exceptional events leaves at least one minus their total fraction. ", + "end_line": 70, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.fraction_good_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_1} [inst : Fintype A] [Nonempty A] (B D G : A → Prop),\n (∀ (x : A), ¬B x → ¬D x → G x) →\n 1 - PCP.Algebraic.AffineLineSampling.fraction B - PCP.Algebraic.AffineLineSampling.fraction D ≤\n PCP.Algebraic.AffineLineSampling.fraction G", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Not", + "LE.le", + "Rat", + "Rat.instLE", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.AffineLineSampling.fraction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Read an actual query from the degree-`r` primary oracle or certificate proof. ", + "end_line": 109, + "is_class": false, + "kind": "definition", + "line": 104, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t r : ℕ} →\n ((Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t →\n PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t r → ZMod 2", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.Query" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.DerivedZeroOnGrid.read.match_1", + "Prod", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "PCP.Algebraic.BinaryLocalCorrection.read" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The formal matrix product is the bivariate certificate equation at the selected column. ", + "end_line": 184, + "is_class": false, + "kind": "theorem", + "line": 164, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.matrix_mulVec_assemble", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] {d e : ℕ} (a : I → F) (columns : I → Polynomial F)\n (v : PCP.Algebraic.BerlekampWelchMatrix.Unknowns d e → Polynomial F) (i : I),\n (PCP.Algebraic.BerlekampWelchMatrix.matrix d e a columns).mulVec v i =\n PCP.Algebraic.PointLineCrossing.rowPolynomial\n (PCP.Algebraic.BerlekampWelchCertificate.assemble fun j => v (Sum.inl j)) (a i) -\n columns i *\n PCP.Algebraic.PointLineCrossing.rowPolynomial\n (PCP.Algebraic.BerlekampWelchCertificate.assemble fun j => v (Sum.inr j)) (a i)", + "type_dependencies": [ + "Field", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BerlekampWelchMatrix.Unknowns", + "Eq", + "Matrix.mulVec", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "Polynomial.commRing", + "Field.toCommRing", + "instFintypeSum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin.fintype", + "PCP.Algebraic.BerlekampWelchMatrix.matrix", + "HSub.hSub", + "instHSub", + "Polynomial.instSub", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "PCP.Algebraic.BerlekampWelchCertificate.assemble", + "Sum.inl", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "Sum.inr" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Bound on the number of proof **bits** read (bits, not larger proof symbols). ", + "end_line": 89, + "is_class": false, + "kind": "definition", + "line": 89, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A finite union has fraction at most the sum of its constituent fractions. ", + "end_line": 53, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.fraction_exists_mem_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_1} {I : Type u_2} [inst : Fintype A] (J : Finset I) (E : I → A → Prop),\n (PCP.Algebraic.AffineLineSampling.fraction fun x => ∃ i ∈ J, E i x) ≤\n ∑ i ∈ J, PCP.Algebraic.AffineLineSampling.fraction (E i)", + "type_dependencies": [ + "Fintype", + "Finset", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.AffineLineSampling.fraction", + "Exists", + "And", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.sum", + "Rat.addCommMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 36, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.correct", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Finset.sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Semiring.toAddCommMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All possible old suffix addresses of one new cell, one per output-prefix length. ", + "end_line": 120, + "is_class": false, + "kind": "definition", + "line": 117, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.candidates", + "provenance": "lean", + "structural_dependencies": [], + "type": "{tm : Turing.FinTM2} →\n {B : ℕ} →\n PCP.Machine.TableauCells.Cells tm B →\n (k : tm.K) → ℕ → Fin (PCP.Machine.FiniteTransitionTable.outputBound tm + 1) → Option (tm.Γ k)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.FiniteTransitionTable.outputBound", + "OfNat.ofNat", + "instOfNatNat", + "Option", + "Turing.FinTM2.Γ" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.FiniteTransitionTable.outputBound", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.TableauCells.readCell", + "PCP.Machine.TM2Locality.machineWindow", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} {S : Type u_3} (p : X → W → ZMod 2) (a b : X → W → S → Option (ZMod 2))\n (s : X × W × S × S),\n PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck p a b s =\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck (some (p s.1 s.2.1)) (a s.1 s.2.1 s.2.2.1) (b s.1 s.2.1 s.2.2.2)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Prod", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Prop) (x : ℕ) (x_1 : PCP.QueryTree x),\n (∀ (x : ℕ) (accept : Bool), motive x (PCP.QueryTree.leaf accept)) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d), motive d.succ (PCP.QueryTree.query a f t)) → motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "Nat.succ", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "Nat.succ", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "Eq", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 46, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.fraction_prod", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} [inst : Fintype X] [inst_1 : Fintype W] (E : X × W → Prop),\n PCP.Algebraic.AffineLineSampling.fraction E =\n Finset.univ.expect fun x => PCP.Algebraic.AffineLineSampling.fraction fun w => E (x, w)", + "type_dependencies": [ + "Fintype", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.AffineLineSampling.fraction", + "instFintypeProd", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 72, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u} →\n (t : PCP.Reduction.NAEThreeColor.Literal V) →\n ((a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a)) →\n ((a : V) → (a_1 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)) → motive t", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.Literal.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → PCP.CostModel → PCP.CostModel → Sort u", + "type_dependencies": [ + "PCP.CostModel" + ], + "value_dependencies": [ + "PCP.CostModel", + "PCP.CostModel.casesOn", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 64, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.read_encodeCells", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} (c : tm.Cfg) (hs : PCP.Machine.StackSupported tm c.stk),\n (∀ (k : tm.K), (c.stk k).length ≤ B) →\n ∀ (k : tm.K) (j : ℕ),\n PCP.Machine.TableauCells.readCell (PCP.Machine.TableauCells.encodeCells B c hs) k j = (c.stk k)[j]?", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "LE.le", + "instLENat", + "List.length", + "Eq", + "Option", + "PCP.Machine.TableauCells.readCell", + "PCP.Machine.TableauCells.encodeCells", + "GetElem?.getElem?", + "List", + "LT.lt", + "instLTNat", + "List.instGetElem?NatLtLength" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Binary evaluation commutes with a binary-linear map of coefficients. ", + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.eval_mapCoefficients", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] (ℓ : F →ₗ[ZMod 2] ZMod 2)\n (q : MvPolynomial σ F) (x : σ → ZMod 2),\n (MvPolynomial.eval x) (PCP.Algebraic.HadamardComposition.mapCoefficients ℓ q) =\n ℓ ((MvPolynomial.eval fun i => (algebraMap (ZMod 2) F) (x i)) q)", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Algebra.toModule", + "Semiring.toModule", + "MvPolynomial", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.HadamardComposition.mapCoefficients", + "LinearMap.instFunLike", + "Algebra.algebraMap" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.scope.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ} (s : C → Fin d → V)\n (x : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) (v : V),\n PCP.Reduction.FiniteDomainConstraints.scope s (Sum.inr v) x = (Sum.inl v, (finProdFinEquiv.symm x).2)", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.arity", + "Eq", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.scope", + "Sum.inr", + "Prod.mk", + "Sum", + "Unit", + "Sum.inl", + "Prod.snd", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "DFunLike.coe", + "Equiv", + "HMul.hMul", + "instHMul", + "instMulNat", + "Prod", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "finProdFinEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The Walsh basis is orthonormal for the uniform average. ", + "end_line": 227, + "is_class": false, + "kind": "theorem", + "line": 212, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.pairing", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f g : (ι → ZMod 2) → ℚ),\n ∑ a, PCP.Algebraic.BLR.fourier f a * PCP.Algebraic.BLR.fourier g a = PCP.Algebraic.BLR.average fun x => f x * g x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.average" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.weights.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (c : ℕ) (ζ : F),\n PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ =\n PCP.Algebraic.LagrangeConstraint.weight (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) 0", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "PCP.Algebraic.LagrangeConstraint.weight", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "theorem", + "line": 125, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) = 16 ^ max 1 (Nat.clog 16 M)", + "type_dependencies": [ + "Nat", + "Eq", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.rowPolynomial_assemble._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]\n [MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n)", + "type_dependencies": [ + "FunLike", + "Monoid", + "MonoidHomClass", + "MulOneClass.toMulOne", + "Monoid.toMulOneClass", + "Nat", + "Eq", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "DFunLike.coe" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each branch's physical queries occur in the complete list. ", + "end_line": 298, + "is_class": false, + "kind": "theorem", + "line": 292, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.mem_queries_of_branch", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t) (i : Fin 7)\n {q : PCP.Algebraic.ThreeColorVerifier.Query F n m c t},\n q ∈ PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i (s i) →\n q ∈ PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "PCP.Algebraic.ThreeColorVerifier.queries" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.cellsFinite", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (tm : Turing.FinTM2) (B : ℕ), Finite (PCP.Machine.TableauCells.Cells tm B)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Finite", + "PCP.Machine.TableauCells.Cells" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness: a polynomial-time relation is computable. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 85, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.polyTimeRel_computable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (self : PCP.CostModel) (R : List Bool → List Bool → Bool), self.PolyTimeRel R → Computable₂ R", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.CostModel.PolyTimeRel", + "Computable₂", + "Primcodable.list", + "Primcodable.bool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.two_mul_nonzero_count._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", + "type_dependencies": [ + "Fintype", + "Eq", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.univ", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.1, extended linearly to all univariate polynomials. ", + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] →\n (m : ℕ) → [NeZero m] → (c : ℕ) → Polynomial R →ₗ[R] MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial.lsum", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.smulRight", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.SetMultilinear.encode._proof_1", + "LinearMap.id", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "Fair random bits used on inputs of length `n`. ", + "end_line": 87, + "is_class": false, + "kind": "definition", + "line": 87, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.randomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 168, + "is_class": false, + "kind": "definition", + "line": 167, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.chosenCoordinates", + "provenance": "lean", + "structural_dependencies": [], + "type": "(M : ℕ) →\n PCP.Algebraic.ThreeColorFields.Chosen M ≃ₗ[ZMod 2] Fin (PCP.Algebraic.ThreeColorFields.binaryDimension M) → ZMod 2", + "type_dependencies": [ + "Nat", + "LinearEquiv", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "PCP.Algebraic.ThreeColorFields.Chosen", + "Fin", + "PCP.Algebraic.ThreeColorFields.binaryDimension", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.index", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instModuleZModOfNatNatElement", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorFields.coordinates", + "PCP.Algebraic.ThreeColorFields.index" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 179, + "is_class": false, + "kind": "theorem", + "line": 177, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_variable_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (v : V),\n (PCP.Reduction.NAEThreeColor.graph Q).Adj (PCP.Reduction.NAEThreeColor.variableVertex v false)\n (PCP.Reduction.NAEThreeColor.variableVertex v true)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Adj", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "PCP.Reduction.NAEThreeColor.variableVertex", + "Bool.false", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every location read by the tester, including the primary Hadamard check. ", + "end_line": 69, + "is_class": false, + "kind": "definition", + "line": 59, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n 1 ≤ r →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r →\n List (PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "List", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "HAppend.hAppend", + "List", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.Hadamard.testQueries", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "List.cons", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "List.nil" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.sizePoly.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ),\n PCP.Machine.NPTableau.sizePoly h q =\n q +\n (PCP.Machine.NPTableau.timePoly h q + 1) *\n (2 + Polynomial.C (Fintype.card h.tm.K) * (PCP.Machine.NPTableau.spacePoly h q + 1))", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "PCP.Machine.NPTableau.sizePoly", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "PCP.Machine.NPTableau.timePoly", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatAtLeastTwo", + "Polynomial.instNatCast", + "PCP.Machine.NPTableau.sizePoly._proof_1", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "Fintype.card", + "Turing.FinTM2.K", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.kFin", + "PCP.Machine.NPTableau.spacePoly" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 161, + "is_class": false, + "kind": "theorem", + "line": 159, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_homogeneousIndex", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (x w : Fin t → ZMod 2),\n (PCP.Algebraic.Hadamard.encode r x) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) w) =\n (PCP.Algebraic.Hadamard.linearEncode x) w", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.Hadamard.linearEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every supplied column is forced by the clean seed rectangle and its error bound. ", + "end_line": 123, + "is_class": false, + "kind": "theorem", + "line": 111, + "module": "PCP.Algebraic.BivariateAgreementFromRectangle", + "name": "PCP.Algebraic.BivariateAgreementFromRectangle.all_columns_recovered", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (a : I → F),\n Function.Injective a →\n ∀ (C : I → Polynomial F),\n (∀ (i : I), (C i).natDegree ≤ d) →\n ∀ (R : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n ∀ (b : Fin (d + 1) → I),\n Function.Injective b →\n ∀ (B : Finset F),\n (∀ y ∈ B, ∀ (j : Fin (d + 1)), Polynomial.eval (a (b j)) (R y) = Polynomial.eval y (C (b j))) →\n ∀ {ε : ℚ},\n (∀ (i : I),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x =>\n Polynomial.eval x (C i)) ≤\n ε) →\n ε * ↑(Fintype.card F) + ↑d < ↑B.card →\n ∀ (i : I),\n PCP.Algebraic.PointLineCrossing.rowPolynomial\n (PCP.Algebraic.BivariateInterpolation.interpolate (a ∘ b) (C ∘ b)) (a i) =\n C i", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Finset", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "Polynomial.eval", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "LT.lt", + "Rat.instLT", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Finset.card", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "PCP.Algebraic.BivariateInterpolation.interpolate", + "Function.comp" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 40, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.eval_coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ) (x : σ → R),\n (MvPolynomial.eval x) (PCP.Algebraic.GridVanishing.coordinate H i) = ∏ a ∈ H, (x i - a)", + "type_dependencies": [ + "CommRing", + "Finset", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.GridVanishing.coordinate", + "Finset.prod", + "CommRing.toCommMonoid", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.predecessor_volume_lt._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ},\n 2 < PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1 < PCP.Algebraic.ThreeColorParameterChoice.exponent N → False", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Not", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u_2) →\n (x : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ((x : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color x q)) →\n ((x : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert x q)) →\n ((x : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference x q)) →\n ((x : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert x q)) →\n ((uv : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine uv x q)) →\n ((uv :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine uv x q)) →\n ((uv :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine uv x q)) →\n ((uv :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine uv x q)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Closure: an efficiently implemented verifier with logarithmic randomness and a polynomial\nproof-length bound induces a polynomial-time NP checking relation.\n\nThis is the bridge between verifier efficiency and NP-checker efficiency.\nDischarging it means showing the model is closed under: enumerating `2 ^ O(log n)` random\nstrings, unfolding a constant-depth query tree, and indexing a polynomially long witness.\n\nThe budget hypothesis is `CanonicalRandomness`, **not** `LogRandomness`. With only an upper\nbound this field is not justifiable for any standard model: an arbitrary `f : ℕ → Bool` can be\nhidden in the budget (see `Verifier.LogRandomness`) and recovered by an elementary\nlength-measuring algorithm, so the field would assert that every unary language has a computable\nchecking relation. A canonical budget is determined by `a` and `b` and carries no such\ninformation. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 104, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.polyTimeRel_finiteWitnessCheck", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (self : PCP.CostModel) (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n self.PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → self.PolyTimeRel (PCP.finiteWitnessCheck V)", + "type_dependencies": [ + "PCP.CostModel", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.CostModel.PolyTimeAlg", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.CostModel.PolyTimeRel", + "PCP.finiteWitnessCheck" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) →\n (x : ℕ) → Nat.below (motive := fun x => List Bool → PCP.QueryTree x) x → List Bool → PCP.QueryTree x", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Nat.below", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Nat.below", + "PCP.QueryTree", + "PCP.QueryTree.ofStep.match_3", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.ofStep.match_1", + "PCP.QueryTree.leaf", + "Bool.false", + "Nat.succ", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.QueryTree.query", + "PProd", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "List.nil", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Exactly the five consecutive noncentral generator powers in the paper. ", + "end_line": 110, + "is_class": false, + "kind": "definition", + "line": 107, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.nodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → Fin 5 ↪ PCP.Algebraic.ThreeColorFields.FieldFamily k", + "type_dependencies": [ + "Nat", + "Function.Embedding", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorFields.FieldFamily" + ], + "value_dependencies": [ + "Nat", + "Function.Embedding.mk", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator", + "PCP.Algebraic.ThreeColorFields.nodes._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "All grid randomness except its outer point. ", + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → Type (max 0 u_2)", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Prod", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum" + ] + }, + { + "axioms": [], + "doc": "Literals include the two fixed Boolean constants. ", + "end_line": 76, + "is_class": false, + "kind": "inductive", + "line": 72, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.Literal" + ], + "type": "Type u_1 → Type u_1", + "type_dependencies": [], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep._sunfold", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree.ofStep.match_3", + "PCP.QueryTree", + "PCP.QueryTree.ofStep.match_1", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.leaf", + "Bool.false", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.QueryTree.query", + "PCP.QueryTree.ofStep", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "List.nil", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`L` is in NP relative to the polynomial-time-checkability notion `P`. ", + "end_line": 43, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Complexity.NP", + "name": "PCP.InNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Prop", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Nonempty", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The rational Walsh character indexed by `a`. ", + "end_line": 143, + "is_class": false, + "kind": "definition", + "line": 142, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character", + "provenance": "lean", + "structural_dependencies": [], + "type": "{ι : Type u_1} → [Fintype ι] → (ι → ZMod 2) → (ι → ZMod 2) → ℚ", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Algebraic.BLR.sign", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] {inst_4 : DecidableEq F} [inst_5 : DecidableEq F] [inst_6 : Fintype V] (a a_1 : I → F),\n a = a_1 →\n ∀ (w w_1 : I → F),\n w = w_1 →\n ∀ (f f_1 : V → F),\n f = f_1 →\n PCP.Algebraic.WeightedConstraint.rejectionRate a w f =\n PCP.Algebraic.WeightedConstraint.rejectionRate a_1 w_1 f_1", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.WeightedConstraint.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.consecutivePointsEquiv._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (t : F) (xy : (σ → F) × (σ → F)),\n (PCP.Algebraic.PolynomialLine.point (xy.1 - t • (xy.2 - xy.1), xy.2 - xy.1).1\n (xy.1 - t • (xy.2 - xy.1), xy.2 - xy.1).2 t,\n PCP.Algebraic.PolynomialLine.point (xy.1 - t • (xy.2 - xy.1), xy.2 - xy.1).1\n (xy.1 - t • (xy.2 - xy.1), xy.2 - xy.1).2 (t + 1)) =\n xy", + "type_dependencies": [ + "Field", + "Prod", + "Eq", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Prod.snd", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.read.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {t r : ℕ} →\n (motive : PCP.Algebraic.BinaryDifferenceConsistency.Query F σ t r → Sort u_3) →\n (x : PCP.Algebraic.BinaryDifferenceConsistency.Query F σ t r) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p)) →\n ((p : (σ ⊕ σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inr p)) → motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Sum", + "Sum.inr" + ], + "value_dependencies": [ + "PCP.Algebraic.BinaryDifferenceConsistency.read.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 99, + "is_class": false, + "kind": "theorem", + "line": 91, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.tree_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool) (r : Fin (2 ^ PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget x.length)) (π : PCP.ProofOracle),\n (PCP.Algebraic.ThreeColorCanonicalVerifier.tree x r).eval π =\n PCP.Algebraic.ThreeColorBinaryVerifier.test (PCP.Algebraic.ThreeColorEncoding.graph x)\n (PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord x π) (PCP.Algebraic.ThreeColorCanonicalVerifier.sample x r)\n (PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode x)", + "type_dependencies": [ + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "List.length", + "PCP.ProofOracle", + "Eq", + "PCP.QueryTree.eval", + "PCP.Algebraic.ThreeColorCanonicalVerifier.tree", + "PCP.Algebraic.ThreeColorBinaryVerifier.test", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "Fin.fintype", + "PCP.Algebraic.ThreeColorEncoding.graph", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.sample", + "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The selected binary coordinate count. ", + "end_line": 161, + "is_class": false, + "kind": "definition", + "line": 160, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.binaryDimension", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.index" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 382, + "is_class": false, + "kind": "definition", + "line": 382, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeGridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n [Fintype F] → [DecidableEq F] → {k : ℕ} → Fintype (PCP.Algebraic.DerivedZeroOnGrid.GridRandomness F k m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.instFintypeCallSeedOfDecidableEq", + "instFintypeSum", + "instDecidableEqSum" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The numerical form of ALMSS Corollary 70 for chosen nearest rows and columns.\nThe nearby bivariate polynomial, whose existence is the substantive preceding\nagreement theorem, remains an explicit argument. ", + "end_line": 321, + "is_class": false, + "kind": "theorem", + "line": 294, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.crossing_bestApproximation_eq_of_nearby_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {d : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F] (f : F × F → F)\n (P : MvPolynomial (Fin 2) F),\n (∀ (i : Fin 2), MvPolynomial.degreeOf i P ≤ d) →\n ∀ (x₀ y₀ : F) {ε ε' : ℚ},\n (PCP.Algebraic.relativeDistance f fun z =>\n Polynomial.eval z.2 ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun y => f (z.1, y))) ≤\n ε →\n (PCP.Algebraic.relativeDistance f fun z =>\n Polynomial.eval z.1 ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun x => f (x, z.2))) ≤\n ε →\n (PCP.Algebraic.relativeDistance f fun z => (MvPolynomial.eval ![z.1, z.2]) P) ≤ 4 * ε →\n (PCP.Algebraic.relativeDistance (fun y => f (x₀, y)) fun y =>\n Polynomial.eval x₀ ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun x => f (x, y))) ≤\n ε' →\n (PCP.Algebraic.relativeDistance (fun x => f (x, y₀)) fun x =>\n Polynomial.eval y₀ ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun y => f (x, y))) ≤\n ε' →\n 5 * ε + ε' + 2 * (↑d / ↑(Fintype.card F)) < 1 / 2 →\n Polynomial.eval y₀ ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun y => f (x₀, y)) =\n Polynomial.eval x₀ ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun x => f (x, y₀))", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Prod", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.degreeOf", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Prod.snd", + "Subtype.val", + "Polynomial", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.bestApproximation", + "Prod.mk", + "Prod.fst", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "LT.lt", + "Rat.instLT", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Origin errors are bounded by sampled line-comparison errors plus `D/(|F|-1)`. ", + "end_line": 118, + "is_class": false, + "kind": "theorem", + "line": 107, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.origin_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {D : ℕ} (T : (σ → F) → Polynomial F),\n (∀ (b : σ → F), (T b).natDegree ≤ D) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n ∀ (a : σ → F),\n (PCP.Algebraic.relativeDistance (fun b => Polynomial.eval 0 (T b)) fun x => (MvPolynomial.eval a) P) ≤\n (PCP.Algebraic.relativeDistance (fun s => Polynomial.eval (↑s.2) (T s.1)) fun s =>\n (MvPolynomial.eval (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2)) P) +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "Polynomial.eval", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Prod", + "Units", + "Semiring.toMonoid", + "instFintypeProd", + "instFintypeUnitsOfDecidableEq", + "Units.val", + "Prod.snd", + "Prod.fst", + "PCP.Algebraic.PolynomialLine.point", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 53, + "is_class": false, + "kind": "definition", + "line": 52, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat" + ], + "value_dependencies": [ + "Field", + "Nat", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.GeneratorLowDegreeTest.correct" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "theorem", + "line": 28, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (x : Fin t → ZMod 2) (c : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n (PCP.Algebraic.Hadamard.encode r x) c = (MvPolynomial.eval x) ((PCP.Algebraic.BinaryPolynomialSpace.polynomial t r) c)", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "RingHom", + "MvPolynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "AddMonoidAlgebra.instAddCommMonoid", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.BinaryPolynomialSpace.polynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 74, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.degreeOf_basis_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽] [inst_1 : DecidableEq 𝔽] [inst_2 : Fintype σ] (H : Finset 𝔽)\n (a : σ → ↥H) (j : σ), MvPolynomial.degreeOf j (PCP.Algebraic.GridInterpolation.basis H a) ≤ H.card - 1", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.degreeOf", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GridInterpolation.basis", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.digitMonomial m c k = ∏ i, MvPolynomial.X (i, PCP.Algebraic.digit m k ↑i)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "Finset.prod", + "Fin", + "CommSemiring.toCommMonoid", + "AddMonoidAlgebra.commSemiring", + "Finsupp", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "MvPolynomial.X", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n ℕ → Sort (max 1 (imax (u_2 + 1) u) (imax (u_2 + 1) (u_2 + 1) u))", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "cond", + "Nat.ble", + "PULift", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The binary difference check reads a common homogeneous label at three locations. ", + "end_line": 54, + "is_class": false, + "kind": "definition", + "line": 48, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {t r : ℕ} →\n 1 ≤ r →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n ((σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n (σ → F) → (σ → F) → (Fin t → ZMod 2) → ZMod 2", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Sum", + "Fin" + ], + "value_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Sum", + "Fin", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Sum.elim", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.parameterShiftEquiv._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (t : F) (s : ((σ → F) × (σ → F)) × F),\n ((((s.1.1 - (t - s.2) • s.1.2, s.1.2), s.2).1.1 +\n (t - ((s.1.1 - (t - s.2) • s.1.2, s.1.2), s.2).2) • ((s.1.1 - (t - s.2) • s.1.2, s.1.2), s.2).1.2,\n ((s.1.1 - (t - s.2) • s.1.2, s.1.2), s.2).1.2),\n ((s.1.1 - (t - s.2) • s.1.2, s.1.2), s.2).2) =\n s", + "type_dependencies": [ + "Field", + "Prod", + "Eq", + "Prod.mk", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The corrected function has minimum prediction error for the fixed lines table. ", + "end_line": 153, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.rejectionRate_correction_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ c),\n PCP.Algebraic.PointLineTest.rejectionRate (PCP.Algebraic.PointLineTest.correction table) table ≤\n PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineTest.correction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 79, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (Y Q : σ → MvPolynomial σ R),\n (PCP.Algebraic.GridVanishing.substitute Y) (PCP.Algebraic.GridVanishing.certificate Q) = ∑ i, Q i * Y i", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "PCP.Algebraic.GridVanishing.certificate", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "constructor", + "line": 30, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.NPCertificate" + ], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Accept unused zero-parameter seeds, otherwise run the actual verifier. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.test", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorFullFieldSampling.test._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "PCP.Algebraic.ThreeColorFullFieldSampling.test.match_1", + "Option", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorFullFieldSampling.decode", + "Unit", + "Bool.true", + "PCP.Algebraic.ThreeColorVerifier.test" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Lemma 3.4: the corrector errs with probability at most `(c+1)·δ(f,P)`, because every\nindividual noncentral sample is uniform. No hypothesis on `δ` or the field size is needed. ", + "end_line": 87, + "is_class": false, + "kind": "theorem", + "line": 61, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} {ζ : F} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ],\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ c →\n ∀ (f : (σ → F) → F) (u : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.StandardLocalCorrection.correct c ζ f u) fun x =>\n (MvPolynomial.eval u) P) ≤\n ↑(c + 1) * PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.StandardLocalCorrection.correct", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An explicit affine ceiling-log bound for every natural-coefficient polynomial. ", + "end_line": 49, + "is_class": false, + "kind": "theorem", + "line": 34, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.clog_eval_add_two_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : Polynomial ℕ) (n : ℕ),\n Nat.clog 2 (Polynomial.eval n p + 2) ≤ p.natDegree * Nat.clog 2 (n + 2) + Nat.clog 2 (Polynomial.eval 1 p + 2)", + "type_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring", + "LE.le", + "instLENat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Polynomial.eval", + "HMul.hMul", + "instHMul", + "instMulNat", + "Polynomial.natDegree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every concrete NP language has a certified program computing its encoded graph reduction. ", + "end_line": 265, + "is_class": false, + "kind": "theorem", + "line": 256, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.of_inNP_program", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language},\n PCP.InNP PCP.Machine.PolyTimeRel L →\n ∃ f p P C d,\n ∀ (x : List Bool),\n P.run (List.map Bool.toNat x) = List.map Bool.toNat (f x) ∧\n P.cost (List.map Bool.toNat x) ≤ C * (x.length + 1) ^ d ∧\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧\n (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "List", + "Bool", + "Polynomial", + "Nat", + "Nat.instSemiring", + "PCP.Lang.Prog", + "And", + "Eq", + "PCP.Lang.Prog.run", + "List.map", + "Bool.toNat", + "LE.le", + "instLENat", + "PCP.Lang.Prog.cost", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "OfNat.ofNat", + "instOfNatNat", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness in the original oracle-verifier model. ", + "end_line": 156, + "is_class": false, + "kind": "theorem", + "line": 147, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.completeAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.CompleteAt x", + "type_dependencies": [ + "List", + "Bool", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Verifier.CompleteAt", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.validPolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F),\n PCP.Algebraic.ThreeColorGrid.validPolynomial P = P ^ 3 - 1", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "AddMonoidAlgebra.semiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidAlgebra.zero", + "Finsupp.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "SizeOf PCP.Machine.Sym", + "type_dependencies": [ + "SizeOf", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "SizeOf.mk", + "PCP.Machine.Sym", + "PCP.Machine.Sym._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 76, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.symbolicX_inY", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (p : Polynomial F),\n PCP.Algebraic.BerlekampWelchCertificate.symbolicX (PCP.Algebraic.BerlekampWelchCertificate.inY p) = Polynomial.C p", + "type_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Polynomial.semiring", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "PCP.Algebraic.BerlekampWelchCertificate.symbolicX", + "PCP.Algebraic.BerlekampWelchCertificate.inY", + "Polynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An actual `FinTM2` realizes the complete construction at the unchanged public bit encoding. ", + "end_line": 143, + "is_class": false, + "kind": "theorem", + "line": 134, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.polyTimeMap", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits (PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits", + "PCP.Reduction.NPThreeColorRuntime.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 24, + "is_class": false, + "kind": "definition", + "line": 24, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.sep.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} → (t : PCP.Machine.Sym) → t.ctorIdx = 1 → motive PCP.Machine.Sym.sep → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.firstLabelEquiv._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {W : Type u_2} (x : (V × V) × W),\n ((((x.1.1, x.2), x.1.2).1.1, ((x.1.1, x.2), x.1.2).2), ((x.1.1, x.2), x.1.2).1.2) =\n ((((x.1.1, x.2), x.1.2).1.1, ((x.1.1, x.2), x.1.2).2), ((x.1.1, x.2), x.1.2).1.2)", + "type_dependencies": [ + "Prod", + "Eq", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le_log_add_one._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), max 8 (Nat.clog 2 N) ≤ 8 * (Nat.clog 2 N + 1) → ¬4 * max 8 (Nat.clog 2 N) ≤ 32 * (Nat.clog 2 N + 1) → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "Preorder.toLE", + "Nat.instPreorder", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 162, + "is_class": false, + "kind": "theorem", + "line": 159, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.rowPolynomial_assemble_eq_eval_series", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {k : ℕ} (v : Fin (k + 1) → Polynomial F) (x : F),\n PCP.Algebraic.PointLineCrossing.rowPolynomial (PCP.Algebraic.BerlekampWelchCertificate.assemble v) x =\n Polynomial.eval (Polynomial.C x) (PCP.Algebraic.BerlekampWelchCertificate.series v)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "PCP.Algebraic.BerlekampWelchCertificate.assemble", + "Polynomial.eval", + "CommRing.toCommSemiring", + "Polynomial.commRing", + "Field.toCommRing", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "PCP.Algebraic.BerlekampWelchCertificate.series" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The selected cardinality meets the requested threshold, also at zero. ", + "end_line": 133, + "is_class": false, + "kind": "theorem", + "line": 129, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.le_card_chosen", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), M ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "No proof for a noncolorable graph defeats the fixed positive rejection bound. ", + "end_line": 244, + "is_class": false, + "kind": "theorem", + "line": 228, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate_ge_of_not_colorable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V),\n ¬G.Colorable 3 →\n ∀ (π : PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (Fintype.card V))\n (eV : optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V)),\n PCP.Algebraic.ThreeColorBinaryVerifier.gap ≤ PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate G π eV", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "Not", + "SimpleGraph.Colorable", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Fintype.card", + "optParam", + "Equiv", + "Fin", + "Fintype.equivFin", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap", + "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The threshold for applying the bivariate agreement theorem. ", + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 24, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.agreementError", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℚ", + "type_dependencies": [ + "Rat" + ], + "value_dependencies": [ + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A received word cannot be within distance less than one quarter of two messages. ", + "end_line": 134, + "is_class": false, + "kind": "theorem", + "line": 125, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.eq_of_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ},\n 1 ≤ r →\n ∀ (x y : Fin t → ZMod 2) (w : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) {ε : ℚ},\n ε < 1 / 4 →\n PCP.Algebraic.relativeDistance w ⇑(PCP.Algebraic.Hadamard.encode r x) ≤ ε →\n PCP.Algebraic.relativeDistance w ⇑(PCP.Algebraic.Hadamard.encode r y) ≤ ε → x = y", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "LT.lt", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_add", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : ZMod 2), PCP.Algebraic.BLR.sign (a + b) = PCP.Algebraic.BLR.sign a * PCP.Algebraic.BLR.sign b", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.sign", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The two fresh primary queries followed by both unchanged certificate query lists. ", + "end_line": 83, + "is_class": false, + "kind": "definition", + "line": 73, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Q : (Fin n → F) → Polynomial F) →\n (∀ (x : Fin n → F), (Q x).natDegree ≤ r) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r →\n List (PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t r)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.DerivedZeroOnGrid.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "HAppend.hAppend", + "List", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.HadamardDerivedOracle.queries", + "Field.toCommRing", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "PCP.Algebraic.DerivedZeroOnGrid.callQueries", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ] + }, + { + "axioms": [ + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "Equiv.sumArrowEquivProdArrow.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (α : Type u_9) (β : Type u_10) (γ : Type u_11),\n Equiv.sumArrowEquivProdArrow α β γ =\n { toFun := fun f => (f ∘ Sum.inl, f ∘ Sum.inr), invFun := fun p => Sum.elim p.1 p.2, left_inv := ⋯, right_inv := ⋯ }", + "type_dependencies": [ + "Eq", + "Equiv", + "Sum", + "Prod", + "Equiv.sumArrowEquivProdArrow", + "Equiv.mk", + "Prod.mk", + "Function.comp", + "Sum.inl", + "Sum.inr", + "Sum.elim", + "Prod.fst", + "Prod.snd", + "Equiv.sumArrowEquivProdArrow._proof_1", + "Equiv.sumArrowEquivProdArrow._proof_2" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Lemma 3.3 for the generator-weighted test, strengthened to the linear field-size\nhypothesis `q > 2c` (the paper assumes `q > C*c^3`). ", + "end_line": 292, + "is_class": false, + "kind": "theorem", + "line": 272, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F} [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ],\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : (σ → F) → F) {δ : ℚ},\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f ≤ δ →\n δ < 1 / (2 * (↑c + 2) ^ 2) →\n ∃ P, P.totalDegree ≤ c ∧ (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤ 2 * δ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t} →\n {validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t} →\n {properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t} →\n {color' :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {validCert' :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {difference' :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {properCert' :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {colorLines' : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t} →\n {validLines' differenceLines' :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t} →\n {properLines' :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c\n t} →\n { color := color, validCert := validCert, difference := difference,\n properCert := properCert, colorLines := colorLines, validLines := validLines,\n differenceLines := differenceLines, properLines := properLines } =\n { color := color', validCert := validCert', difference := difference',\n properCert := properCert', colorLines := colorLines', validLines := validLines',\n differenceLines := differenceLines', properLines := properLines' } →\n (color ≍ color' →\n validCert ≍ validCert' →\n difference ≍ difference' →\n properCert ≍ properCert' →\n colorLines ≍ colorLines' →\n validLines ≍ validLines' →\n differenceLines ≍ differenceLines' → properLines ≍ properLines' → P) →\n P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.WeightedConstraint.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] [inst_4 : DecidableEq F] [inst_5 : Fintype V] (a w : I → F) (f : V → F),\n PCP.Algebraic.WeightedConstraint.rejectionRate a w f =\n PCP.Algebraic.relativeDistance (fun s => f s.1) fun s => PCP.Algebraic.WeightedConstraint.predict a w f s.1 s.2", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Prod.fst", + "PCP.Algebraic.WeightedConstraint.predict", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.generator_ne_zero._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Fintype F], 1 < Fintype.card F → Fintype.card F - 1 = 0 → False", + "type_dependencies": [ + "Fintype", + "LT.lt", + "Nat", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Program-bearing NP certificate reduction, ready for actual verifier preprocessing. ", + "end_line": 254, + "is_class": false, + "kind": "theorem", + "line": 243, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.of_certificate_program", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language} (cert : PCP.NPCertificate PCP.Machine.PolyTimeRel L),\n ∃ f p P C d,\n ∀ (x : List Bool),\n P.run (List.map Bool.toNat x) = List.map Bool.toNat (f x) ∧\n P.cost (List.map Bool.toNat x) ≤ C * (x.length + 1) ^ d ∧\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧ (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "PCP.Language", + "PCP.NPCertificate", + "PCP.Machine.PolyTimeRel", + "Exists", + "List", + "Bool", + "Polynomial", + "Nat", + "Nat.instSemiring", + "PCP.Lang.Prog", + "And", + "Eq", + "PCP.Lang.Prog.run", + "List.map", + "Bool.toNat", + "LE.le", + "instLENat", + "PCP.Lang.Prog.cost", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "OfNat.ofNat", + "instOfNatNat", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (5 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "recursor", + "line": 72, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u} →\n ((a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a)) →\n ((a : V) → (a_1 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)) →\n (t : PCP.Reduction.NAEThreeColor.Literal V) → motive t", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "_private.PCP.Algebraic.ThreeColorCanonicalVerifier.0.PCP.Algebraic.ThreeColorCanonicalVerifier.power_bound_mono._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N n : ℕ}, N ≤ n → ¬4 * max 1 N ≤ 4 * (n + 1) → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Not", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Distrib.toMul", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Nat.instCommSemiring", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "theorem", + "line": 131, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.totalDegree_formalQuery_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.HadamardComposition.formalQuery ρ P L).totalDegree ≤ P.natDegree", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.HadamardComposition.formalQuery", + "Polynomial.natDegree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 163, + "is_class": false, + "kind": "theorem", + "line": 161, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (c k : ℕ) (i : Fin c) (j : Fin m),\n (PCP.Algebraic.SetMultilinear.digitExponents m c k) (i, j) = if PCP.Algebraic.digit m k ↑i = j then 1 else 0", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Fin", + "Eq", + "DFunLike.coe", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "Finsupp.instFunLike", + "PCP.Algebraic.SetMultilinear.digitExponents", + "Prod.mk", + "ite", + "PCP.Algebraic.digit", + "Fin.val", + "instDecidableEqFin", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.BinaryZeroOnGridCorrection.Query F n m c t → Sort u_2) →\n (x : PCP.Algebraic.BinaryZeroOnGridCorrection.Query F n m c t) →\n ((q : (Fin n → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl q)) →\n ((q :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n ×\n PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t) →\n motive (Sum.inr q)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.exists_polynomial_of_hasLowDegreeLines._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [Fintype F] {d : ℕ} (n : ℕ) (a : Fin (d + 1) ↪ F)\n (P : Fin (d + 1) → MvPolynomial (Fin n) F) (p : Polynomial F), ¬d ≤ 2 * d → False", + "type_dependencies": [ + "Field", + "Fintype", + "Nat", + "Function.Embedding", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial", + "CommSemiring.toSemiring", + "Not", + "LE.le", + "Preorder.toLE", + "Nat.instPreorder", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → {motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u} → ℕ → Sort (max 1 u (imax (u_1 + 1) u))", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Nat" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Nat", + "cond", + "Nat.ble", + "PULift", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 85, + "is_class": false, + "kind": "constructor", + "line": 85, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Verifier" + ], + "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 40, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.readCell_of_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} (s : PCP.Machine.TableauCells.Cells tm B) (k : tm.K) (j : Fin B),\n PCP.Machine.TableauCells.readCell s k ↑j = Option.map Subtype.val (s k j)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "Fin", + "Eq", + "Option", + "Turing.FinTM2.Γ", + "PCP.Machine.TableauCells.readCell", + "Fin.val", + "Option.map", + "Subtype", + "PCP.Machine.Supported", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "constructor", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "One palette triangle, a complementary pair per variable, a triangle per clause. ", + "end_line": 84, + "is_class": false, + "kind": "definition", + "line": 83, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Vertex", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_1 → Type u_2 → Type (max 0 u_2 u_1)", + "type_dependencies": [], + "value_dependencies": [ + "Sum", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Prod", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.consecutivePointsEquiv._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (t : F) (uv : (σ → F) × (σ → F)),\n ((PCP.Algebraic.PolynomialLine.point uv.1 uv.2 t, PCP.Algebraic.PolynomialLine.point uv.1 uv.2 (t + 1)).1 -\n t •\n ((PCP.Algebraic.PolynomialLine.point uv.1 uv.2 t, PCP.Algebraic.PolynomialLine.point uv.1 uv.2 (t + 1)).2 -\n (PCP.Algebraic.PolynomialLine.point uv.1 uv.2 t, PCP.Algebraic.PolynomialLine.point uv.1 uv.2 (t + 1)).1),\n (PCP.Algebraic.PolynomialLine.point uv.1 uv.2 t, PCP.Algebraic.PolynomialLine.point uv.1 uv.2 (t + 1)).2 -\n (PCP.Algebraic.PolynomialLine.point uv.1 uv.2 t, PCP.Algebraic.PolynomialLine.point uv.1 uv.2 (t + 1)).1) =\n uv", + "type_dependencies": [ + "Field", + "Prod", + "Eq", + "Prod.mk", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Prod.fst", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.snd", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Slice interpolation recovers all first-coordinate lines, not only the selected slices. ", + "end_line": 99, + "is_class": false, + "kind": "theorem", + "line": 75, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.eval_interpolateSlices_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n d : ℕ} {a : Fin (d + 1) → F},\n Function.Injective a →\n ∀ (P : Fin (d + 1) → MvPolynomial (Fin n) F) (f : (Fin (n + 1) → F) → F),\n (∀ (i : Fin (d + 1)) (y : Fin n → F), (MvPolynomial.eval y) (P i) = f (Fin.cons (a i) y)) →\n (∀ (y : Fin n → F), ∃ p, p.natDegree ≤ d ∧ ∀ (t : F), Polynomial.eval t p = f (Fin.cons t y)) →\n ∀ (z : Fin (n + 1) → F), (MvPolynomial.eval z) (PCP.Algebraic.PolynomialLine.interpolateSlices a P) = f z", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Fin.cons", + "Exists", + "Polynomial", + "And", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Polynomial.eval", + "PCP.Algebraic.PolynomialLine.interpolateSlices" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.predictedCell.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} (p : PCP.Machine.TableauCells.Prefix tm) (k : tm.K) (j : ℕ)\n (old : Fin (PCP.Machine.FiniteTransitionTable.outputBound tm + 1) → Option (tm.Γ k)),\n PCP.Machine.TableauCells.predictedCell p k j old =\n if j < ↑((PCP.Machine.FiniteTransitionTable.localStep tm p).2.2 k).fst then\n ((PCP.Machine.ComputationTableau.decodeRow (PCP.Machine.FiniteTransitionTable.localStep tm p)).stk k)[j]?\n else old ((PCP.Machine.FiniteTransitionTable.localStep tm p).2.2 k).fst", + "type_dependencies": [ + "Turing.FinTM2", + "PCP.Machine.TableauCells.Prefix", + "Turing.FinTM2.K", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.FiniteTransitionTable.outputBound", + "OfNat.ofNat", + "instOfNatNat", + "Option", + "Turing.FinTM2.Γ", + "Eq", + "PCP.Machine.TableauCells.predictedCell", + "ite", + "LT.lt", + "instLTNat", + "Fin.val", + "Sigma.fst", + "PCP.Machine.ComputationTableau.Symbol", + "Prod.snd", + "Turing.FinTM2.σ", + "PCP.Machine.ComputationTableau.Stack", + "Turing.FinTM2.Λ", + "Prod", + "PCP.Machine.FiniteTransitionTable.localStep", + "Nat.decLt", + "GetElem?.getElem?", + "List", + "List.length", + "List.instGetElem?NatLtLength", + "Turing.TM2.Cfg.stk", + "PCP.Machine.ComputationTableau.decodeRow" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The center and the `c+1` generator positions are all the queried values. ", + "end_line": 62, + "is_class": false, + "kind": "definition", + "line": 60, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → (σ → F) → (σ → F) → List (σ → F)", + "type_dependencies": [ + "Field", + "Nat", + "List" + ], + "value_dependencies": [ + "Field", + "Nat", + "List.cons", + "List.ofFn", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨1, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 1 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 14 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every finite field retains at least one sixteenth of the old rejection. ", + "end_line": 177, + "is_class": false, + "kind": "theorem", + "line": 167, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate_ge_sixteenth", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π / 16 ≤\n PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "LE.le", + "Rat", + "Rat.instLE", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The acceptance bias of the three-query test is the third Fourier moment. ", + "end_line": 282, + "is_class": false, + "kind": "theorem", + "line": 260, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.cubic_identity", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ),\n (PCP.Algebraic.BLR.average fun x => PCP.Algebraic.BLR.average fun y => f x * f y * f (x + y)) =\n ∑ a, PCP.Algebraic.BLR.fourier f a ^ 3", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.fourier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 34, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.correct_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (c : ℕ) (ζ : F)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (u v : σ → F) (w : Fin t → ZMod 2)\n (H G : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n (∀ p ∈ PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ u v w, H p.1 p.2 = G p.1 p.2) →\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ H u v w =\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ G u v w", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "Eq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.correct_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (c : ℕ) (ζ : F) (f : (σ → F) → F) (u v : σ → F) (w : Fin t → ZMod 2),\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ (f x)))) u v\n w =\n (PCP.Algebraic.Hadamard.linearEncode (ρ (PCP.Algebraic.StandardLocalCorrection.correct c ζ f u v))) w", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.Hadamard.linearEncode", + "PCP.Algebraic.StandardLocalCorrection.correct" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ], + "value_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk", + "PCP.CostModel.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.palette._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V)\n (f : (PCP.Reduction.NAEThreeColor.graph Q).Coloring (Fin 3)) ⦃i j : Fin 3⦄,\n f (PCP.Reduction.NAEThreeColor.base i) = f (PCP.Reduction.NAEThreeColor.base j) → i = j", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "Eq", + "DFunLike.coe", + "RelHom.instFunLike", + "SimpleGraph.Adj", + "SimpleGraph.completeGraph", + "PCP.Reduction.NAEThreeColor.base" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A boundary check reads the control value and each single cell. ", + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 72, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.Boundary", + "provenance": "lean", + "structural_dependencies": [], + "type": "{tm : Turing.FinTM2} →\n {B : ℕ} → PCP.Machine.TableauCells.Prefix tm → PCP.Machine.TableauCells.Cells tm B → tm.Cfg → Prop", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg", + "And", + "Eq", + "Option", + "Turing.FinTM2.Λ", + "Turing.TM2.Cfg.l", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.σ", + "PCP.Machine.ComputationTableau.decodeRow", + "PCP.Machine.TM2Locality.machineWindow", + "Turing.TM2.Cfg.var", + "Fin", + "PCP.Machine.TableauCells.readCell", + "Fin.val", + "GetElem?.getElem?", + "List", + "LT.lt", + "instLTNat", + "List.length", + "List.instGetElem?NatLtLength", + "Turing.TM2.Cfg.stk" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.degreeOf_inY_zero._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Two independent call seeds, with the common point and label sampled once. ", + "end_line": 61, + "is_class": false, + "kind": "definition", + "line": 58, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Prod", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Column-wise proximity controls the mean number of errors across the supplied columns. ", + "end_line": 108, + "is_class": false, + "kind": "theorem", + "line": 89, + "module": "PCP.Algebraic.BivariateAgreementFromRectangle", + "name": "PCP.Algebraic.BivariateAgreementFromRectangle.expect_rowErrors_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype I]\n (a : I → F) (C : I → Polynomial F) (R : F → Polynomial F) {ε : ℚ},\n (∀ (i : I),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x => Polynomial.eval x (C i)) ≤ ε) →\n (Finset.univ.expect fun y =>\n ↑(hammingDist (fun i => Polynomial.eval (a i) (R y)) fun i => Polynomial.eval y (C i))) ≤\n ↑(Fintype.card I) * ε", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Polynomial.eval", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "Nat.cast", + "Rat.instNatCast", + "hammingDist", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every branch uses only its own mapped physical query list. ", + "end_line": 290, + "is_class": false, + "kind": "theorem", + "line": 258, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π π' : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (i : Fin 7)\n (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i),\n (∀ q ∈ PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i s,\n PCP.Algebraic.ThreeColorVerifier.read π q = PCP.Algebraic.ThreeColorVerifier.read π' q) →\n PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G π i s =\n PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G π' i s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.read", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A convenient uniform constant when the field has at least three times the degree. ", + "end_line": 161, + "is_class": false, + "kind": "theorem", + "line": 150, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.rejectionAt_le_four_mul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (f : (σ → F) → F) (t : F),\n 3 * c ≤ Fintype.card F →\n PCP.Algebraic.PointLineTest.rejectionAt c f t ≤\n 4 * PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable c f)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.rejectionAt", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineTest.decodedTable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Consecutive parameters send a uniform ordered center/direction pair to two uniform points. ", + "end_line": 74, + "is_class": false, + "kind": "definition", + "line": 65, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.consecutivePointsEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → F → (σ → F) × (σ → F) ≃ (σ → F) × (σ → F)", + "type_dependencies": [ + "Field", + "Equiv", + "Prod" + ], + "value_dependencies": [ + "Field", + "Equiv.mk", + "Prod", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "Prod.snd", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "PCP.Algebraic.PointLineTest.consecutivePointsEquiv._proof_1", + "PCP.Algebraic.PointLineTest.consecutivePointsEquiv._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Averaging rows and arbitrary point-dependent requested labels costs twice full distance.\nThe final coefficient seed is still fresh and explicitly sampled. ", + "end_line": 122, + "is_class": false, + "kind": "theorem", + "line": 108, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.averaged_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} {I : Type u_2} [inst_2 : Fintype I]\n {A : Type u_3} [inst_3 : Fintype A] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (P : I → Polynomial F)\n (hP : ∀ (i : I), (P i).natDegree ≤ r) (H : I → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (f : I → F) (L : I → A → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.relativeDistance\n (fun s => PCP.Algebraic.HadamardDerivedOracle.answer ρ (P s.1) ⋯ (H s.1) (L s.1 s.2.1) s.2.2) fun s =>\n (PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval (f s.1) (P s.1)))) (L s.1 s.2.1)) ≤\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ H f", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 71, + "is_class": false, + "kind": "theorem", + "line": 65, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t),\n (PCP.Algebraic.ThreeColorFullFieldSampling.queries ρ nodes ζ H G s).length ≤ 20 * c + 107", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorFullFieldSampling.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Binary line comparison controls field-valued origin error via the exact half-distance. ", + "end_line": 333, + "is_class": false, + "kind": "theorem", + "line": 318, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.origin_error_le_twice_binary_comparison", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : DecidableEq F] {t : ℕ} {σ : Type u_3} [inst_1 : Field F] [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] {D : ℕ} (ρ : F → Fin t → ZMod 2),\n Function.Injective ρ →\n ∀ (T : (σ → F) → Polynomial F),\n (∀ (b : σ → F), (T b).natDegree ≤ D) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n ∀ (a : σ → F),\n (PCP.Algebraic.relativeDistance (fun b => Polynomial.eval 0 (T b)) fun x => (MvPolynomial.eval a) P) ≤\n (2 *\n PCP.Algebraic.relativeDistance\n (fun s => (PCP.Algebraic.Hadamard.linearEncode (ρ (Polynomial.eval (↑s.1.2) (T s.1.1)))) s.2)\n fun s =>\n (PCP.Algebraic.Hadamard.linearEncode\n (ρ ((MvPolynomial.eval (PCP.Algebraic.PolynomialLine.point a s.1.1 ↑s.1.2)) P)))\n s.2) +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "DecidableEq", + "Nat", + "Field", + "Fintype", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "Polynomial.eval", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "Prod", + "Units", + "Semiring.toMonoid", + "instFintypeProd", + "instFintypeUnitsOfDecidableEq", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "LinearMap", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Units.val", + "Prod.snd", + "Prod.fst", + "PCP.Algebraic.PolynomialLine.point", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.ProofOracle) (b : Bool), (PCP.QueryTree.leaf b).eval x_1 = b", + "type_dependencies": [ + "Nat", + "PCP.ProofOracle", + "Bool", + "Eq", + "PCP.QueryTree.eval", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval._unsafe_rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "PCP.QueryTree.eval.match_1", + "Bool", + "ite", + "Eq", + "Bool.true", + "instDecidableEqBool", + "PCP.QueryTree.eval._unsafe_rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 147, + "is_class": false, + "kind": "theorem", + "line": 145, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode_single", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x : Fin t → ZMod 2) (i : Fin t), (PCP.Algebraic.Hadamard.linearEncode x) (Pi.single i 1) = x i", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Pi.single", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "instDecidableEqFin", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.canonicalRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CanonicalRandomness\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000)\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000)", + "type_dependencies": [ + "PCP.Verifier.CanonicalRandomness", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HMul.hMul", + "Nat", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (π : PCP.ProofOracle) (h_1 : (x : ℕ) → (b : Bool) → (x_1 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_1)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match d + 1, PCP.QueryTree.query a f t, π with\n | x, PCP.QueryTree.leaf b, x_1 => h_1 x b x_1\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_2 d a f t π", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.eval.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 82, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.input", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} →\n (h : PCP.Machine.NPTableau.Checker R) → List Bool → List Bool → List (h.tm.Γ h.tm.k₀)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Turing.FinTM2.Γ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.k₀" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "List.map", + "PCP.Machine.Sym", + "Turing.FinTM2.Γ", + "Turing.TM2ComputableAux.tm", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.k₀", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "Turing.TM2ComputableAux.inputAlphabet", + "Prod.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A certificate for the actual fixed pair and Boolean encodings. ", + "end_line": 49, + "is_class": false, + "kind": "definition", + "line": 47, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.Checker", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → List Bool → Bool) → Type 1", + "type_dependencies": [ + "List", + "Bool" + ], + "value_dependencies": [ + "List", + "Bool", + "Turing.TM2ComputableInPolyTime", + "Prod", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 80, + "is_class": false, + "kind": "theorem", + "line": 73, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.totalDegree_coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R) (i : σ),\n (PCP.Algebraic.GridVanishing.coordinate H i).totalDegree = H.card", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "Eq", + "Nat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.GridVanishing.coordinate", + "Finset.card" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : PCP.ProofOracle) (d a : ℕ) (f t : PCP.QueryTree d),\n (PCP.QueryTree.query a f t).eval x = if x a = true then t.eval x else f.eval x", + "type_dependencies": [ + "PCP.ProofOracle", + "Nat", + "PCP.QueryTree", + "Eq", + "Bool", + "PCP.QueryTree.eval", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "ite", + "Bool.true", + "instDecidableEqBool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Evaluation of a coordinate slice updates precisely the selected coordinate. ", + "end_line": 206, + "is_class": false, + "kind": "theorem", + "line": 198, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.eval_axisRestrict", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : DecidableEq σ] (u : σ → F) (i : σ) (P : MvPolynomial σ F)\n (t : F),\n Polynomial.eval t ((PCP.Algebraic.PointLineCrossing.axisRestrict u i) P) =\n (MvPolynomial.eval (Function.update u i t)) P", + "type_dependencies": [ + "Field", + "DecidableEq", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Polynomial.eval", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.PointLineCrossing.axisRestrict", + "MvPolynomial.eval", + "Function.update" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 140, + "is_class": false, + "kind": "theorem", + "line": 131, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate_eq_card_ratio", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate ρ nodes ζ H G π =\n ↑(Fintype.card (PCP.Algebraic.ThreeColorVerifier.Sample F n m c t)) /\n ↑(Fintype.card (PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t)) *\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Pi.instFintype", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawBranchSeed", + "PCP.Algebraic.ThreeColorFullFieldSampling.rawBranchSeedFintype", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.test.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (s : PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t),\n PCP.Algebraic.ThreeColorFullFieldSampling.test ρ nodes ζ H G π s =\n match PCP.Algebraic.ThreeColorFullFieldSampling.decode s with\n | none => true\n | some a => PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorFullFieldSampling.test._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorFullFieldSampling.test", + "PCP.Algebraic.ThreeColorFullFieldSampling.test.match_1", + "Option", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorFullFieldSampling.decode", + "Unit", + "Bool.true", + "PCP.Algebraic.ThreeColorVerifier.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.certificate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (Q : σ → MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.certificate Q = ∑ i, (MvPolynomial.rename Sum.inl) (Q i) * MvPolynomial.X (Sum.inr i)", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "Sum", + "PCP.Algebraic.GridVanishing.certificate", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "DFunLike.coe", + "AlgHom", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Sum.inl", + "MvPolynomial.X", + "Sum.inr" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.sample.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F)\n (s : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a s =\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ f H a s.1 s.2.1 s.2.2.1.1 s.2.2.1.2 s.2.2.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "PCP.Algebraic.BinaryLocalCorrection.run", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The distance definition is exactly the probability of a nonzero check residual. ", + "end_line": 142, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate_eq_check_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] {t r : ℕ} (hr : 1 ≤ r)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (g : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr f g =\n PCP.Algebraic.relativeDistance (fun s => PCP.Algebraic.BinaryDifferenceConsistency.check hr f g s.1.1 s.1.2 s.2)\n fun x => 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Sum", + "Eq", + "Rat", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "PCP.Algebraic.relativeDistance", + "Prod", + "Fin", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryDifferenceConsistency.check", + "Prod.fst", + "Prod.snd", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{a : ℕ} → PCP.QueryTree a → ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.rec", + "Bool", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "instSizeOfNat", + "Bool._sizeOf_inst" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The input bound in the paper's `degree ≤ d`, `d < m ^ c` form. ", + "end_line": 113, + "is_class": false, + "kind": "theorem", + "line": 109, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_encode_of_degree_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c →\n ∀ (P : Polynomial R),\n P.natDegree ≤ d →\n ∀ (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n ((PCP.Algebraic.SetMultilinear.encode m c) P) =\n Polynomial.eval x P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Polynomial", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "LinearMap", + "RingHom.id", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The public adjacency extension, on the flattened pair of vertex coordinates. ", + "end_line": 54, + "is_class": false, + "kind": "definition", + "line": 50, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.edgePolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : Field F] → {n : ℕ} → (H : Finset F) → SimpleGraph (Fin n → ↥H) → MvPolynomial (Fin (n + n)) F", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "DFunLike.coe", + "AlgHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "AddMonoidAlgebra.semiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Comparing line rows with an imperfect oracle adds exactly its global error. ", + "end_line": 146, + "is_class": false, + "kind": "theorem", + "line": 133, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.origin_error_le_comparison_add_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {D : ℕ} (T : (σ → F) → Polynomial F),\n (∀ (b : σ → F), (T b).natDegree ≤ D) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n ∀ (a : σ → F) (f : (σ → F) → F),\n (PCP.Algebraic.relativeDistance (fun b => Polynomial.eval 0 (T b)) fun x => (MvPolynomial.eval a) P) ≤\n ((PCP.Algebraic.relativeDistance (fun s => Polynomial.eval (↑s.2) (T s.1)) fun s =>\n f (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2)) +\n PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "Polynomial.eval", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Prod", + "Units", + "Semiring.toMonoid", + "instFintypeProd", + "instFintypeUnitsOfDecidableEq", + "Units.val", + "Prod.snd", + "Prod.fst", + "PCP.Algebraic.PolynomialLine.point", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The source's numerical `1/9` proximity conclusion, conditional only on the\nexplicit clean rectangle and the `1/10` column errors at `10d` distinct nodes. ", + "end_line": 226, + "is_class": false, + "kind": "theorem", + "line": 200, + "module": "PCP.Algebraic.BivariateAgreementFromRectangle", + "name": "PCP.Algebraic.BivariateAgreementFromRectangle.exists_nearby_polynomial_one_ninth", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype I]\n {d : ℕ} (a : I → F),\n Function.Injective a →\n ∀ (C : I → Polynomial F),\n (∀ (i : I), (C i).natDegree ≤ d) →\n ∀ (R : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n ∀ (b : Fin (d + 1) → I),\n Function.Injective b →\n ∀ (B : Finset F),\n (∀ y ∈ B, ∀ (j : Fin (d + 1)), Polynomial.eval (a (b j)) (R y) = Polynomial.eval y (C (b j))) →\n (∀ (i : I),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x =>\n Polynomial.eval x (C i)) ≤\n 1 / 10) →\n 1 / 10 * ↑(Fintype.card F) + ↑d < ↑B.card →\n Fintype.card I = 10 * d →\n ∃ P,\n (∀ (j : Fin 2), MvPolynomial.degreeOf j P ≤ d) ∧\n (∀ (i : I), PCP.Algebraic.PointLineCrossing.rowPolynomial P (a i) = C i) ∧\n PCP.Algebraic.relativeDistance R (PCP.Algebraic.PointLineCrossing.columnPolynomial P) ≤\n 1 / 9 ∧\n (PCP.Algebraic.relativeDistance (fun z => Polynomial.eval z.1 (R z.2)) fun z =>\n (MvPolynomial.eval ![z.1, z.2]) P) ≤\n 1 / 9", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Finset", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "Polynomial.eval", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "LT.lt", + "Rat.instLT", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Finset.card", + "instMulNat", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.degreeOf", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "Polynomial.instDecidableEq", + "PCP.Algebraic.PointLineCrossing.columnPolynomial", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A plurality value exists because the finite alphabet has a most frequent value. ", + "end_line": 39, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.Plurality.exists_minimizer", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {A : Type u_2} [inst : Fintype R] [Finite A] [Nonempty A] [inst_3 : DecidableEq A] (w : R → A),\n ∃ a, ∀ (b : A), (PCP.Algebraic.relativeDistance w fun x => a) ≤ PCP.Algebraic.relativeDistance w fun x => b", + "type_dependencies": [ + "Fintype", + "Finite", + "Nonempty", + "DecidableEq", + "Exists", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "`alg` implements `V`: unfolding the algorithm reproduces `V`'s decision tree on every input and\nevery random string.\n\nThis ties the certificate to *this* verifier — its random-bit handling (`bitsOfFin`), its query\naddresses, and its decision rule all have to match. Proving some unrelated verifier efficient\nwould not discharge it. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Complexity.CostModel", + "name": "PCP.Verifier.ImplementedBy", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → PCP.VerifierAlg → Prop", + "type_dependencies": [ + "PCP.Verifier", + "PCP.VerifierAlg" + ], + "value_dependencies": [ + "PCP.Verifier", + "PCP.VerifierAlg", + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Eq", + "PCP.QueryTree", + "PCP.Verifier.queries", + "PCP.QueryTree.ofStep", + "PCP.bitsOfFin", + "List.nil", + "PCP.Verifier.run" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} {a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3},\n PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.difference a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.below", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → {a : ℕ} → PCP.QueryTree a → Sort (max 1 u)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.rec", + "Bool", + "PUnit", + "PProd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Distinct degree-bounded polynomials disagree on at least `n-d` distinct sample points. ", + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 59, + "module": "PCP.Algebraic.BivariateAgreementFromRectangle", + "name": "PCP.Algebraic.BivariateAgreementFromRectangle.sample_disagreementCount_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : DecidableEq F] [inst_2 : Fintype I] {d : ℕ} (a : I → F),\n Function.Injective a →\n ∀ (p q : Polynomial F),\n p.natDegree ≤ d →\n q.natDegree ≤ d →\n p ≠ q →\n ↑(Fintype.card I) - ↑d ≤ ↑(hammingDist (fun i => Polynomial.eval (a i) p) fun i => Polynomial.eval (a i) q)", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Nat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Ne", + "Rat", + "Rat.instLE", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "hammingDist", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → ℕ → ℕ → Type u_3", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.SetMultilinear.Variables" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.direct.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2}\n (motive : PCP.Reduction.NAEThreeColor.Vertex V C → PCP.Reduction.NAEThreeColor.Vertex V C → Sort u_3) (val : V × Bool)\n (i : Fin 3) (h_1 : (i j : Fin 3) → motive (Sum.inl i) (Sum.inl j))\n (h_2 : (val : V × Bool) → (i : Fin 3) → motive (Sum.inr (Sum.inl val)) (Sum.inl i))\n (h_3 : (v : V) → (b : Bool) → (w : V) → (d : Bool) → motive (Sum.inr (Sum.inl (v, b))) (Sum.inr (Sum.inl (w, d))))\n (h_4 : (e : C) → (i : Fin 3) → (f : C) → (j : Fin 3) → motive (Sum.inr (Sum.inr (e, i))) (Sum.inr (Sum.inr (f, j))))\n (h_5 : (e : C) → (i : Fin 3) → (x : PCP.Reduction.NAEThreeColor.Vertex V C) → motive (Sum.inr (Sum.inr (e, i))) x)\n (h_6 : (x x_1 : PCP.Reduction.NAEThreeColor.Vertex V C) → motive x x_1),\n (match Sum.inr (Sum.inl val), Sum.inl i with\n | Sum.inl i, Sum.inl j => h_1 i j\n | Sum.inr (Sum.inl val), Sum.inl i => h_2 val i\n | Sum.inr (Sum.inl (v, b)), Sum.inr (Sum.inl (w, d)) => h_3 v b w d\n | Sum.inr (Sum.inr (e, i)), Sum.inr (Sum.inr (f, j)) => h_4 e i f j\n | Sum.inr (Sum.inr (e, i)), x => h_5 e i x\n | x, x_1 => h_6 x x_1) =\n h_2 val i", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Prod", + "Bool", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Sum.inr", + "Prod.mk", + "Eq", + "PCP.Reduction.NAEThreeColor.direct.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.literalVertex.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (a : Bool),\n PCP.Reduction.NAEThreeColor.literalVertex (PCP.Reduction.NAEThreeColor.Literal.const a) =\n PCP.Reduction.NAEThreeColor.base (PCP.Reduction.NAEThreeColor.boolColor a)", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.literalVertex", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.base", + "PCP.Reduction.NAEThreeColor.boolColor" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The quantitative statement with the actual rejection rate as its error parameter. ", + "end_line": 70, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.test_soundness_at_rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.testRejectionRate hr H < 1 / 28 →\n ∃ x,\n PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.Hadamard.encode r x) ≤\n PCP.Algebraic.Hadamard.testRejectionRate hr H ∧\n PCP.Algebraic.relativeDistance (fun p => H ((PCP.Algebraic.BinaryPolynomialSpace.embed hr) p))\n ⇑(PCP.Algebraic.Hadamard.encode 1 x) ≤\n 3 * PCP.Algebraic.Hadamard.testRejectionRate hr H", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "LT.lt", + "Rat", + "Rat.instLT", + "PCP.Algebraic.Hadamard.testRejectionRate", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Exists", + "Fin", + "And", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.embed", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.HadamardDerivedOracle.queries.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (P P_1 : Polynomial F) (e_P : P = P_1) (hP : P.natDegree ≤ r)\n (L L_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n L = L_1 →\n ∀ (R R_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n R = R_1 →\n PCP.Algebraic.HadamardDerivedOracle.queries ρ P hP L R =\n PCP.Algebraic.HadamardDerivedOracle.queries ρ_1 P_1 ⋯ L_1 R_1", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "List", + "PCP.Algebraic.HadamardDerivedOracle.queries", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n ¬PCP.Algebraic.ThreeColorParameterChoice.exponent N = 2 →\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬2 < PCP.Algebraic.ThreeColorParameterChoice.exponent N → False", + "type_dependencies": [ + "Nat", + "Not", + "Eq", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "After the explicit center shift, the fresh parameter has exactly the tester distribution. ", + "end_line": 95, + "is_class": false, + "kind": "theorem", + "line": 85, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.shifted_parameter_error_eq_rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (f : (σ → F) → F) (t : F),\n (PCP.Algebraic.relativeDistance (fun s => f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 t)) fun s =>\n Polynomial.eval s.2 ↑(PCP.Algebraic.PointLineTest.decodedTable c f (s.1.1 + (t - s.2) • s.1.2, s.1.2))) =\n PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable c f)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "Prod.snd", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Subtype.val", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.decodedTable", + "Prod.mk", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.PointLineTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One adjacency check has separate control checks and one bounded-width check per cell. ", + "end_line": 140, + "is_class": false, + "kind": "definition", + "line": 136, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.Step", + "provenance": "lean", + "structural_dependencies": [], + "type": "{tm : Turing.FinTM2} →\n {B : ℕ} →\n PCP.Machine.TableauCells.Prefix tm →\n PCP.Machine.TableauCells.Prefix tm →\n PCP.Machine.TableauCells.Cells tm B → PCP.Machine.TableauCells.Cells tm B → Prop", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "And", + "Eq", + "Option", + "Turing.FinTM2.Λ", + "Turing.TM2.Cfg.l", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.σ", + "PCP.Machine.ComputationTableau.decodeRow", + "PCP.Machine.TM2Locality.machineWindow", + "PCP.Machine.FiniteTransitionTable.outputBound", + "PCP.Machine.FiniteTransitionTable.localStep", + "Turing.TM2.Cfg.var", + "Fin", + "PCP.Machine.TableauCells.readCell", + "Fin.val", + "PCP.Machine.TableauCells.predictedCell", + "PCP.Machine.TableauCells.candidates" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 168, + "is_class": false, + "kind": "theorem", + "line": 165, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial_eq_monomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.digitMonomial m c k =\n (MvPolynomial.monomial (PCP.Algebraic.SetMultilinear.digitExponents m c k)) 1", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "MvPolynomial.monomial", + "PCP.Algebraic.SetMultilinear.digitExponents", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.corrected.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (ζ : F) (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H s =\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H s.1)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c s.2.1) s.2.2.1.1 s.2.2.1.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses._unsafe_rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.addresses.match_1", + "Finset", + "Bool", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "PCP.QueryTree.addresses._unsafe_rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 75, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.exists_primitive_cube_root", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), ∃ ω, IsPrimitiveRoot ω 3", + "type_dependencies": [ + "Nat", + "Exists", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "View the same difference oracle on flattened coordinates. ", + "end_line": 71, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n (Fin (n + n) → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.GridCoordinateTransport.rows", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual execution supplies every prefix and every individual cell. ", + "end_line": 268, + "is_class": false, + "kind": "definition", + "line": 264, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.canonicalAssignment", + "provenance": "lean", + "structural_dependencies": [], + "type": "(tm : Turing.FinTM2) →\n (T B : ℕ) →\n (initial : tm.Cfg) → PCP.Machine.StackSupported tm initial.stk → PCP.Machine.TableauCells.Assignment tm T B", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.TableauCells.Assignment" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "Prod.mk", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "PCP.Machine.FiniteTransitionTable.prefixRow", + "PCP.Machine.boundedEval", + "Fin.val", + "PCP.Machine.TableauCells.canonicalAssignment._proof_1", + "PCP.Machine.TableauCells.encodeCells" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every individual variable has degree at most one. ", + "end_line": 198, + "is_class": false, + "kind": "theorem", + "line": 192, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.degreeOf_encode_le_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R)\n (ij : PCP.Algebraic.SetMultilinear.Variables m c),\n MvPolynomial.degreeOf ij ((PCP.Algebraic.SetMultilinear.encode m c) P) ≤ 1", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.SetMultilinear.Variables", + "LE.le", + "instLENat", + "MvPolynomial.degreeOf", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries),\n sizeOf { randomness := randomness, queries := queries, run := run } = 1 + sizeOf queries", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "SizeOf.sizeOf", + "PCP.Verifier", + "PCP.Verifier._sizeOf_inst", + "PCP.Verifier.mk", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "instSizeOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 71, + "is_class": false, + "kind": "theorem", + "line": 66, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.PointLineEndpointConsistency.crossing_column_prediction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (f : (σ → F) → F)\n (u : σ → F) (seed : PCP.Algebraic.MixedPlaneSampling.MixedSeed F σ) (t : F),\n Polynomial.eval t\n ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun y =>\n PCP.Algebraic.PointLineEndpointConsistency.mixedGrid f u seed (y, seed.2.2)) =\n Polynomial.eval t ↑(PCP.Algebraic.PointLineTest.decodedTable d f (u, seed.1))", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.MixedPlaneSampling.MixedSeed", + "Eq", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Subtype.val", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.bestApproximation", + "PCP.Algebraic.PointLineEndpointConsistency.mixedGrid", + "Prod.mk", + "Prod.snd", + "Prod", + "PCP.Algebraic.PointLineTest.decodedTable", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.read f H (Sum.inl p) = f p.1 p.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Prod", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Lemma 3.10: low rejection yields a codeword close on both full and degree-one queries. ", + "end_line": 61, + "is_class": false, + "kind": "theorem", + "line": 28, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.test_soundness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) {δ : ℚ},\n δ < 1 / 28 →\n PCP.Algebraic.Hadamard.testRejectionRate hr H ≤ δ →\n ∃ x,\n PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.Hadamard.encode r x) ≤ δ ∧\n PCP.Algebraic.relativeDistance (fun p => H ((PCP.Algebraic.BinaryPolynomialSpace.embed hr) p))\n ⇑(PCP.Algebraic.Hadamard.encode 1 x) ≤\n 3 * δ", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Rat", + "LT.lt", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instLE", + "PCP.Algebraic.Hadamard.testRejectionRate", + "Exists", + "Fin", + "And", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.embed", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.index_add_one._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), ¬max 1 (Nat.clog 16 M) - 1 + 1 = max 1 (Nat.clog 16 M) → False", + "type_dependencies": [ + "Nat", + "Not", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.Accepts.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (x : List Bool)\n (a : PCP.Machine.NPTableau.Assignment h q x),\n PCP.Machine.NPTableau.Accepts h q x a =\n PCP.Machine.ComputationTableau.Satisfies h.tm (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q))\n (PCP.Machine.NPTableau.input h x (PCP.Machine.NPTableau.witnessList a.1)) (PCP.Machine.NPTableau.output h true)\n a.2", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "PCP.Machine.NPTableau.Assignment", + "Eq", + "PCP.Machine.NPTableau.Accepts", + "PCP.Machine.ComputationTableau.Satisfies", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "PCP.Machine.NPTableau.input", + "PCP.Machine.NPTableau.witnessList", + "PCP.Machine.NPTableau.BoundedWitness", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.ComputationTableau.Row", + "PCP.Machine.NPTableau.output", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 111, + "is_class": false, + "kind": "theorem", + "line": 111, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier_queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.queries = 187", + "type_dependencies": [ + "Eq", + "Nat", + "PCP.Verifier.queries", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a : ι → ZMod 2), PCP.Algebraic.BLR.linearForm a = ∑ i, a i • LinearMap.proj i", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BLR.linearForm", + "Finset.sum", + "LinearMap.addCommMonoid", + "Finset.univ", + "HSMul.hSMul", + "Pi.module", + "instHSMul", + "LinearMap.instSMul", + "NonUnitalNonAssocSemiring.toDistribSMul", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "ZMod.commRing", + "PCP.Algebraic.BLR.linearForm._proof_1", + "LinearMap.proj" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 143, + "is_class": false, + "kind": "theorem", + "line": 141, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x w : Fin t → ZMod 2), (PCP.Algebraic.Hadamard.linearEncode x) w = ∑ i, x i * w i", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Finset.sum", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A polynomial vanishing on a nonempty grid has a complete honest proof. ", + "end_line": 201, + "is_class": false, + "kind": "theorem", + "line": 190, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.exists_rejectionRate_eval_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : NeZero m] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F),\n P.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∃ M,\n M.totalDegree ≤ P.totalDegree ∧\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P))))\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M))))\n (PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M) =\n 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "Exists", + "Sum", + "And", + "LE.le", + "instLENat", + "Eq", + "Rat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A single oracle verifier for every encoded graph. ", + "end_line": 109, + "is_class": false, + "kind": "definition", + "line": 105, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier", + "type_dependencies": [ + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.Verifier.mk", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.tree" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "definition", + "line": 128, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 61, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "_private.PCP.Algebraic.WeightedConstraintSoundness.0.PCP.Algebraic.WeightedConstraint.shifted_error", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] [inst_4 : DecidableEq F] [inst_5 : Fintype V] (a w : I → F) (f : V → F) (x v : V) (b : F),\n b ≠ 0 →\n (PCP.Algebraic.relativeDistance (fun s => f (x + b • s.1)) fun s =>\n PCP.Algebraic.WeightedConstraint.predict a w f (x + b • s.1) (v + b • s.2)) =\n PCP.Algebraic.WeightedConstraint.rejectionRate a w f", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "HAdd.hAdd", + "instHAdd", + "AddCommMagma.toAdd", + "AddCommSemigroup.toAddCommMagma", + "AddCommMonoid.toAddCommSemigroup", + "HSMul.hSMul", + "instHSMul", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction", + "Prod.fst", + "PCP.Algebraic.WeightedConstraint.predict", + "Prod.snd", + "PCP.Algebraic.WeightedConstraint.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.acceptance_pow_le_half", + "provenance": "lean", + "structural_dependencies": [], + "type": "(1 - PCP.Algebraic.ThreeColorBinaryVerifier.gap) ^ PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions ≤ 1 / 2", + "type_dependencies": [ + "LE.le", + "Rat", + "Rat.instLE", + "HPow.hPow", + "Nat", + "instHPow", + "Rat.instPowNat", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 126, + "is_class": false, + "kind": "constructor", + "line": 126, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 56, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n (PCP.Algebraic.SetMultilinear.encode m c) 1 = PCP.Algebraic.SetMultilinear.digitMonomial m c 0", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.Satisfies.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} [inst : Field F] (G : SimpleGraph V) (f : V → F),\n PCP.Algebraic.ThreeColorAlgebra.Satisfies G f =\n ((∀ (v : V), f v ^ 3 - 1 = 0) ∧ ∀ (v w : V), G.Adj v w → (f v - f w) ^ 3 - 1 = 0)", + "type_dependencies": [ + "Field", + "SimpleGraph", + "Eq", + "PCP.Algebraic.ThreeColorAlgebra.Satisfies", + "And", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "SimpleGraph.Adj" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Nonzero-parameter disagreement has the usual polynomial-distance lower bound. ", + "end_line": 61, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.distance_on_units_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {D : ℕ} (p q : Polynomial F),\n p.natDegree ≤ D →\n q.natDegree ≤ D →\n p ≠ q →\n 1 - ↑D / ↑(Fintype.card Fˣ) ≤\n PCP.Algebraic.relativeDistance (fun l => Polynomial.eval (↑l) p) fun l => Polynomial.eval (↑l) q", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Ne", + "Rat", + "Rat.instLE", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "OfNat.ofNat", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Units", + "Semiring.toMonoid", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.relativeDistance", + "Polynomial.eval", + "Units.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.correct.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.StandardLocalCorrection.correct c ζ f u v =\n ∑ i,\n PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i *\n f (PCP.Algebraic.PolynomialLine.point u v (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i))", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.StandardLocalCorrection.correct", + "Finset.sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Semiring.toAddCommMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.triangleWitness.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Bool → Bool → Bool → Sort u_1) (h_1 : Unit → motive false false true) (h_2 : Unit → motive true true false)\n (h_3 : (x : Bool) → motive false true x) (h_4 : (x x_1 x_2 : Bool) → motive x x_1 x_2),\n (match true, true, false with\n | false, false, true => h_1 ()\n | true, true, false => h_2 ()\n | false, true, x => h_3 x\n | x, x_1, x_2 => h_4 x x_1 x_2) =\n h_2 ()", + "type_dependencies": [ + "Bool", + "Unit", + "Bool.false", + "Bool.true", + "Eq", + "PCP.Reduction.NAEThreeColor.triangleWitness.match_1", + "Unit.unit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.accepted_wrong_honest_le._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {R : Type u_4} [inst : AddCommMonoidWithOne R] (p : ι → Prop) [inst_1 : DecidablePred p]\n (s : Finset ι), (∑ a ∈ s, if p a then 1 else 0) = ↑{x ∈ s | p x}.card", + "type_dependencies": [ + "AddCommMonoidWithOne", + "DecidablePred", + "Finset", + "Eq", + "Finset.sum", + "AddCommMonoidWithOne.toAddCommMonoid", + "ite", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "Zero.toOfNat0", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddMonoidWithOne.toAddMonoid", + "Nat.cast", + "AddMonoidWithOne.toNatCast", + "Finset.card", + "Finset.filter" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The semantic interpretation used only in the correctness proof. ", + "end_line": 70, + "is_class": false, + "kind": "definition", + "line": 66, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.Represents", + "provenance": "lean", + "structural_dependencies": [], + "type": "{tm : Turing.FinTM2} →\n {B : ℕ} → PCP.Machine.TableauCells.Prefix tm → PCP.Machine.TableauCells.Cells tm B → tm.Cfg → Prop", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg", + "And", + "Eq", + "Option", + "Turing.FinTM2.Λ", + "Turing.TM2.Cfg.l", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.σ", + "PCP.Machine.ComputationTableau.decodeRow", + "PCP.Machine.TM2Locality.machineWindow", + "Turing.TM2.Cfg.var", + "PCP.Machine.TableauCells.readCell", + "GetElem?.getElem?", + "List", + "LT.lt", + "instLTNat", + "List.length", + "List.instGetElem?NatLtLength", + "Turing.TM2.Cfg.stk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Evaluation determines a formal polynomial when its total degree is below the field size. ", + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 72, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.eval_injective_of_totalDegree_lt_card", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] {m : ℕ},\n Set.InjOn (fun p x => (MvPolynomial.eval x) p) {p | p.totalDegree < Fintype.card 𝔽}", + "type_dependencies": [ + "Field", + "Fintype", + "Nat", + "Set.InjOn", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Set.ofPred", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest_honestProof._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} {m c : ℕ} (P : MvPolynomial (Fin n) F) (MVal : MvPolynomial (Fin n ⊕ Fin n) F)\n (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F), ¬1 ≤ 3 → False", + "type_dependencies": [ + "Field", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → (σ → F) → (σ → F) → List (σ → F)", + "type_dependencies": [ + "Field", + "Nat", + "List" + ], + "value_dependencies": [ + "Field", + "Nat", + "List.ofFn", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 190, + "is_class": false, + "kind": "theorem", + "line": 176, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_character_mul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (x y : ι → ZMod 2),\n (PCP.Algebraic.BLR.average fun a => PCP.Algebraic.BLR.character a x * PCP.Algebraic.BLR.character a y) =\n if x = y then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character", + "ite", + "Fintype.decidablePiFintype", + "ZMod.decidableEq", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2),\n PCP.Algebraic.BLR.character a x = PCP.Algebraic.BLR.sign ((PCP.Algebraic.BLR.linearForm a) x)", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.character", + "PCP.Algebraic.BLR.sign", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 182, + "is_class": false, + "kind": "theorem", + "line": 176, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial_isSetMultilinear", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.IsSetMultilinear m c (PCP.Algebraic.SetMultilinear.digitMonomial m c k)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.SetMultilinear.IsSetMultilinear", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.expect_shared_fst", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (f : W × S → ℚ),\n (Finset.univ.expect fun s => f (s.1, s.2.1)) = Finset.univ.expect fun s => f s", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Place the input graph in the selected grid, adding isolated vertices. ", + "end_line": 135, + "is_class": false, + "kind": "definition", + "line": 130, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n [inst : Fintype V] →\n SimpleGraph V →\n optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V) →\n SimpleGraph\n (Fin\n (PCP.Algebraic.ThreeColorParameters.size\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))) →\n ↥(PCP.Algebraic.ThreeColorParameters.grid\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))))", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "optParam", + "Equiv", + "Fin", + "Fintype.card", + "Fintype.equivFin", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid" + ], + "value_dependencies": [ + "Fintype", + "SimpleGraph", + "Equiv", + "Fin", + "Fintype.card", + "PCP.Algebraic.ThreeColorGridIndex.pad", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameters.gridCode", + "SimpleGraph.comap", + "DFunLike.coe", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "PCP.Verifier.rec", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "SizeOf.sizeOf", + "instSizeOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Canonical reduced query coordinates make the translation unique. ", + "end_line": 193, + "is_class": false, + "kind": "theorem", + "line": 184, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.query_unique", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (hP : P.natDegree ≤ r)\n (Λ : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n (∀ (u : F),\n (PCP.Algebraic.BinaryPolynomialSpace.evaluate (ρ u)) Λ =\n (PCP.Algebraic.BinaryPolynomialSpace.evaluate (ρ (Polynomial.eval u P))) L) →\n Λ = PCP.Algebraic.HadamardComposition.query ρ P L hP", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.evaluate", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "PCP.Algebraic.HadamardComposition.query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.candidates.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} (s : PCP.Machine.TableauCells.Cells tm B) (k : tm.K) (j : ℕ)\n (n : Fin (PCP.Machine.FiniteTransitionTable.outputBound tm + 1)),\n PCP.Machine.TableauCells.candidates s k j n =\n PCP.Machine.TableauCells.readCell s k (PCP.Machine.TM2Locality.machineWindow tm + (j - ↑n))", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.FiniteTransitionTable.outputBound", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Option", + "Turing.FinTM2.Γ", + "PCP.Machine.TableauCells.candidates", + "PCP.Machine.TableauCells.readCell", + "PCP.Machine.TM2Locality.machineWindow", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An averaged rejection guarantee follows from genuine per-target corrector bounds. ", + "end_line": 194, + "is_class": false, + "kind": "theorem", + "line": 97, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.two_corrector_rejection_bound", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} {S : Type u_3} [inst : Fintype X] [Nonempty X] [inst_2 : Fintype W] [inst_3 : Fintype S]\n [Nonempty S] (p P A B : X → W → ZMod 2) (a b : X → W → S → Option (ZMod 2)) {K ν ε : ℚ},\n 0 ≤ K →\n (∀ (x : X),\n (PCP.Algebraic.relativeDistance (fun ws => a x ws.1 ws.2) fun ws => some (A x ws.1)) ≤\n (K * PCP.Algebraic.AffineLineSampling.fraction fun ws => a x ws.1 ws.2 = none) + ν) →\n (∀ (x : X),\n (PCP.Algebraic.relativeDistance (fun ws => b x ws.1 ws.2) fun ws => some (B x ws.1)) ≤\n (K * PCP.Algebraic.AffineLineSampling.fraction fun ws => b x ws.1 ws.2 = none) + ν) →\n (PCP.Algebraic.relativeDistance (fun xw => p xw.1 xw.2) fun xw => P xw.1 xw.2) ≤ ε →\n (PCP.Algebraic.relativeDistance\n (fun xw => PCP.Algebraic.BinaryZeroOnGrid.checkBits (P xw.1 xw.2) (A xw.1 xw.2) (B xw.1 xw.2)) fun x =>\n (0, 0)) ≤\n ((1 + 2 * K) *\n PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck p a b) fun x =>\n some (0, 0)) +\n ε +\n 2 * ν", + "type_dependencies": [ + "Fintype", + "Nonempty", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Rat", + "LE.le", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Option.instDecidableEq", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "Option.some", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.AffineLineSampling.fraction", + "Eq", + "Option.none", + "instDecidableEqProd", + "PCP.Algebraic.BinaryZeroOnGrid.checkBits", + "Prod.mk", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "The least admissible exponent; the witness is proved for every input size. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Nat.find", + "And", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "instDecidableAnd", + "Nat.decLe", + "_private.PCP.Algebraic.ThreeColorParameterChoice.0.PCP.Algebraic.ThreeColorParameterChoice.exists_exponent" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), ¬M ≤ 1 → ¬1 ≤ M → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The finite transition table chooses one of the machine-fixed suffix candidates. ", + "end_line": 126, + "is_class": false, + "kind": "definition", + "line": 122, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.predictedCell", + "provenance": "lean", + "structural_dependencies": [], + "type": "{tm : Turing.FinTM2} →\n PCP.Machine.TableauCells.Prefix tm →\n (k : tm.K) → ℕ → (Fin (PCP.Machine.FiniteTransitionTable.outputBound tm + 1) → Option (tm.Γ k)) → Option (tm.Γ k)", + "type_dependencies": [ + "Turing.FinTM2", + "PCP.Machine.TableauCells.Prefix", + "Turing.FinTM2.K", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.FiniteTransitionTable.outputBound", + "OfNat.ofNat", + "instOfNatNat", + "Option", + "Turing.FinTM2.Γ" + ], + "value_dependencies": [ + "Turing.FinTM2", + "PCP.Machine.TableauCells.Prefix", + "Turing.FinTM2.K", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.FiniteTransitionTable.outputBound", + "OfNat.ofNat", + "instOfNatNat", + "Option", + "Turing.FinTM2.Γ", + "PCP.Machine.ComputationTableau.Row", + "PCP.Machine.FiniteTransitionTable.localStep", + "ite", + "LT.lt", + "instLTNat", + "Fin.val", + "Sigma.fst", + "PCP.Machine.ComputationTableau.Symbol", + "Prod.snd", + "Turing.FinTM2.σ", + "PCP.Machine.ComputationTableau.Stack", + "Turing.FinTM2.Λ", + "Prod", + "Nat.decLt", + "GetElem?.getElem?", + "List", + "List.length", + "List.instGetElem?NatLtLength", + "Turing.TM2.Cfg.stk", + "PCP.Machine.ComputationTableau.decodeRow" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_character_mul._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x y : ι → ZMod 2),\n PCP.Algebraic.BLR.character a x * PCP.Algebraic.BLR.character a y = PCP.Algebraic.BLR.character a (x + y)", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → PCP.Machine.Sym → PCP.Machine.Sym → Sort u", + "type_dependencies": [ + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.Sym.casesOn", + "Bool", + "Eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.colorValue_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {ω : F},\n IsPrimitiveRoot ω 3 → Function.Injective (PCP.Algebraic.ThreeColorAlgebra.colorValue ω)", + "type_dependencies": [ + "Field", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Function.Injective", + "Fin", + "PCP.Algebraic.ThreeColorAlgebra.colorValue" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym → ℕ", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.Sym.rec", + "Nat", + "Bool", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "Bool._sizeOf_inst" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.fraction_good_ge._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (E : α → Prop) [inst_1 : DecidablePred E],\n (Finset.univ.expect fun x => if E x then 1 else 0) = PCP.Algebraic.AffineLineSampling.fraction E", + "type_dependencies": [ + "Fintype", + "DecidablePred", + "Eq", + "Rat", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "ite", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.AffineLineSampling.fraction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 80, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_equiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (e : α ≃ β) (f : β → ℚ),\n (PCP.Algebraic.BLR.average fun x => f (e x)) = PCP.Algebraic.BLR.average f", + "type_dependencies": [ + "Fintype", + "Equiv", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "DFunLike.coe", + "EquivLike.toFunLike", + "Equiv.instEquivLike" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)),\n 5 * ((H.card - 1) * n) < m ^ c →\n ∀ (P : MvPolynomial (Fin n) F),\n P.totalDegree ≤ (H.card - 1) * n →\n ∀ (MVal : MvPolynomial (Fin n ⊕ Fin n) F) (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n ¬P.totalDegree < m ^ c → False", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.boolColor.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), PCP.Reduction.NAEThreeColor.boolColor b = if b = true then 1 else 0", + "type_dependencies": [ + "Bool", + "Eq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.boolColor", + "ite", + "Bool.true", + "instDecidableEqBool", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.canonicalAssignment._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (tm : Turing.FinTM2) (T : ℕ) (initial : tm.Cfg),\n PCP.Machine.StackSupported tm initial.stk →\n ∀ (i : Fin (T + 1)), PCP.Machine.StackSupported tm (PCP.Machine.boundedEval tm (↑i) initial).stk", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.boundedEval", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 135, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every satisfying assignment supplies an explicit proper three-coloring. ", + "end_line": 167, + "is_class": false, + "kind": "definition", + "line": 160, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.coloring", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) →\n (a : V → Bool) →\n (∀ (e : C), PCP.Reduction.NAEThreeColor.NAE fun i => PCP.Reduction.NAEThreeColor.Literal.eval a (Q e i)) →\n (PCP.Reduction.NAEThreeColor.graph Q).Coloring (Fin 3)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.NAE", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.NAE", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "SimpleGraph.Coloring.mk", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "PCP.Reduction.NAEThreeColor.color", + "PCP.Reduction.NAEThreeColor.coloring._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 36, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.correction", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {V : Type u_2} →\n {I : Type u_3} →\n [inst : Field F] →\n [inst_1 : AddCommGroup V] →\n [_root_.Module F V] →\n [Fintype I] → [Fintype F] → [DecidableEq F] → [Fintype V] → (I → F) → (I → F) → (V → F) → V → F", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq" + ], + "value_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "PCP.Algebraic.Plurality.value", + "Finite.of_fintype", + "PCP.Algebraic.WeightedConstraint.correction._proof_1", + "PCP.Algebraic.WeightedConstraint.predict" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.pairDisagreement.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {A : Type u_2} [inst : Fintype V] [inst_1 : DecidableEq A] (f : V → A),\n PCP.Algebraic.PointLineTest.pairDisagreement f = PCP.Algebraic.relativeDistance (fun p => f p.1) fun p => f p.2", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.PointLineTest.pairDisagreement", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c t r : ℕ} (Q : (Fin n → F) → Polynomial F),\n (∀ (x : Fin n → F), (Q x).natDegree ≤ r) →\n ∀ (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r), (Q s.1).natDegree ≤ r", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Prod.fst", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.inputPoly.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (q : Polynomial ℕ), PCP.Machine.NPTableau.inputPoly q = Polynomial.X + q + 1", + "type_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "PCP.Machine.NPTableau.inputPoly", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "Polynomial.X", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A clean seed rectangle and close columns give an actual nearby bivariate polynomial. ", + "end_line": 198, + "is_class": false, + "kind": "theorem", + "line": 173, + "module": "PCP.Algebraic.BivariateAgreementFromRectangle", + "name": "PCP.Algebraic.BivariateAgreementFromRectangle.exists_nearby_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype I]\n {d : ℕ} (a : I → F),\n Function.Injective a →\n ∀ (C : I → Polynomial F),\n (∀ (i : I), (C i).natDegree ≤ d) →\n ∀ (R : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n ∀ (b : Fin (d + 1) → I),\n Function.Injective b →\n ∀ (B : Finset F),\n (∀ y ∈ B, ∀ (j : Fin (d + 1)), Polynomial.eval (a (b j)) (R y) = Polynomial.eval y (C (b j))) →\n ∀ {ε : ℚ},\n (∀ (i : I),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x =>\n Polynomial.eval x (C i)) ≤\n ε) →\n ε * ↑(Fintype.card F) + ↑d < ↑B.card →\n ∃ P,\n (∀ (j : Fin 2), MvPolynomial.degreeOf j P ≤ d) ∧\n (∀ (i : I), PCP.Algebraic.PointLineCrossing.rowPolynomial P (a i) = C i) ∧\n PCP.Algebraic.relativeDistance R (PCP.Algebraic.PointLineCrossing.columnPolynomial P) ≤\n ↑(Fintype.card I) * ε / (↑(Fintype.card I) - ↑d) ∧\n (PCP.Algebraic.relativeDistance (fun z => Polynomial.eval z.1 (R z.2)) fun z =>\n (MvPolynomial.eval ![z.1, z.2]) P) ≤\n ↑(Fintype.card I) * ε / (↑(Fintype.card I) - ↑d)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Finset", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "Polynomial.eval", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "LT.lt", + "Rat.instLT", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Finset.card", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.degreeOf", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "Polynomial.instDecidableEq", + "PCP.Algebraic.PointLineCrossing.columnPolynomial", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_variable_pair._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u} (r : V → V → Prop) (v w : V), (SimpleGraph.fromRel r).Adj v w = (v ≠ w ∧ (r v w ∨ r w v))", + "type_dependencies": [ + "Eq", + "SimpleGraph.Adj", + "SimpleGraph.fromRel", + "And", + "Ne", + "Or" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (ζ : F) (f : (σ → F) → F),\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f =\n PCP.Algebraic.WeightedConstraint.rejectionRate (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "Pi.instFintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The field-coordinate version, using only injectivity of the paper's coordinate map. ", + "end_line": 123, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encodeFunction_map", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} {ι : Type u_1} {α : Type u_2} [inst : Fintype ι] [inst_1 : DecidableEq α] (ρ : α → Fin t → ZMod 2),\n Function.Injective ρ →\n 1 ≤ r →\n ∀ (f g : ι → α),\n PCP.Algebraic.relativeDistance (PCP.Algebraic.Hadamard.encodeFunction r fun i => ρ (f i))\n (PCP.Algebraic.Hadamard.encodeFunction r fun i => ρ (g i)) =\n 1 / 2 * PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "LE.le", + "instLENat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.Hadamard.encodeFunction", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (witnessBound : Polynomial ℕ)\n (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true)\n (witnessBound_1 : Polynomial ℕ) (check_1 : List Bool → List Bool → Bool) (check_polyTime_1 : P check_1)\n (spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true),\n ({ witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 }) =\n (witnessBound = witnessBound_1 ∧ check = check_1)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Polynomially bounded reduction, with a canonical source randomness budget. ", + "end_line": 70, + "is_class": false, + "kind": "definition", + "line": 66, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.canonicalVerifier", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : PCP.Verifier) →\n {a b : ℕ} →\n V.CanonicalRandomness a b →\n (f : List Bool → List Bool) →\n (p : Polynomial ℕ) → (∀ (x : List Bool), (f x).length ≤ Polynomial.eval x.length p) → PCP.Verifier", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "Polynomial", + "Nat.instSemiring", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "Polynomial", + "Nat.instSemiring", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "PCP.Verifier.Reduction.verifier", + "PCP.Verifier.Reduction.budget", + "PCP.Verifier.Reduction.randomness_le_budget" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d) (addr_1 : ℕ) (onFalse_1 onTrue_1 : PCP.QueryTree d),\n (PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1) =\n (addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n {F' : Type u_2} → {n' m' c' t' : ℕ} → PCP.Algebraic.ThreeColorVerifier.Proof F' n' m' c' t' → Sort u", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → (c : ℕ) → F → Fin (c + 1) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 241, + "is_class": false, + "kind": "theorem", + "line": 235, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_validGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.validGridQuery q) =\n PCP.Algebraic.DerivedZeroOnGrid.read π.color π.validCert (PCP.Algebraic.ThreeColorVerifier.validAuxiliary π) q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery", + "PCP.Algebraic.DerivedZeroOnGrid.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 180, + "is_class": false, + "kind": "theorem", + "line": 161, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.distance_line_bits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [Field F] {m c t r : ℕ} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ]\n {A : Type u_3} [inst_3 : DecidableEq A]\n (k l : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ × F → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k (s.1, s.2.1) s.2.2.1.2) fun s => l (s.1, s.2.1) s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The combined verdict is exactly conjunction of the seven concrete verdicts. ", + "end_line": 316, + "is_class": false, + "kind": "theorem", + "line": 311, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.test_eq_true", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s = true ↔\n ∀ (i : Fin 7), PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G π i (s i) = true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Iff", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "Bool.true", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.inversion._simp_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),\n ∑ i ∈ s, a * f i = a * ∑ i ∈ s, f i", + "type_dependencies": [ + "NonUnitalNonAssocSemiring", + "Finset", + "Eq", + "Finset.sum", + "NonUnitalNonAssocSemiring.toAddCommMonoid", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "NonUnitalNonAssocSemiring.toDistrib" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses._sunfold", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.addresses.match_1", + "Finset", + "Bool", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "PCP.QueryTree.addresses" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Expanding separated row words multiplies their relative distance by at least\ntheir separation. The separation hypothesis is local to the two rows compared. ", + "end_line": 60, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.row_mismatch_mul_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {I : Type u_1} {J : Type u_2} {A : Type u_3} [inst : Fintype I] [inst_1 : Fintype J] [inst_2 : DecidableEq A]\n (R S : I → J → A) (δ : ℚ),\n (∀ (i : I), R i ≠ S i → δ ≤ PCP.Algebraic.relativeDistance (R i) (S i)) →\n δ * PCP.Algebraic.relativeDistance R S ≤ PCP.Algebraic.relativeDistance (fun p => R p.1 p.2) fun p => S p.1 p.2", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Rat", + "Ne", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Fintype.decidablePiFintype", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Decoded vertices already carry their actual numeric addresses; only the bound is cast. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : List Bool) →\n Fin (PCP.Algebraic.ThreeColorEncoding.vertexCount x) ≃ Fin (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x)", + "type_dependencies": [ + "List", + "Bool", + "Equiv", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder" + ], + "value_dependencies": [ + "List", + "Bool", + "finCongr", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 80, + "is_class": false, + "kind": "theorem", + "line": 76, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.totalDegree_edgeExtension_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)),\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree ≤ 2 * ((H.card - 1) * Fintype.card σ)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A nonnegative function of mean at most half the threshold has enough good\ncoordinates to embed any finite set whose doubled size fits in the domain. ", + "end_line": 60, + "is_class": false, + "kind": "theorem", + "line": 28, + "module": "PCP.Algebraic.BivariateColumnSelection", + "name": "PCP.Algebraic.BivariateColumnSelection.exists_embedding_of_expect_le_half", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] [Nonempty α] (X : α → ℚ),\n (∀ (x : α), 0 ≤ X x) →\n ∀ {a : ℚ},\n 0 < a →\n (Finset.univ.expect fun x => X x) ≤ a / 2 → ∀ (n : ℕ), 2 * n ≤ Fintype.card α → ∃ b, ∀ (i : Fin n), X (b i) ≤ a", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Rat", + "LE.le", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "LT.lt", + "Rat.instLT", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "instOfNatNat", + "Fintype.card", + "Exists", + "Function.Embedding", + "Fin", + "DFunLike.coe", + "Function.instFunLikeEmbedding" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The auxiliary encodings of all genuine line restrictions. ", + "end_line": 111, + "is_class": false, + "kind": "definition", + "line": 108, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n [NeZero m] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n MvPolynomial σ F → PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.honestTable", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeTriple.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (t : List Bool × List Bool × List Bool),\n PCP.Machine.encodeTriple t =\n PCP.Machine.ofBits t.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.1 ++\n PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.2", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.encodeTriple", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 175, + "is_class": false, + "kind": "definition", + "line": 175, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeGridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t : ℕ} → [Fintype F] → [DecidableEq F] → Fintype (PCP.Algebraic.DerivedZeroOnGrid.GridRandomness F n m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed._proof_1", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeCallSeedSumFin" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "definition", + "line": 42, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m]\n (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (M M_1 : MvPolynomial (Fin n ⊕ Fin n) F),\n M = M_1 →\n ∀ (a a_1 : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n),\n a = a_1 →\n ∀ (a_2 a_3 : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n),\n a_2 = a_3 →\n ∀ (a_4 a_5 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c),\n a_4 = a_5 →\n ∀ (a_6 a_7 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n a_6 = a_7 →\n PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M a a_2 a_4 a_6 =\n PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ_1 M_1 a_1 a_3 a_5 a_7", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "MvPolynomial", + "Sum", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Ceiling-logarithm selection increases cardinality by at most a factor sixteen. ", + "end_line": 153, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) ≤ 16 * max 1 M", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Number of vertices of the actual decoded input graph. ", + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool → ℕ", + "type_dependencies": [ + "List", + "Bool", + "Nat" + ], + "value_dependencies": [ + "List", + "Bool", + "Fintype.card", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 135, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 7 →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [], + "doc": "An equivalence between the \"proxy type\" `PCP.Reduction.NAEThreeColor.Literal.proxyType` and `PCP.Reduction.NAEThreeColor.Literal`. The proxy type is a reducible definition that represents the inductive type using `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum` (and whatever other inductive types appear within the inductive type), and the intended use is to define typeclass instances uses pre-existing instances on these. (Generated by the `proxy_equiv%` elaborator.)", + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.proxyTypeEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : Type u_1) → Bool ⊕ (_ : V) × Bool ≃ PCP.Reduction.NAEThreeColor.Literal V", + "type_dependencies": [ + "Equiv", + "Sum", + "Bool", + "Sigma", + "PCP.Reduction.NAEThreeColor.Literal" + ], + "value_dependencies": [ + "Equiv.mk", + "Sum", + "Bool", + "Sigma", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_3", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5", + "Sum.inl", + "Sum.inr", + "Sigma.mk", + "Sum.casesOn", + "Eq", + "Eq.ndrec", + "Eq.refl", + "Eq.symm", + "PCP.Reduction.NAEThreeColor.Literal.casesOn" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "PCP.QueryTree.eval.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "definition", + "line": 51, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "_private.PCP.Algebraic.WeightedConstraintSoundness.0.PCP.Algebraic.WeightedConstraint.pairEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {V : Type u_2} →\n [inst : Field F] → [inst_1 : AddCommGroup V] → [_root_.Module F V] → V → V → (a : F) → a ≠ 0 → V × V ≃ V × V", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Equiv", + "Prod" + ], + "value_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Equiv.prodCongr", + "PCP.Algebraic.affineSamplingEquiv", + "Field.toDivisionRing" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardComposition.query.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (P P_1 : Polynomial F) (e_P : P = P_1) (L L_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n L = L_1 →\n ∀ (_hP : P.natDegree ≤ r) (a a_1 : PCP.Algebraic.BinaryPolynomialSpace.Monomials t r),\n a = a_1 →\n PCP.Algebraic.HadamardComposition.query ρ P L _hP a =\n PCP.Algebraic.HadamardComposition.query ρ_1 P_1 L_1 ⋯ a_1", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "PCP.Algebraic.HadamardComposition.query", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.expect_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : Fintype B] (k : A × B → ℚ),\n (Finset.univ.expect fun p => k p) = Finset.univ.expect fun a => Finset.univ.expect fun b => k (a, b)", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete honest proof, including the four auxiliary tables shared between tests. ", + "end_line": 36, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.honestProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [NeZero m] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n MvPolynomial (Fin n) F →\n MvPolynomial (Fin n ⊕ Fin n) F →\n MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.honestProof._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Restoring the requested label gives exactly the corrector's actual full sample. ", + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n {σ : Type u_2} →\n (Fin t → ZMod 2) × PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t ≃\n PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t", + "type_dependencies": [ + "Field", + "Nat", + "Equiv", + "Prod", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BinaryLocalCorrection.Sample" + ], + "value_dependencies": [ + "Field", + "Nat", + "Equiv.mk", + "Prod", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Prod.mk", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Correction queries are routed to the same physical certificate and line tables. ", + "end_line": 172, + "is_class": false, + "kind": "definition", + "line": 168, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} → PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "Prod.mk", + "PCP.Algebraic.ThreeColorVerifier.PairPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k k_1 : ℕ),\n k = k_1 → PCP.Algebraic.SetMultilinear.digitMonomial m c k = PCP.Algebraic.SetMultilinear.digitMonomial m c k_1", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 174, + "is_class": false, + "kind": "definition", + "line": 174, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeCallSeedSumFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] → Fintype (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instDecidableEqSum", + "instDecidableEqFin", + "instFintypeSum", + "Fin.fintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerPoint", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 320, + "is_class": false, + "kind": "theorem", + "line": 311, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate_nodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (ζ : F) (f : (σ → F) → F),\n PCP.Algebraic.FixedLagrangeConstraint.rejectionRate (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) f =\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBits_le_budget._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n PCP.Algebraic.ThreeColorBinaryVerifier.randomBits (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x) ≤\n 32000000 * (Nat.clog 2 (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x) + 1) →\n Nat.clog 2 (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x) ≤ Nat.clog 2 (x.length + 2) →\n ¬PCP.Algebraic.ThreeColorBinaryVerifier.randomBits (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x) ≤\n 32000000 * Nat.clog 2 (x.length + 2) + 32000000 →\n False", + "type_dependencies": [ + "List", + "Bool", + "LE.le", + "Nat", + "instLENat", + "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Nat.clog", + "List.length", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 116, + "is_class": false, + "kind": "definition", + "line": 115, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableRelVertexAdjGraphOfDecidableEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n [DecidableEq V] →\n [DecidableEq C] →\n (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) → DecidableRel (PCP.Reduction.NAEThreeColor.graph Q).Adj", + "type_dependencies": [ + "DecidableEq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "DecidableRel", + "PCP.Reduction.NAEThreeColor.Vertex", + "SimpleGraph.Adj", + "PCP.Reduction.NAEThreeColor.graph" + ], + "value_dependencies": [ + "DecidableEq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.instDecidableRelVertexAdjGraphOfDecidableEq._aux_1" + ] + }, + { + "axioms": [], + "doc": "A \"proxy type\" equivalent to `PCP.Reduction.NAEThreeColor.Literal` that is constructed from `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum`. See `PCP.Reduction.NAEThreeColor.Literal.proxyTypeEquiv` for the equivalence. (Generated by the `proxy_equiv%` elaborator.)", + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.proxyType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_1 → Type u_1", + "type_dependencies": [], + "value_dependencies": [ + "Sum", + "Bool", + "Sigma" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 74, + "is_class": false, + "kind": "definition", + "line": 74, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.const.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {P : Sort u} →\n {a a' : Bool} →\n PCP.Reduction.NAEThreeColor.Literal.const a = PCP.Reduction.NAEThreeColor.Literal.const a' → (a = a' → P) → P", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.const" + ], + "value_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.const", + "id", + "PCP.Reduction.NAEThreeColor.Literal.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 64, + "is_class": false, + "kind": "theorem", + "line": 59, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.PointLineEndpointConsistency.crossing_row_prediction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (f : (σ → F) → F)\n (u : σ → F) (seed : PCP.Algebraic.MixedPlaneSampling.MixedSeed F σ) (t : F),\n Polynomial.eval seed.2.2\n ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun z =>\n PCP.Algebraic.PointLineEndpointConsistency.mixedGrid f u seed (t, z)) =\n PCP.Algebraic.PointLineTest.prediction (PCP.Algebraic.PointLineTest.decodedTable d f)\n (PCP.Algebraic.PolynomialLine.point u seed.1 t) seed.2", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.MixedPlaneSampling.MixedSeed", + "Eq", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.snd", + "Prod", + "Subtype.val", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.bestApproximation", + "PCP.Algebraic.PointLineEndpointConsistency.mixedGrid", + "Prod.mk", + "PCP.Algebraic.PointLineTest.prediction", + "PCP.Algebraic.PointLineTest.decodedTable", + "PCP.Algebraic.PolynomialLine.point", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨2, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 3 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 18 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "Decidable.byContradiction", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The bounded algebraic witness characterizes any finite graph that fits in the grid.\nThe embedding and padded graph are supplied by the stated cardinality bound. ", + "end_line": 191, + "is_class": false, + "kind": "theorem", + "line": 173, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates_on_grid", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ {V : Type u_3} [inst_5 : Fintype V] (G : SimpleGraph V) (H : Finset F),\n H.Nonempty →\n ∀ (hsize : Fintype.card V ≤ H.card ^ Fintype.card σ),\n have G' := PCP.Algebraic.GraphGridEmbedding.pad G (PCP.Algebraic.GraphGridEmbedding.gridEmbedding H hsize);\n G.Colorable 3 ↔\n ∃ P MVal MProp,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n MVal.totalDegree ≤ 3 * ((H.card - 1) * Fintype.card σ) ∧\n MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) ∧\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal ∧\n PCP.Algebraic.GridVanishing.IsCertificate H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G')\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P))\n MProp", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "SimpleGraph", + "Finset", + "Finset.Nonempty", + "LE.le", + "instLENat", + "Fintype.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Finset.card", + "PCP.Algebraic.GraphGridEmbedding.Grid", + "PCP.Algebraic.GraphGridEmbedding.pad", + "PCP.Algebraic.GraphGridEmbedding.gridEmbedding", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "And", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "_private.PCP.Reduction.FiniteDomainConstraints.0.PCP.Reduction.FiniteDomainConstraints.scope.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {a d : ℕ} →\n (motive :\n PCP.Reduction.FiniteDomainConstraints.Constraint V C →\n Fin (PCP.Reduction.FiniteDomainConstraints.arity a d) → Sort u_3) →\n (x : PCP.Reduction.FiniteDomainConstraints.Constraint V C) →\n (x_1 : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) →\n ((e : C) → (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) → motive (Sum.inl e) n) →\n ((v : V) → (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) → motive (Sum.inr v) n) →\n motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.arity", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "PCP.Reduction.FiniteDomainConstraints.scope.match_1" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), a ^ m * a ^ n = a ^ (m + n)", + "type_dependencies": [ + "Monoid", + "Nat", + "Eq", + "HMul.hMul", + "instHMul", + "MulOne.toMul", + "MulOneClass.toMulOne", + "Monoid.toMulOneClass", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The rejection loss is precisely the probability of four nonzero parameters. ", + "end_line": 165, + "is_class": false, + "kind": "theorem", + "line": 159, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate ρ nodes ζ H G π =\n PCP.Algebraic.ThreeColorFullFieldSampling.retention (Fintype.card F) *\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.ThreeColorFullFieldSampling.retention", + "Fintype.card", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Both correction calls have the promised mean error even when they share\ntheir sampled direction and homogeneous label. ", + "end_line": 215, + "is_class": false, + "kind": "theorem", + "line": 182, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.correction_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (Q : (σ → F) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F),\n (∀ (b : σ → F), (Q b).totalDegree ≤ c) →\n ∀ (parameter : Fˣ → F),\n PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H parameter)\n (PCP.Algebraic.BinaryLocalCorrection.decodedAt ρ Q parameter) ≤\n ↑(c + 1) *\n Finset.univ.expect fun b =>\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ (H b) fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) (Q b))))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Units", + "Semiring.toMonoid", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "instFintypeProd", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "PCP.Algebraic.BinaryLocalCorrection.decodedAt", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Tag the primary oracle separately from each target's certificate-correction queries. ", + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 73, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (x : ℕ) (b : Bool) (x_1 : PCP.ProofOracle)\n (h_1 : (x : ℕ) → (b : Bool) → (x_2 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_2)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match x, PCP.QueryTree.leaf b, x_1 with\n | x, PCP.QueryTree.leaf b, x_2 => h_1 x b x_2\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_1 x b x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.eval.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] {inst_1 : DecidableEq ι} [inst_2 : DecidableEq ι] (f f_1 : (ι → ZMod 2) → ℚ),\n f = f_1 → ∀ (a a_1 : ι → ZMod 2), a = a_1 → PCP.Algebraic.BLR.fourier f a = PCP.Algebraic.BLR.fourier f_1 a_1", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.fourier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = ↑(V.acceptingRandomness x π).card / 2 ^ V.randomness x.length", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Eq", + "Rat", + "PCP.Verifier.accProb", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.acceptingRandomness", + "Rat.instPowNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Read each structured-table bit from its single-word address. ", + "end_line": 74, + "is_class": false, + "kind": "definition", + "line": 72, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "{N : ℕ} → PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord N → PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof N", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "PCP.Algebraic.ThreeColorVerifier.ofOracle", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.size", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorVerifier.Query", + "DFunLike.coe", + "Equiv", + "PCP.Algebraic.ThreeColorBinaryVerifier.Address", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] {t r : ℕ} (hr : 1 ≤ r)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (g : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr f g =\n PCP.Algebraic.relativeDistance\n (fun s => g (Sum.elim s.1.1 s.1.2) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2)) fun s =>\n f s.1.1 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2) -\n f s.1.2 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2)", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Sum", + "Eq", + "Rat", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "PCP.Algebraic.relativeDistance", + "Prod", + "Fin", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate._proof_1", + "ZMod.decidableEq", + "Sum.elim", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLowDegreeTest.queries.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {c t r : ℕ} (hr : 1 ≤ r)\n (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (a a_1 : Fin (c + 1) → F),\n a = a_1 →\n ∀ (s s_1 : PCP.Algebraic.BinaryLowDegreeTest.TestRandomness F σ t r),\n s = s_1 →\n PCP.Algebraic.BinaryLowDegreeTest.queries hr ρ a s =\n PCP.Algebraic.BinaryLowDegreeTest.queries hr ρ_1 a_1 s_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryLowDegreeTest.TestRandomness", + "List", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLowDegreeTest.queries" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 0 → ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "Bool", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "Bool", + "PCP.QueryTree.leaf", + "PCP.QueryTree.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The seven concrete branch verdicts. ", + "end_line": 115, + "is_class": false, + "kind": "definition", + "line": 96, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n (i : Fin 7) → PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Fin.cases", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_3", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines", + "Fin.succ", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_4", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines", + "Fin.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "Decidable.decide", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_6", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary", + "Option.some", + "Prod.mk", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Option.instDecidableEq", + "instDecidableEqProd", + "ZMod.decidableEq", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_8", + "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "PCP.Algebraic.BinaryDifferenceConsistency.check", + "Prod.fst", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "Prod.snd", + "Fin.elim0" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A nonzero bivariate polynomial has at most its `X` degree many identically\nzero selected `Y`-columns. The field-size premise prevents zero polynomial functions. ", + "end_line": 237, + "is_class": false, + "kind": "theorem", + "line": 212, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.card_zero_columns_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype I] {e : ℕ} (a : I → F),\n Function.Injective a →\n ∀ (E : MvPolynomial (Fin 2) F),\n E ≠ 0 →\n MvPolynomial.degreeOf 0 E ≤ e →\n (∀ (j : Fin 2), MvPolynomial.degreeOf j E < Fintype.card F) →\n {i | PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i) = 0}.card ≤ e", + "type_dependencies": [ + "Field", + "Fintype", + "Nat", + "Function.Injective", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Ne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "LE.le", + "instLENat", + "MvPolynomial.degreeOf", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "LT.lt", + "instLTNat", + "Fintype.card", + "Finset.card", + "Finset.filter", + "Eq", + "Polynomial", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "Polynomial.instZero", + "Polynomial.instDecidableEq", + "Classical.propDecidable", + "Finset.univ" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_singleton", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (a : R) (i : σ),\n PCP.Algebraic.GridVanishing.coordinate {a} i = MvPolynomial.X i - MvPolynomial.C a", + "type_dependencies": [ + "CommRing", + "Eq", + "MvPolynomial", + "CommRing.toCommSemiring", + "PCP.Algebraic.GridVanishing.coordinate", + "Singleton.singleton", + "Finset", + "Finset.instSingleton", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.normalize._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V)\n (f : (PCP.Reduction.NAEThreeColor.graph Q).Coloring (Fin 3)) {v w : PCP.Reduction.NAEThreeColor.Vertex V C},\n (PCP.Reduction.NAEThreeColor.graph Q).Adj v w →\n (PCP.Reduction.NAEThreeColor.palette Q f).symm (f v) = (PCP.Reduction.NAEThreeColor.palette Q f).symm (f w) → False", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "SimpleGraph.Adj", + "Eq", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Reduction.NAEThreeColor.palette", + "RelHom.instFunLike", + "SimpleGraph.completeGraph", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 18, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → ℕ → F → Prop", + "type_dependencies": [ + "Field", + "Nat" + ], + "value_dependencies": [ + "Field", + "Nat", + "And", + "Function.Injective", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "Ne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "_private.PCP.Algebraic.WeightedConstraintSoundness.0.PCP.Algebraic.WeightedConstraint.grid_comm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] (a w : I → F) (f : V → F) (x y z b : V),\n ∑ i, w i * PCP.Algebraic.WeightedConstraint.predict a w f (x + a i • y) (z + a i • b) =\n ∑ j, w j * PCP.Algebraic.WeightedConstraint.predict a w f (x + a j • z) (y + a j • b)", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "Eq", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "PCP.Algebraic.WeightedConstraint.predict", + "HAdd.hAdd", + "instHAdd", + "AddCommMagma.toAdd", + "AddCommSemigroup.toAddCommMagma", + "AddCommMonoid.toAddCommSemigroup", + "HSMul.hSMul", + "instHSMul", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type (max u_2 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A slightly looser size form that retains the first field's size explicitly. ", + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 155, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le_sixteen_max", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) ≤ 16 * max 16 M", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "definition", + "line": 52, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type (max u_2 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Fact 2.7, for ordinary total degree, including constant polynomials. ", + "end_line": 265, + "is_class": false, + "kind": "theorem", + "line": 251, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eq_zero_iff_exists_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F} [Finite σ],\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : (σ → F) → F),\n (∀ (u v : σ → F), PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v = 0) ↔\n ∃ P, P.totalDegree ≤ c ∧ ∀ (x : σ → F), (MvPolynomial.eval x) P = f x", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Finite", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Iff", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Exists", + "MvPolynomial", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The returned answer depends only on the stated queries. ", + "end_line": 119, + "is_class": false, + "kind": "theorem", + "line": 97, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f g : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H K : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a b : σ → F) (z : Fˣ)\n (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n (∀ p ∈ PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ a b z v w s,\n PCP.Algebraic.BinaryLocalCorrection.read f H p = PCP.Algebraic.BinaryLocalCorrection.read g K p) →\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ f H a b z v w s =\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ g K a b z v w s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.run" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} {witnessBound : Polynomial ℕ}\n {check : List Bool → List Bool → Bool} {check_polyTime : P check}\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true}\n {witnessBound_1 : Polynomial ℕ} {check_1 : List Bool → List Bool → Bool} {check_polyTime_1 : P check_1}\n {spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true},\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 } →\n witnessBound = witnessBound_1 ∧ check = check_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Two distinct polynomials of degree at most `d` agree on at most a `d / |𝔽|` fraction. ", + "end_line": 46, + "is_class": false, + "kind": "theorem", + "line": 34, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.eval_agreement_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] [inst_2 : DecidableEq 𝔽] {m d : ℕ}\n (p q : MvPolynomial (Fin m) 𝔽),\n p.totalDegree ≤ d →\n q.totalDegree ≤ d →\n p ≠ q →\n (PCP.Algebraic.relativeAgreement (fun x => (MvPolynomial.eval x) p) fun x => (MvPolynomial.eval x) q) ≤\n ↑d / ↑(Fintype.card 𝔽)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Ne", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeAgreement", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.averageRejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {t r : ℕ} [inst : Fintype ι] (hr : 1 ≤ r)\n (H : ι → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.averageRejectionRate hr H =\n (∑ i, PCP.Algebraic.Hadamard.testRejectionRate hr (H i)) / ↑(Fintype.card ι)", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.Hadamard.averageRejectionRate", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "PCP.Algebraic.Hadamard.testRejectionRate", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_1.else_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u} {β : Type v} {motive : α ⊕ β → Sort u_1} (t : α ⊕ β) (inl : (val : α) → motive (Sum.inl val))\n («else» : Nat.hasNotBit 1 t.ctorIdx → motive t) (h : Nat.hasNotBit 1 t.ctorIdx),\n PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_1 t inl «else» = «else» h", + "type_dependencies": [ + "Sum", + "Sum.inl", + "Nat.hasNotBit", + "Sum.ctorIdx", + "Eq", + "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.eval_validPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F) (x : σ → F),\n (MvPolynomial.eval x) (PCP.Algebraic.ThreeColorGrid.validPolynomial P) = (MvPolynomial.eval x) P ^ 3 - 1", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.read.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t)\n (q :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n ×\n PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.read p M A (Sum.inr q) =\n PCP.Algebraic.BinaryLocalCorrection.read M (A q.1) q.2", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.read", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.read", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every received eight-table proof of a non-three-colorable grid graph is\nrejected with a fixed positive probability, independent of graph size. ", + "end_line": 130, + "is_class": false, + "kind": "theorem", + "line": 115, + "module": "PCP.Algebraic.ThreeColorVerifierSoundness", + "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate_ge_of_not_colorable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] {n m c t : ℕ} [NeZero m]\n [CharP F 2],\n 1 ≤ c →\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n 100 * (c * m ^ c) * H.card ≤ Fintype.card F →\n (H.card - 1) * n ≤ c * m ^ c →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n ¬G.Colorable 3 →\n ∀ (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorSoundnessBudget.gap c ≤\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "Finset.card", + "HSub.hSub", + "instHSub", + "instSubNat", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Not", + "SimpleGraph.Colorable", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat", + "Rat.instLE", + "PCP.Algebraic.ThreeColorSoundnessBudget.gap", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "Classical.propDecidable", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A usual proper three-coloring supplies the required field assignment. ", + "end_line": 91, + "is_class": false, + "kind": "theorem", + "line": 85, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.satisfies_colorValue", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} [inst : Field F] [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (G : SimpleGraph V) (C : G.Coloring (Fin 3)),\n PCP.Algebraic.ThreeColorAlgebra.Satisfies G fun v => PCP.Algebraic.ThreeColorAlgebra.colorValue ω (C v)", + "type_dependencies": [ + "Field", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "SimpleGraph", + "SimpleGraph.Coloring", + "Fin", + "PCP.Algebraic.ThreeColorAlgebra.Satisfies", + "PCP.Algebraic.ThreeColorAlgebra.colorValue", + "DFunLike.coe", + "RelHom.instFunLike", + "SimpleGraph.Adj", + "SimpleGraph.completeGraph" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A primary-table location or a difference-table location. ", + "end_line": 58, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → Type (max u_3 u_4)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateColumnSelection", + "name": "PCP.Algebraic.BivariateColumnSelection.exists_good_columns._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Fintype F] {d : ℕ}, 20 * d ≤ Fintype.card F → ¬2 * (10 * d) ≤ Fintype.card F → False", + "type_dependencies": [ + "Fintype", + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "definition", + "line": 23, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {b b' : Bool} → PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b' → (b = b' → P) → P", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "id", + "PCP.Machine.Sym.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridCorrection.0.PCP.Algebraic.BinaryZeroOnGridCorrection.read.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.BinaryZeroOnGridCorrection.Query F n m c t → Sort u_2) →\n (x : PCP.Algebraic.BinaryZeroOnGridCorrection.Query F n m c t) →\n ((q : (Fin n → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl q)) →\n ((q :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n ×\n PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t) →\n motive (Sum.inr q)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Sum.inr" + ], + "value_dependencies": [ + "PCP.Algebraic.BinaryZeroOnGridCorrection.read.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Agreement on the query list determines the verdict. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 75, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.check_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {t r : ℕ} (hr : 1 ≤ r) (a b : σ → F) (w : Fin t → ZMod 2)\n (f f' : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (g g' : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n (∀ q ∈ PCP.Algebraic.BinaryDifferenceConsistency.queries hr a b w,\n PCP.Algebraic.BinaryDifferenceConsistency.read f g q = PCP.Algebraic.BinaryDifferenceConsistency.read f' g' q) →\n PCP.Algebraic.BinaryDifferenceConsistency.check hr f g a b w =\n PCP.Algebraic.BinaryDifferenceConsistency.check hr f' g' a b w", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.BinaryDifferenceConsistency.queries", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.read", + "PCP.Algebraic.BinaryDifferenceConsistency.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The prediction at `x` using the line centered at `x - t • v`. ", + "end_line": 114, + "is_class": false, + "kind": "definition", + "line": 112, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.prediction", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} → [inst : Field F] → {c : ℕ} → PCP.Algebraic.PointLineTest.LineTable F σ c → (σ → F) → (σ → F) × F → F", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.PointLineTest.LineTable", + "Prod" + ], + "value_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.PointLineTest.LineTable", + "Prod", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.snd", + "Subtype.val", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Prod.mk", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring", + "Prod.fst" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.predictionSamplesEquiv._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (s : ((σ → F) × (σ → F)) × F),\n (((PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2, s.1.2, s.2).1 -\n (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2, s.1.2, s.2).2.2 •\n (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2, s.1.2, s.2).2.1,\n (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2, s.1.2, s.2).2.1),\n (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2, s.1.2, s.2).2.2) =\n s", + "type_dependencies": [ + "Field", + "Prod", + "Eq", + "Prod.mk", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Prod.fst", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.snd", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring", + "CommSemiring.toSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 31, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_ofBits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool), (PCP.Machine.ofBits x).length = x.length", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "Nat", + "List.length", + "PCP.Machine.Sym", + "PCP.Machine.ofBits" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "recursor", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Sort u} →\n ((color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t) →\n (validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t) →\n (properLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t) →\n motive\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines }) →\n (t : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) → motive t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 109, + "is_class": false, + "kind": "definition", + "line": 105, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.directDecidable", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n [DecidableEq V] →\n [DecidableEq C] →\n (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) → DecidableRel (PCP.Reduction.NAEThreeColor.direct Q)", + "type_dependencies": [ + "DecidableEq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "DecidableRel", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.direct" + ], + "value_dependencies": [ + "DecidableEq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Vertex", + "Sum.casesOn", + "Sum", + "Prod", + "Bool", + "Decidable", + "PCP.Reduction.NAEThreeColor.direct", + "Sum.inl", + "id", + "inferInstance", + "Not", + "Eq", + "instDecidableNot", + "instDecidableEqFin", + "Sum.inr", + "Prod.casesOn", + "Prod.mk", + "False", + "instDecidableFalse", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1", + "And", + "instDecidableAnd", + "instDecidableEqBool", + "PCP.Reduction.NAEThreeColor.literalVertex", + "instDecidableEqSum", + "instDecidableEqProd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Averaging errors by columns bounds the mean number of errors in a row. ", + "end_line": 99, + "is_class": false, + "kind": "theorem", + "line": 82, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.expect_rowErrors_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype I]\n (a : I → F) (C : I → Polynomial F) (R : F → Polynomial F) {ε : ℚ},\n (∀ (i : I),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x => Polynomial.eval x (C i)) ≤ ε) →\n (Finset.univ.expect fun y => ↑(PCP.Algebraic.BivariateCleanRectangle.rowErrors a C R y)) ≤ ↑(Fintype.card I) * ε", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Polynomial.eval", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "Nat.cast", + "Rat.instNatCast", + "PCP.Algebraic.BivariateCleanRectangle.rowErrors", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.queries_length", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (hP : P.natDegree ≤ r) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (R : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n (PCP.Algebraic.HadamardDerivedOracle.queries ρ P hP L R).length = 2", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "List.length", + "PCP.Algebraic.HadamardDerivedOracle.queries" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Embed a homogeneous linear query into the degree-`r` query space. ", + "end_line": 152, + "is_class": false, + "kind": "definition", + "line": 149, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t r : ℕ} → 1 ≤ r → (Fin t → ZMod 2) →ₗ[ZMod 2] PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Finset.sum", + "Fin", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.addCommMonoid", + "Finset.univ", + "Fin.fintype", + "LinearMap.smulRight", + "PCP.Algebraic.Hadamard.homogeneousIndex._proof_1", + "LinearMap.proj", + "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 170, + "is_class": false, + "kind": "theorem", + "line": 163, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r), Function.Injective ⇑(PCP.Algebraic.Hadamard.homogeneousIndex hr)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Fin", + "ZMod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.ReferenceNPConverse", + "name": "PCP.ReferenceNP.of_inNP._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (R : List Bool → List Bool → Bool) (x w : List Bool),\n (Complexity.pair x w ∈ PCP.Machine.ReferencePair.checkerLanguage R) = (R x w = true)", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "Membership.mem", + "Complexity.Language", + "Set.instMembership", + "PCP.Machine.ReferencePair.checkerLanguage", + "Complexity.pair", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.queries hr ρ nodes ζ s =\n List.map (fun p => Sum.inl (s.1.1, p)) (PCP.Algebraic.Hadamard.testQueries hr s.2.2.2.1) ++\n List.map (fun p => Sum.inr (s.1, p))\n (PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1 ρ nodes\n s.2.2.2.2) ++\n List.map (fun p => Sum.inr (s.1, p))\n (PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c s.2.1) s.2.2.1.1 s.2.2.1.2) ++\n [Sum.inl\n (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1,\n (PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2.2.1.2)]", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "List", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "HAppend.hAppend", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.SetMultilinear.Variables", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.Hadamard.testQueries", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "List.cons", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "List.nil" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {W : Type u_3} [inst : Field F] (s : ((σ → F) × Fˣ) × W), ↑s.1.2 ≠ 0", + "type_dependencies": [ + "Field", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Ne", + "Units.val", + "MonoidWithZero.toMonoid", + "Semiring.toMonoidWithZero", + "Prod.snd", + "Prod.fst", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A union of zero sets of nonzero bounded-degree column polynomials is small. ", + "end_line": 131, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.fraction_exists_column_zero_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] (J : Finset I) (E : I → Polynomial F) (D : ℕ),\n (∀ i ∈ J, E i ≠ 0) →\n (∀ i ∈ J, (E i).natDegree ≤ D) →\n (PCP.Algebraic.AffineLineSampling.fraction fun y => ∃ i ∈ J, Polynomial.eval y (E i) = 0) ≤\n ↑J.card * ↑D / ↑(Fintype.card F)", + "type_dependencies": [ + "Field", + "Fintype", + "Finset", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Nat", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Polynomial.instZero", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.AffineLineSampling.fraction", + "Exists", + "And", + "Eq", + "Polynomial.eval", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "General point-versus-line soundness with explicit absolute constants,\nincluding degree zero and zero-dimensional spaces. ", + "end_line": 69, + "is_class": false, + "kind": "theorem", + "line": 56, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.PointLineTest.exists_close_of_small_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {d : ℕ},\n PCP.Algebraic.PointLineConstants.fieldFactor * d ^ 3 ≤ Fintype.card F →\n ∀ (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ d),\n PCP.Algebraic.PointLineTest.rejectionRate f table ≤ PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ d ∧\n (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤\n 2 * PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.PointLineTest.LineTable", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Rat.instMul", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 157, + "is_class": false, + "kind": "theorem", + "line": 154, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.polynomial_homogeneousIndex", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (w : Fin t → ZMod 2),\n (PCP.Algebraic.BinaryPolynomialSpace.polynomial t r) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) w) =\n ∑ i, MvPolynomial.C (w i) * MvPolynomial.X i", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.polynomial", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Finset.sum", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C", + "MvPolynomial.X" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableRelVertexAdjGraphOfDecidableEq._aux_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n [DecidableEq V] →\n [DecidableEq C] →\n (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) → DecidableRel (PCP.Reduction.NAEThreeColor.graph Q).Adj", + "type_dependencies": [ + "DecidableEq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "DecidableRel", + "PCP.Reduction.NAEThreeColor.Vertex", + "SimpleGraph.Adj", + "PCP.Reduction.NAEThreeColor.graph" + ], + "value_dependencies": [ + "DecidableEq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Vertex", + "instDecidableRelAdjFromRelOfDecidableEq", + "instDecidableEqSum", + "Sum", + "Prod", + "Bool", + "instDecidableEqFin", + "instDecidableEqProd", + "instDecidableEqBool", + "PCP.Reduction.NAEThreeColor.direct", + "PCP.Reduction.NAEThreeColor.directDecidable" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), ¬0 ≤ 1 → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 156, + "is_class": false, + "kind": "definition", + "line": 154, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1 →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.validQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.boolColor_ne_two._simp_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), (PCP.Reduction.NAEThreeColor.boolColor b = 2) = False", + "type_dependencies": [ + "Bool", + "Eq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.boolColor", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Both algebraic constraints, with edge constraints imposed only on actual edges. ", + "end_line": 74, + "is_class": false, + "kind": "definition", + "line": 72, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.Satisfies", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {V : Type u_2} → [Field F] → SimpleGraph V → (V → F) → Prop", + "type_dependencies": [ + "Field", + "SimpleGraph" + ], + "value_dependencies": [ + "Field", + "SimpleGraph", + "And", + "Eq", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "SimpleGraph.Adj" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Compare one nonzero line sample, returning its proposed origin value on acceptance. ", + "end_line": 238, + "is_class": false, + "kind": "definition", + "line": 234, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.correct", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} → [inst : Field F] → ((σ → F) → Polynomial F) → ((σ → F) → F) → (σ → F) → (σ → F) → Fˣ → Option F", + "type_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Units", + "Semiring.toMonoid", + "Option" + ], + "value_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Units", + "Semiring.toMonoid", + "ite", + "Option", + "Eq", + "Polynomial.eval", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "Classical.propDecidable", + "Option.some", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Option.none" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Bundled actual query list for one certificate correction call. ", + "end_line": 71, + "is_class": false, + "kind": "definition", + "line": 66, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.callQueries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n (Fin t → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t →\n List (PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.BinaryLocalCorrection.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The binary dimension follows from the explicit coefficient equivalence. ", + "end_line": 55, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.finrank_fieldFamily", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), Module.finrank (ZMod 2) (PCP.Algebraic.ThreeColorFields.FieldFamily k) = 4 * (k + 1)", + "type_dependencies": [ + "Nat", + "Eq", + "Module.finrank", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.BinaryMaterializedField.instModuleZModOfNatNatElement" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_smul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ) (a : R)\n (P : MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R),\n (PCP.Algebraic.SetMultilinear.decode m c) (a • P) = Polynomial.C a * (PCP.Algebraic.SetMultilinear.decode m c) P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "Polynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The minimum normalized error of one parametrized line. ", + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 73, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.decodedLineError", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → [Fintype F] → [DecidableEq F] → ℕ → ((σ → F) → F) → (σ → F) × (σ → F) → ℚ", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Prod", + "Rat" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Prod", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "Prod.snd", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Subtype.val", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.decodedTable" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Two approximations to the same grid have small average column disagreement. ", + "end_line": 75, + "is_class": false, + "kind": "theorem", + "line": 68, + "module": "PCP.Algebraic.BivariateColumnSelection", + "name": "PCP.Algebraic.BivariateColumnSelection.mean_column_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {I : Type u_1} {J : Type u_2} {A : Type u_3} [inst : Fintype I] [inst_1 : Fintype J] [inst_2 : DecidableEq A]\n (f R C : I × J → A) {ε : ℚ},\n PCP.Algebraic.relativeDistance f R ≤ ε →\n PCP.Algebraic.relativeDistance f C ≤ ε →\n (Finset.univ.expect fun x => PCP.Algebraic.relativeDistance (fun y => R (x, y)) fun y => C (x, y)) ≤ 2 * ε", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Prod", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "Prod.mk", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ) (i : Fin (c + 1)), ↑i ≠ c → ¬↑i < c → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Ne", + "Fin.val", + "Not", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Uniform affine output queries retain the same factor-two error bound. ", + "end_line": 133, + "is_class": false, + "kind": "theorem", + "line": 124, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.affine_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} {I : Type u_2} [inst_2 : Fintype I]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (P : I → Polynomial F) (hP : ∀ (i : I), (P i).natDegree ≤ r)\n (H : I → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) (f : I → F),\n (PCP.Algebraic.relativeDistance (fun s => PCP.Algebraic.HadamardDerivedOracle.answer ρ (P s.1) ⋯ (H s.1) s.2.1 s.2.2)\n fun s => (PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval (f s.1) (P s.1)))) s.2.1) ≤\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ H f", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "An oracle verifier.\n\nOn an input `x` of length `n` it draws `randomness n` fair bits and then runs the decision tree\nselected by that random string, making at most `queries` *bit* queries into the proof. ", + "end_line": 91, + "is_class": false, + "kind": "inductive", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Verifier.mk", + "PCP.Verifier" + ], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instInhabitedSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "Inhabited PCP.Machine.Sym", + "type_dependencies": [ + "Inhabited", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Inhabited.mk", + "PCP.Machine.Sym", + "PCP.Machine.instInhabitedSym.default" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The final primary-oracle proximity factor. ", + "end_line": 50, + "is_class": false, + "kind": "definition", + "line": 49, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HAdd.hAdd", + "Rat", + "instHAdd", + "Rat.instAdd", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 176, + "is_class": false, + "kind": "theorem", + "line": 136, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.correction_satisfies", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] [inst_4 : Fintype F] [inst_5 : DecidableEq F] [inst_6 : Fintype V] (a w : I → F),\n (∀ (i : I), a i ≠ 0) →\n ∀ (f : V → F),\n (2 * ↑(Fintype.card I) + 3) * ↑(Fintype.card I) * PCP.Algebraic.WeightedConstraint.rejectionRate a w f < 1 →\n ∀ (x v : V),\n PCP.Algebraic.WeightedConstraint.correction a w f x =\n PCP.Algebraic.WeightedConstraint.predict a w (PCP.Algebraic.WeightedConstraint.correction a w f) x v", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "LT.lt", + "Rat", + "Rat.instLT", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "Eq", + "PCP.Algebraic.WeightedConstraint.correction", + "PCP.Algebraic.WeightedConstraint.predict" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "recursor", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Verifier → Sort u} →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n (t : PCP.Verifier) → motive t", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A two-query correction rule for any finite additive codeword. ", + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 33, + "module": "PCP.Algebraic.HadamardCorrection", + "name": "PCP.Algebraic.Hadamard.selfCorrect_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {W : Type u_2} [inst : AddCommGroup V] [inst_1 : AddCommGroup W] [inst_2 : Fintype V]\n [inst_3 : DecidableEq W] (E : V →+ W) (w : V → W) (P : V),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.Hadamard.selfCorrect w P) fun x => E P) ≤\n 2 * PCP.Algebraic.relativeDistance w ⇑E", + "type_dependencies": [ + "AddCommGroup", + "Fintype", + "DecidableEq", + "AddMonoidHom", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.Hadamard.selfCorrect", + "DFunLike.coe", + "AddMonoidHom.instFunLike", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.eval_agreement_le._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t : ℕ} →\n (motive : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → Sort u_3) →\n (x : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl p)) →\n ((p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "recursor", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n (t : PCP.NPCertificate P L) → motive t", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The coordinate polynomial `∏ a ∈ H, (X i - a)`. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → Finset R → σ → MvPolynomial σ R", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring" + ], + "value_dependencies": [ + "CommRing", + "Finset", + "Finset.prod", + "MvPolynomial", + "CommRing.toCommSemiring", + "CommRing.toCommMonoid", + "AddMonoidAlgebra.commRing", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False", + "type_dependencies": [ + "Zero", + "OfNat", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "NeZero", + "Eq", + "Zero.toOfNat0", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 223, + "is_class": false, + "kind": "theorem", + "line": 195, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_univariate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : F → F),\n (∀ (u v : F),\n f u =\n PCP.Algebraic.WeightedConstraint.predict (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f u v) →\n ∃ P, P.natDegree ≤ c ∧ ∀ (x : F), Polynomial.eval x P = f x", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "PCP.Algebraic.WeightedConstraint.predict", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Semiring.toModule", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "Exists", + "Polynomial", + "And", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.read.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {t r : ℕ} (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (g : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (p : (σ ⊕ σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n PCP.Algebraic.BinaryDifferenceConsistency.read f g (Sum.inr p) = g p.1 p.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Sum", + "Prod", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.read", + "Sum.inr", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The two consecutive observations have exactly the global independent-pair discrepancy. ", + "end_line": 98, + "is_class": false, + "kind": "theorem", + "line": 86, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.consecutive_distance_eq_pairDisagreement", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n {A : Type u_3} [inst_4 : DecidableEq A] (f : (σ → F) → A),\n (PCP.Algebraic.relativeDistance (fun s => f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2)) fun s =>\n f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 (s.2 + 1))) =\n PCP.Algebraic.PointLineTest.pairDisagreement f", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "Prod.snd", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.PointLineTest.pairDisagreement" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)) (P : MvPolynomial σ F),\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ →\n ∀ (MVal : MvPolynomial (σ ⊕ σ) F) (MProp : MvPolynomial ((σ ⊕ σ) ⊕ σ ⊕ σ) F),\n MProp.totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree +\n 3 * (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree ≤ 2 * ((H.card - 1) * Fintype.card σ) →\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree ≤ P.totalDegree →\n ¬MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) → False", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The decision-tree and padding adapters preserve the exact rejection probability. ", + "end_line": 145, + "is_class": false, + "kind": "theorem", + "line": 136, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.rejectionProb_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool) (π : PCP.ProofOracle),\n PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.rejectionProb x π =\n PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate (PCP.Algebraic.ThreeColorEncoding.graph x)\n (PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord x π) (PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode x)", + "type_dependencies": [ + "List", + "Bool", + "PCP.ProofOracle", + "Eq", + "Rat", + "PCP.Verifier.rejectionProb", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "Fin.fintype", + "PCP.Algebraic.ThreeColorEncoding.graph", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.direct.match_1.eq_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2}\n (motive : PCP.Reduction.NAEThreeColor.Vertex V C → PCP.Reduction.NAEThreeColor.Vertex V C → Sort u_3) (e : C)\n (i : Fin 3) (f : C) (j : Fin 3) (h_1 : (i j : Fin 3) → motive (Sum.inl i) (Sum.inl j))\n (h_2 : (val : V × Bool) → (i : Fin 3) → motive (Sum.inr (Sum.inl val)) (Sum.inl i))\n (h_3 : (v : V) → (b : Bool) → (w : V) → (d : Bool) → motive (Sum.inr (Sum.inl (v, b))) (Sum.inr (Sum.inl (w, d))))\n (h_4 : (e : C) → (i : Fin 3) → (f : C) → (j : Fin 3) → motive (Sum.inr (Sum.inr (e, i))) (Sum.inr (Sum.inr (f, j))))\n (h_5 : (e : C) → (i : Fin 3) → (x : PCP.Reduction.NAEThreeColor.Vertex V C) → motive (Sum.inr (Sum.inr (e, i))) x)\n (h_6 : (x x_1 : PCP.Reduction.NAEThreeColor.Vertex V C) → motive x x_1),\n (match Sum.inr (Sum.inr (e, i)), Sum.inr (Sum.inr (f, j)) with\n | Sum.inl i, Sum.inl j => h_1 i j\n | Sum.inr (Sum.inl val), Sum.inl i => h_2 val i\n | Sum.inr (Sum.inl (v, b)), Sum.inr (Sum.inl (w, d)) => h_3 v b w d\n | Sum.inr (Sum.inr (e, i)), Sum.inr (Sum.inr (f, j)) => h_4 e i f j\n | Sum.inr (Sum.inr (e, i)), x => h_5 e i x\n | x, x_1 => h_6 x x_1) =\n h_4 e i f j", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk", + "Eq", + "PCP.Reduction.NAEThreeColor.direct.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 214, + "is_class": false, + "kind": "theorem", + "line": 212, + "module": "PCP.Verifier.Definition", + "name": "PCP.finiteWitnessCheck_eq_true_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w = true ↔\n ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Iff", + "Eq", + "PCP.finiteWitnessCheck", + "Bool.true", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "PCP.oracleOfWitness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.graph.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V),\n PCP.Reduction.NAEThreeColor.graph Q = SimpleGraph.fromRel (PCP.Reduction.NAEThreeColor.direct Q)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "SimpleGraph", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "SimpleGraph.fromRel", + "PCP.Reduction.NAEThreeColor.direct" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph_colorable_iff._simp_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V) (eV : optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V)),\n (PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph G eV).Colorable 3 = G.Colorable 3", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "optParam", + "Equiv", + "Fin", + "Fintype.card", + "Fintype.equivFin", + "Eq", + "SimpleGraph.Colorable", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "OfNat.ofNat", + "Nat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 282, + "is_class": false, + "kind": "theorem", + "line": 277, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.canonical_linked", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {T B : ℕ} (initial : tm.Cfg) (hs : PCP.Machine.StackSupported tm initial.stk),\n PCP.Machine.mass initial.stk + PCP.Machine.machinePushBound tm * T ≤ B →\n ∀ (i : Fin (T + 1)),\n PCP.Machine.TableauCells.Linked ((PCP.Machine.TableauCells.canonicalAssignment tm T B initial hs).1 i)\n ((PCP.Machine.TableauCells.canonicalAssignment tm T B initial hs).2 i)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.mass", + "Turing.FinTM2.kFin", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Machine.machinePushBound", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.TableauCells.Linked", + "Prod.fst", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "PCP.Machine.TableauCells.canonicalAssignment", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The corrector evaluated on its full finite sample. ", + "end_line": 67, + "is_class": false, + "kind": "definition", + "line": 61, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n (σ → F) → PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → Option (ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.run", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "**`PCP(O(log n), O(1)) ⊆ NP` for the concrete machine model.**\n\nAn efficiently implemented verifier — polynomial-time in the sense of `PCP/Complexity/Machine.lean`,\na step count on `Turing.FinTM2` — with a canonical logarithmic budget, a polynomial proof-length\nbound, perfect completeness and soundness `1/2` puts its language in NP for that same concrete\nclass. No cost model is a parameter, and no model-existence premise is assumed: the model comes\nfrom `Machine.exists_standardCostModel`, whose closure field is the certified finite-witness\nchecker of `PCP/Complexity/CheckerFinal.lean`. ", + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 25, + "module": "PCP.ReverseConcrete", + "name": "PCP.pcp_subset_np_concrete", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (L : PCP.Language) (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PCP.Machine.PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n (∀ (x : List Bool), L x → V.CompleteAt x) →\n (∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)) → PCP.InNP PCP.Machine.PolyTimeRel L", + "type_dependencies": [ + "PCP.Language", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.Machine.PolyTimeAlg", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.InNP", + "PCP.Machine.PolyTimeRel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An actual outer test bounded by a larger rejection budget supplies the same\nlarger full and homogeneous proximity budgets. ", + "end_line": 53, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.ThreeColorVerifierSoundness", + "name": "_private.PCP.Algebraic.ThreeColorVerifierSoundness.0.PCP.Algebraic.ThreeColorVerifier.exists_close_of_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] {m c t : ℕ} [NeZero m] [CharP F 2]\n {σ : Type u_2} [inst_5 : Fintype σ] [inst_6 : DecidableEq σ] {r : ℕ},\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (L : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t) {κ : ℚ},\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f L ≤ κ →\n PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c * κ ≤\n PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ c * m ^ c ∧\n (PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ f fun x => (MvPolynomial.eval x) P) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c * κ ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P)))) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c * κ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "DecidableEq", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Rat.instMul", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Field.toCommRing", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The computed length is exactly the cardinality used in the resource bound. ", + "end_line": 70, + "is_class": false, + "kind": "theorem", + "line": 68, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength_eq_card", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n PCP.Algebraic.ThreeColorBinaryVerifier.proofLength N = Fintype.card (PCP.Algebraic.ThreeColorBinaryVerifier.Address N)", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Fintype.card", + "PCP.Algebraic.ThreeColorBinaryVerifier.Address", + "PCP.Algebraic.ThreeColorVerifier.queryFintype", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.size", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorParameters.fieldIndex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A nearest polynomial on a transverse slice is forced to equal a comparison\npolynomial once row errors put the comparison inside the unique decoding radius.\nOnly the one necessary comparison in the minimization property is assumed. ", + "end_line": 125, + "is_class": false, + "kind": "theorem", + "line": 105, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.eq_of_transverse_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (R S : F → Polynomial F),\n (∀ (i : F), (R i).natDegree ≤ d) →\n (∀ (i : F), (S i).natDegree ≤ d) →\n ∀ (w : F → F) (p q : Polynomial F),\n p.natDegree ≤ d →\n q.natDegree ≤ d →\n ∀ (y : F),\n (∀ (x : F), Polynomial.eval y (S x) = Polynomial.eval x p) →\n ∀ {η ε : ℚ},\n (PCP.Algebraic.relativeDistance (fun z => Polynomial.eval z.2 (R z.1)) fun z =>\n Polynomial.eval z.2 (S z.1)) ≤\n η →\n (PCP.Algebraic.relativeDistance w fun x => Polynomial.eval y (R x)) ≤ ε →\n ((PCP.Algebraic.relativeDistance w fun x => Polynomial.eval x q) ≤\n PCP.Algebraic.relativeDistance w fun x => Polynomial.eval x p) →\n 2 * (ε + η + ↑d / ↑(Fintype.card F)) < 1 - ↑d / ↑(Fintype.card F) → q = p", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "Polynomial.eval", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Prod.snd", + "Prod.fst", + "LT.lt", + "Rat.instLT", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "HSub.hSub", + "instHSub", + "Rat.instSub" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {W : Type u_3} [inst : Field F] (a : σ → F) (s : ((σ → F) × W) × Fˣ),\n ↑(((PCP.Algebraic.affineSamplingEquiv a ↑s.2 ⋯).symm s.1.1, s.2), s.1.2).1.2 ≠ 0", + "type_dependencies": [ + "Field", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Ne", + "Units.val", + "MonoidWithZero.toMonoid", + "Semiring.toMonoidWithZero", + "Prod.snd", + "Prod.fst", + "Prod.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.affineSamplingEquiv", + "Field.toDivisionRing", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Pi.Function.module", + "Ring.toSemiring", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_2", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (M : MvPolynomial (Fin n ⊕ Fin n) F)\n (a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n),\n PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M a = PCP.Algebraic.BinaryLocalCorrection.honestTable ρ M a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary", + "PCP.Algebraic.BinaryLocalCorrection.honestTable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 381, + "is_class": false, + "kind": "definition", + "line": 380, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeCallSeedOfDecidableEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n {σ : Type u_2} →\n [Fintype σ] → [DecidableEq σ] → Fintype (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.inY.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F],\n PCP.Algebraic.BerlekampWelchCertificate.inY = Polynomial.eval₂RingHom MvPolynomial.C (MvPolynomial.X 1)", + "type_dependencies": [ + "Field", + "Eq", + "RingHom", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.BerlekampWelchCertificate.inY", + "Polynomial.eval₂RingHom", + "AddMonoidAlgebra.commSemiring", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "MvPolynomial.C", + "MvPolynomial.X", + "Fin.instOfNat", + "PCP.Algebraic.BerlekampWelchCertificate.inY._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 226, + "is_class": false, + "kind": "theorem", + "line": 214, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V)\n (π : PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (Fintype.card V))\n (eV : optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V)),\n PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate G π eV =\n let a := PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V);\n PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate (PCP.Algebraic.ThreeColorParameters.coordinates a)\n (⇑(PCP.Algebraic.ThreeColorParameters.nodes a)) (PCP.Algebraic.ThreeColorParameters.generator a)\n (PCP.Algebraic.ThreeColorParameters.grid a) (PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph G eV)\n (PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof π)", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Fintype.card", + "optParam", + "Equiv", + "Fin", + "Fintype.equivFin", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate", + "Nat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorParameters.fieldIndex", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.BinaryMaterializedField.instAlgebraZModOfNatNatElement", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorParameters.coordinates", + "DFunLike.coe", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorParameters.nodes", + "PCP.Algebraic.ThreeColorParameters.generator", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 189, + "is_class": false, + "kind": "theorem", + "line": 185, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_clause_literal", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (e : C) (i : Fin 3),\n (PCP.Reduction.NAEThreeColor.graph Q).Adj (PCP.Reduction.NAEThreeColor.clauseVertex e i)\n (PCP.Reduction.NAEThreeColor.literalVertex (Q e i))", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Adj", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "PCP.Reduction.NAEThreeColor.clauseVertex", + "PCP.Reduction.NAEThreeColor.literalVertex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 137, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.card_variable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {a : ℕ} [inst : Fintype V],\n Fintype.card (PCP.Reduction.FiniteDomainConstraints.Variable V a) = (Fintype.card V + 1) * a", + "type_dependencies": [ + "Nat", + "Fintype", + "Eq", + "Fintype.card", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "instFintypeProd", + "Sum", + "Unit", + "Fin", + "instFintypeSum", + "PUnit.fintype", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Source-style full coefficient-space proximity costs at most a factor two per oracle. ", + "end_line": 356, + "is_class": false, + "kind": "theorem", + "line": 327, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_lower_bound_of_full_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n (PCP.Algebraic.relativeDistance (fun s => p' s.1 s.2) fun s =>\n (PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval s.1) P))) s.2) ≤\n δP →\n (PCP.Algebraic.relativeDistance (fun s => M' s.1 s.2) fun s =>\n (PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval s.1) M))) s.2) ≤\n δM →\n (1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 ≤\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) *\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p' M' A +\n 2 * δP +\n 4 * δM +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instDecidableEqSum", + "instFintypeSum", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The multiplicative correction bound, valid even when `D ≥ |F|-1`.\nThe parameter and direction are sampled independently, and zero directions remain included. ", + "end_line": 105, + "is_class": false, + "kind": "theorem", + "line": 79, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.origin_error_mul_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {D : ℕ} (T : (σ → F) → Polynomial F),\n (∀ (b : σ → F), (T b).natDegree ≤ D) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n ∀ (a : σ → F),\n ((1 - ↑D / ↑(Fintype.card F - 1)) *\n PCP.Algebraic.relativeDistance (fun b => Polynomial.eval 0 (T b)) fun x => (MvPolynomial.eval a) P) ≤\n PCP.Algebraic.relativeDistance (fun s => Polynomial.eval (↑s.2) (T s.1)) fun s =>\n (MvPolynomial.eval (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2)) P", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "OfNat.ofNat", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "instSubNat", + "Fintype.card", + "instOfNatNat", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "Polynomial.eval", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Prod", + "Units", + "Semiring.toMonoid", + "instFintypeProd", + "instFintypeUnitsOfDecidableEq", + "Units.val", + "Prod.snd", + "Prod.fst", + "PCP.Algebraic.PolynomialLine.point" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The minimal exponent loses at most a factor four compared with the requested logarithm. ", + "end_line": 76, + "is_class": false, + "kind": "theorem", + "line": 57, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), PCP.Algebraic.ThreeColorParameterChoice.volume N ≤ 4 * max 8 (Nat.clog 2 N)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "PCP.Algebraic.ThreeColorParameterChoice.volume", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 114, + "is_class": false, + "kind": "theorem", + "line": 109, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.IsLowDegree.relativeDistance_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] [inst_2 : DecidableEq 𝔽] {m d : ℕ} {f g : (Fin m → 𝔽) → 𝔽},\n PCP.Algebraic.IsLowDegree d f →\n PCP.Algebraic.IsLowDegree d g → f ≠ g → 1 - ↑d / ↑(Fintype.card 𝔽) ≤ PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Fin", + "PCP.Algebraic.IsLowDegree", + "Ne", + "LE.le", + "Rat", + "Rat.instLE", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "OfNat.ofNat", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness with the strict outer degree required by the inner encoding. ", + "end_line": 134, + "is_class": false, + "kind": "theorem", + "line": 113, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : NeZero m]\n [CharP F 2] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree < m ^ c →\n ∀ (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P))))\n (PCP.Algebraic.EncodedLineLowDegreeTest.honestTable ρ P) s =\n true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "A valid one-hot block determines its represented source symbol uniquely. ", + "end_line": 95, + "is_class": false, + "kind": "theorem", + "line": 90, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.oneHot_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {a : ℕ} (x y : Fin a), (∀ (j : Fin a), decide (x = j) = decide (y = j)) → x = y", + "type_dependencies": [ + "Nat", + "Fin", + "Eq", + "Bool", + "Decidable.decide", + "instDecidableEqFin" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.boundary_represents._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} {c : tm.Cfg} (k : tm.K) (j : ℕ),\n ¬j < B → (c.stk k).length ≤ B → ¬(c.stk k).length ≤ j → False", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "Turing.FinTM2.K", + "Not", + "LT.lt", + "instLTNat", + "LE.le", + "instLENat", + "List.length", + "Turing.FinTM2.Γ", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 76, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → [DecidableEq V] → DecidableEq (PCP.Reduction.NAEThreeColor.Literal V)", + "type_dependencies": [ + "DecidableEq", + "PCP.Reduction.NAEThreeColor.Literal" + ], + "value_dependencies": [ + "DecidableEq", + "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A transition cell reads one prefix, one new cell, and the finite candidate old cells. ", + "end_line": 312, + "is_class": false, + "kind": "definition", + "line": 311, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.transitionWidth", + "provenance": "lean", + "structural_dependencies": [], + "type": "Turing.FinTM2 → ℕ", + "type_dependencies": [ + "Turing.FinTM2", + "Nat" + ], + "value_dependencies": [ + "Turing.FinTM2", + "HAdd.hAdd", + "Nat", + "instHAdd", + "instAddNat", + "PCP.Machine.FiniteTransitionTable.outputBound", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The §7 witness consists of a coloring extension and two bounded certificates. ", + "end_line": 160, + "is_class": false, + "kind": "theorem", + "line": 134, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (σ → ↥H)),\n G.Colorable 3 ↔\n ∃ P MVal MProp,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n MVal.totalDegree ≤ 3 * ((H.card - 1) * Fintype.card σ) ∧\n MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) ∧\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal ∧\n PCP.Algebraic.GridVanishing.IsCertificate H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P))\n MProp", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Fintype.card", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The source machine's proved stack-growth bound at that uniform time. ", + "end_line": 61, + "is_class": false, + "kind": "definition", + "line": 59, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.spacePoly", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} → PCP.Machine.NPTableau.Checker R → Polynomial ℕ → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "PCP.Machine.NPTableau.inputPoly", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "PCP.Machine.machinePushBound", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "PCP.Machine.NPTableau.timePoly" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (ctorIdx : ℕ) →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ctorIdx = t_1.ctorIdx → PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType ctorIdx → motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PULift.down", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "Eq.ndrec", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n {inst_3 : DecidableEq F} [inst_4 : DecidableEq F] (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (nodes nodes_1 : Fin (c + 1) → F),\n nodes = nodes_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (H H_1 : Finset F),\n H = H_1 →\n ∀ (p p_1 : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n p = p_1 →\n ∀\n (M M_1 :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n M = M_1 →\n ∀ (A A_1 : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n A = A_1 →\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p M A =\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ_1 nodes_1 ζ_1 H_1 p_1 M_1 A_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 24, + "is_class": false, + "kind": "theorem", + "line": 20, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "_private.PCP.Algebraic.ThreeColorParameterChoice.0.PCP.Algebraic.ThreeColorParameterChoice.exists_exponent", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), ∃ a, 2 ≤ a ∧ Nat.clog 2 N ≤ a * 2 ^ a", + "type_dependencies": [ + "Nat", + "Exists", + "And", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest polynomial oracles always return the requested homogeneous bit. ", + "end_line": 154, + "is_class": false, + "kind": "theorem", + "line": 130, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : NeZero m]\n [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree < m ^ c →\n ∀ (a b : σ → F) (z : Fˣ) (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P))))\n (PCP.Algebraic.BinaryLocalCorrection.honestTable ρ P a) a b z v w s =\n some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) w)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.run", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryLocalCorrection.honestTable", + "Option.some", + "PCP.Algebraic.Hadamard.linearEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.firstSlot.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {a d : ℕ} (j : Fin a),\n PCP.Reduction.FiniteDomainConstraints.firstSlot j = PCP.Reduction.FiniteDomainConstraints.slot ⟨0, ⋯⟩ j", + "type_dependencies": [ + "Nat", + "Fin", + "Eq", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.firstSlot", + "PCP.Reduction.FiniteDomainConstraints.slot", + "Fin.mk", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.FiniteDomainConstraints.firstSlot._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 46, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.test_pad", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorFullFieldSampling.test ρ nodes ζ H G π (PCP.Algebraic.ThreeColorFullFieldSampling.pad s) =\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorFullFieldSampling.test", + "PCP.Algebraic.ThreeColorFullFieldSampling.pad", + "PCP.Algebraic.ThreeColorVerifier.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A separate auxiliary table for each requested certificate point. ", + "end_line": 56, + "is_class": false, + "kind": "definition", + "line": 54, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.two_mul_nonzero_count._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a)", + "type_dependencies": [ + "DecidablePred", + "Finset", + "Eq", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.filter", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a)", + "type_dependencies": [ + "DecidablePred", + "Finset", + "Eq", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.filter", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.fieldIndex._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n NeZero (4 * (PCP.Algebraic.ThreeColorParameters.fieldIndex (PCP.Algebraic.ThreeColorParameterChoice.exponent N) + 1))", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorParameters.fieldIndex", + "PCP.Algebraic.ThreeColorParameterChoice.exponent" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.literalVertex.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (a : V) (a_1 : Bool),\n PCP.Reduction.NAEThreeColor.literalVertex (PCP.Reduction.NAEThreeColor.Literal.var a a_1) =\n PCP.Reduction.NAEThreeColor.variableVertex a a_1", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.literalVertex", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.variableVertex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.triangleWitness.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Bool → Bool → Bool → Sort u_1) (h_1 : Unit → motive false false true) (h_2 : Unit → motive true true false)\n (h_3 : (x : Bool) → motive false true x) (h_4 : (x x_1 x_2 : Bool) → motive x x_1 x_2),\n (match false, false, true with\n | false, false, true => h_1 ()\n | true, true, false => h_2 ()\n | false, true, x => h_3 x\n | x, x_1, x_2 => h_4 x x_1 x_2) =\n h_1 ()", + "type_dependencies": [ + "Bool", + "Unit", + "Bool.false", + "Bool.true", + "Eq", + "PCP.Reduction.NAEThreeColor.triangleWitness.match_1", + "Unit.unit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.honestTable.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : NeZero m]\n (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (P P_1 : MvPolynomial σ F),\n P = P_1 →\n ∀ (a a_1 : σ → F),\n a = a_1 →\n ∀ (b b_1 : σ → F),\n b = b_1 →\n ∀ (a_2 a_3 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c),\n a_2 = a_3 →\n ∀ (a_4 a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n a_4 = a_5 →\n PCP.Algebraic.BinaryLocalCorrection.honestTable ρ P a b a_2 a_4 =\n PCP.Algebraic.BinaryLocalCorrection.honestTable ρ_1 P_1 a_1 b_1 a_3 a_5", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "MvPolynomial", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.honestTable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.FiniteTransitionTable.prefixRow.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (tm : Turing.FinTM2) (c c_1 : tm.Cfg) (e_c : c = c_1) (hs : PCP.Machine.StackSupported tm c.stk),\n PCP.Machine.FiniteTransitionTable.prefixRow tm c hs = PCP.Machine.FiniteTransitionTable.prefixRow tm c_1 ⋯", + "type_dependencies": [ + "Turing.FinTM2", + "Turing.FinTM2.Cfg", + "Eq", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.ComputationTableau.Row", + "PCP.Machine.TM2Locality.machineWindow", + "PCP.Machine.FiniteTransitionTable.prefixRow", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.distance_expect", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : DecidableEq B] (k l : A → B),\n PCP.Algebraic.relativeDistance k l = Finset.univ.expect fun a => if k a ≠ l a then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "ite", + "Ne", + "instDecidableNot", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "constructor", + "line": 23, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Machine.Sym" + ], + "type": "Bool → PCP.Machine.Sym", + "type_dependencies": [ + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {t r : ℕ} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] (hr : 1 ≤ r)\n (H G : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr H G =\n PCP.Algebraic.relativeDistance (fun p => H p.1 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2)) fun p =>\n G p.1 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "PCP.Algebraic.relativeDistance", + "Prod", + "Fin", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryLagrangeConstraint.rowDistance._proof_1", + "ZMod.decidableEq", + "Prod.fst", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The only discrepancy from always returning the zero-parameter correction\nis actual rejection, exactly rather than merely as an upper bound. ", + "end_line": 135, + "is_class": false, + "kind": "theorem", + "line": 120, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.distance_sample_to_corrected", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a) fun s =>\n some (PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H (fun x => 0) s)) =\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "theorem", + "line": 29, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.exponent_ge_two", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 67, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β → ℚ),\n (PCP.Algebraic.BLR.average fun x => ∑ y, f x y) = ∑ y, PCP.Algebraic.BLR.average fun x => f x y", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.decodedLineError.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] {inst_2 : DecidableEq F} [inst_3 : DecidableEq F]\n (c c_1 : ℕ),\n c = c_1 →\n ∀ (f f_1 : (σ → F) → F),\n f = f_1 →\n ∀ (uv uv_1 : (σ → F) × (σ → F)),\n uv = uv_1 →\n PCP.Algebraic.PointLineTest.decodedLineError c f uv =\n PCP.Algebraic.PointLineTest.decodedLineError c_1 f_1 uv_1", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Prod", + "Rat", + "PCP.Algebraic.PointLineTest.decodedLineError" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.input.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (x w : List Bool),\n PCP.Machine.NPTableau.input h x w = List.map (⇑h.inputAlphabet.symm) (PCP.Machine.encodePair (x, w))", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Eq", + "Turing.FinTM2.Γ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.k₀", + "PCP.Machine.NPTableau.input", + "List.map", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "Turing.TM2ComputableAux.inputAlphabet", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "A fixed finite table supplies the clause triangle's colors. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool → Bool → Bool → Fin 3 → Fin 3", + "type_dependencies": [ + "Bool", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat" + ], + "value_dependencies": [ + "Bool", + "PCP.Reduction.NAEThreeColor.triangleWitness.match_1", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Unit", + "Matrix.vecCons", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1", + "Matrix.vecEmpty" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), PCP.Machine.Sym.bit b = PCP.Machine.Sym.sep → False", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.properPolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (E Q : MvPolynomial σ F),\n PCP.Algebraic.ThreeColorGrid.properPolynomial E Q = E * PCP.Algebraic.ThreeColorGrid.validPolynomial Q", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.ThreeColorGrid.validPolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 144, + "is_class": false, + "kind": "theorem", + "line": 136, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.degreeOf_assemble_zero_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {k : ℕ} (v : Fin (k + 1) → Polynomial F),\n MvPolynomial.degreeOf 0 (PCP.Algebraic.BerlekampWelchCertificate.assemble v) ≤ k", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.degreeOf", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BerlekampWelchCertificate.assemble" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "An actual query to one of the eight physical tables. ", + "end_line": 136, + "is_class": false, + "kind": "inductive", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "A three-literal OR splits into two not-all-equal clauses with one fresh bit. ", + "end_line": 70, + "is_class": false, + "kind": "theorem", + "line": 65, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.or_iff_two_nae", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b c : Bool),\n a = true ∨ b = true ∨ c = true ↔\n ∃ z, PCP.Reduction.NAEThreeColor.NAE ![a, b, z] ∧ PCP.Reduction.NAEThreeColor.NAE ![!z, c, false]", + "type_dependencies": [ + "Bool", + "Iff", + "Or", + "Eq", + "Bool.true", + "Exists", + "And", + "PCP.Reduction.NAEThreeColor.NAE", + "Matrix.vecCons", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Matrix.vecEmpty", + "Bool.not", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "constructor", + "line": 37, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n (PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), PCP.Machine.Sym.sep = PCP.Machine.Sym.bit b → False", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.bit", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n (ctorIdx : ℕ) →\n {a : ℕ} → (t : PCP.QueryTree a) → ctorIdx = t.ctorIdx → PCP.QueryTree.ctorElimType ctorIdx → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "PCP.QueryTree.ctorElimType" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "PCP.QueryTree.ctorElimType", + "PCP.QueryTree.casesOn", + "Bool", + "PULift.down", + "PCP.QueryTree.leaf", + "Eq.ndrec", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete list certifies a constant number of bit queries for fixed `c`. ", + "end_line": 368, + "is_class": false, + "kind": "theorem", + "line": 361, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n (PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s).length ≤ 20 * c + 107", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "PCP.QueryTree.addresses.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 201, + "is_class": false, + "kind": "theorem", + "line": 183, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.distance_point_bits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t r : ℕ} [inst_1 : Fintype F] [inst_2 : Fintype σ]\n [inst_3 : DecidableEq σ] {A : Type u_3} [inst_4 : DecidableEq A] (k l : (σ → F) → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1) s.2.2.1.2) fun s =>\n l (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1) s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "theorem", + "line": 130, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.color_literalVertex", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (a : V → Bool)\n (l : PCP.Reduction.NAEThreeColor.Literal V),\n PCP.Reduction.NAEThreeColor.color Q a (PCP.Reduction.NAEThreeColor.literalVertex l) =\n PCP.Reduction.NAEThreeColor.boolColor (PCP.Reduction.NAEThreeColor.Literal.eval a l)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.color", + "PCP.Reduction.NAEThreeColor.literalVertex", + "PCP.Reduction.NAEThreeColor.boolColor", + "PCP.Reduction.NAEThreeColor.Literal.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.digit.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (k k_1 : ℕ),\n k = k_1 → ∀ (i i_1 : ℕ), i = i_1 → PCP.Algebraic.digit m k i = PCP.Algebraic.digit m k_1 i_1", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Fin", + "PCP.Algebraic.digit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 140, + "is_class": false, + "kind": "definition", + "line": 140, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.natDegree_axisRestrict_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {σ : Type u_1} (i : σ) (s : σ →₀ ℕ), ¬s i ≤ s i → False", + "type_dependencies": [ + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Not", + "LE.le", + "instLENat", + "DFunLike.coe", + "Finsupp.instFunLike", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Theorem 4.1 at inflated outer degree `c*m^c`, for the actual tester and arbitrary\nauxiliary answers. The only rejection restriction is the explicit final threshold.\nThe second distance is over homogeneous degree-one labels, not all affine ones. ", + "end_line": 359, + "is_class": false, + "kind": "theorem", + "line": 322, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.exists_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] [CharP F 2] [NeZero m],\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ≤\n PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ c * m ^ c ∧\n PCP.Algebraic.relativeDistance (fun p => f p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ ((MvPolynomial.eval x) P)) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P)))) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "Rat.instMul", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.queries_length_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n (PCP.Algebraic.BinaryLowDegreeTest.queries ⋯ ρ nodes s).length ≤ max (2 * 1 + 4) (c + 2) →\n ¬(PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.BinaryLocalCorrection.run._proof_2 ρ nodes s).length +\n (c + 1) +\n (c + 1) +\n 1 ≤\n 3 * c + 9 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "LE.le", + "instLENat", + "List.length", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "Max.max", + "Nat.instMax", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.proofOracle.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool)\n (w : PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x))\n (i : ℕ),\n PCP.Algebraic.ThreeColorCanonicalVerifier.proofOracle x w i =\n if h :\n i <\n PCP.Algebraic.ThreeColorBinaryVerifier.proofLength\n (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x) then\n PCP.Algebraic.BinarySeedPadding.boolEquiv.symm (w ⟨i, h⟩)\n else false", + "type_dependencies": [ + "List", + "Bool", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "Nat", + "Eq", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofOracle", + "dite", + "LT.lt", + "instLTNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Nat.decLt", + "DFunLike.coe", + "Equiv", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.BinarySeedPadding.boolEquiv", + "Fin.mk", + "Not", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 204, + "is_class": false, + "kind": "definition", + "line": 204, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Fintype F] → {m c t : ℕ} → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Fintype", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Fintype", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 40, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.series_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommRing R] {k : ℕ}, Function.Injective PCP.Algebraic.BerlekampWelchCertificate.series", + "type_dependencies": [ + "CommRing", + "Nat", + "Function.Injective", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.BerlekampWelchCertificate.series" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A most frequent value, with arbitrary ties. ", + "end_line": 42, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.Plurality.value", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {A : Type u_2} → [Fintype R] → [Finite A] → [Nonempty A] → [DecidableEq A] → (R → A) → A", + "type_dependencies": [ + "Fintype", + "Finite", + "Nonempty", + "DecidableEq" + ], + "value_dependencies": [ + "Fintype", + "Finite", + "Nonempty", + "DecidableEq", + "Exists.choose", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.Plurality.exists_minimizer" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Grid vanishing may be tested using coordinatewise subtypes. ", + "end_line": 88, + "is_class": false, + "kind": "theorem", + "line": 83, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.vanishesOn_iff_grid", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (H : Finset F) (P : MvPolynomial σ F),\n PCP.Algebraic.GridVanishing.VanishesOn H P ↔ ∀ (a : σ → ↥H), (MvPolynomial.eval fun i => ↑(a i)) P = 0", + "type_dependencies": [ + "Field", + "Finset", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Iff", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The concrete two-corrector binary grid check. ", + "end_line": 71, + "is_class": false, + "kind": "definition", + "line": 63, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n ((Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t →\n PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t → Option (ZMod 2 × ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "Option", + "Prod" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check._proof_1", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The answer depends only on the stated two queries. ", + "end_line": 55, + "is_class": false, + "kind": "theorem", + "line": 47, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.answer_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (hP : P.natDegree ≤ r) (H G : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (R : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n (∀ q ∈ PCP.Algebraic.HadamardDerivedOracle.queries ρ P hP L R, H q = G q) →\n PCP.Algebraic.HadamardDerivedOracle.answer ρ P hP H L R = PCP.Algebraic.HadamardDerivedOracle.answer ρ P hP G L R", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.HadamardDerivedOracle.queries", + "Eq", + "PCP.Algebraic.HadamardDerivedOracle.answer" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 49, + "is_class": false, + "kind": "definition", + "line": 49, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "ZMod", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 87, + "is_class": false, + "kind": "theorem", + "line": 85, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.averageRejectionRate_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {t r : ℕ} [inst : Fintype ι] (hr : 1 ≤ r) (x : ι → Fin t → ZMod 2),\n (PCP.Algebraic.Hadamard.averageRejectionRate hr fun i => ⇑(PCP.Algebraic.Hadamard.encode r (x i))) = 0", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.Hadamard.averageRejectionRate", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 164, + "is_class": false, + "kind": "definition", + "line": 164, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.evaluationPoint.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ) (x : R) (ij : PCP.Algebraic.SetMultilinear.Variables m c),\n PCP.Algebraic.SetMultilinear.evaluationPoint m c x ij = x ^ (↑ij.2 * m ^ ↑ij.1)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "PCP.Algebraic.SetMultilinear.Variables", + "Eq", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V))\n (PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg_1 : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R)\n (polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)),\n ({ PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 }) =\n (PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1)", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 205, + "is_class": false, + "kind": "definition", + "line": 205, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeCallSeedSumFin_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [Fintype F] →\n [DecidableEq F] →\n {n m c t : ℕ} → Fintype (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instDecidableEqSum", + "instDecidableEqFin", + "instFintypeSum", + "Fin.fintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} [inst : Field F] {m c t : ℕ} {σ : Type u_1}\n (x : (Fin t → ZMod 2) × PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t),\n ((x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).2.2.1.2, (x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).1,\n (x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).2.1, (x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).2.2.1.1,\n (x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).2.2.2) =\n ((x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).2.2.1.2, (x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).1,\n (x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).2.1, (x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).2.2.1.1,\n (x.2.1, x.2.2.1, (x.2.2.2.1, x.1), x.2.2.2.2).2.2.2)", + "type_dependencies": [ + "Field", + "Nat", + "Prod", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Prod.mk", + "Prod.snd", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Units" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Restrict the ordinary proof oracle to the actual finite algebraic word. ", + "end_line": 68, + "is_class": false, + "kind": "definition", + "line": 65, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : List Bool) →\n PCP.ProofOracle →\n PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x)", + "type_dependencies": [ + "List", + "Bool", + "PCP.ProofOracle", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.ProofOracle", + "PCP.Algebraic.ThreeColorCanonicalVerifier.fieldWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "PCP.QueryTree.wordOfOracle", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The corrected comparison bit. ", + "end_line": 46, + "is_class": false, + "kind": "definition", + "line": 42, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n F →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Claim 7.3 with explicit errors and a strict polynomial-distance threshold.\nThe two proximity premises concern exactly the homogeneous queries used by the check. ", + "end_line": 315, + "is_class": false, + "kind": "theorem", + "line": 295, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.eq_differencePolynomial_of_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n {t r D : ℕ} [inst_4 : Algebra (ZMod 2) F] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (P : MvPolynomial σ F)\n (Q : MvPolynomial (σ ⊕ σ) F),\n P.totalDegree ≤ D →\n Q.totalDegree ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (g : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) {η εf εg : ℚ},\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr f g ≤ η →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P)))) ≤\n εf →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr g fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) Q)))) ≤\n εg →\n η + 2 * εf + εg < (1 - ↑D / ↑(Fintype.card F)) / 2 →\n Q = PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Algebra", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "MvPolynomial.totalDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instFintypeSum", + "instDecidableEqSum", + "LT.lt", + "Rat.instLT", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "Field.toCommRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Fixed graph outputs also have a concrete machine certificate, including the rejecting case. ", + "end_line": 164, + "is_class": false, + "kind": "theorem", + "line": 155, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.polyTimeMap_constant", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (s : List Bool), PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits fun x => s", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.timePoly.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ),\n PCP.Machine.NPTableau.timePoly h q = h.time.comp (PCP.Machine.NPTableau.inputPoly q)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "PCP.Machine.NPTableau.timePoly", + "Polynomial.comp", + "Turing.TM2ComputableInPolyTime.time", + "Prod", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "PCP.Machine.NPTableau.inputPoly" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 133, + "is_class": false, + "kind": "theorem", + "line": 131, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.colorable_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ} (R : C → (Fin d → Fin a) → Bool) (s : C → Fin d → V),\n (PCP.Reduction.FiniteDomainConstraints.graph R s).Colorable 3 ↔ ∃ x, PCP.Reduction.FiniteDomainConstraints.Holds R s x", + "type_dependencies": [ + "Nat", + "Fin", + "Bool", + "Iff", + "SimpleGraph.Colorable", + "PCP.Reduction.NAEThreeColor.Vertex", + "Sum", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "Prod", + "PCP.Reduction.FiniteDomainConstraints.graph", + "OfNat.ofNat", + "instOfNatNat", + "Exists", + "PCP.Reduction.FiniteDomainConstraints.Holds" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 75, + "is_class": false, + "kind": "theorem", + "line": 71, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_digitMonomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n (PCP.Algebraic.SetMultilinear.decode m c) (PCP.Algebraic.SetMultilinear.digitMonomial m c k) =\n Polynomial.X ^ (k % m ^ c)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.X", + "HMod.hMod", + "instHMod", + "Nat.instMod", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodeTriple._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (t : List Bool × List Bool × List Bool),\n ¬t.1.length + (t.2.1.length + (t.2.2.length + 1) + 1) = t.1.length + t.2.1.length + t.2.2.length + 2 → False", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Not", + "Eq", + "Nat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Unused seeds make no reads; valid seeds use exactly the original queries. ", + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t →\n List (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorFullFieldSampling.test._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "PCP.Algebraic.ThreeColorFullFieldSampling.test.match_1", + "Option", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorFullFieldSampling.decode", + "Unit", + "List.nil", + "PCP.Algebraic.ThreeColorVerifier.queries" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {t t' : PCP.Machine.Sym} → t = t' → PCP.Machine.Sym.noConfusionType P t t'", + "type_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "PCP.Machine.Sym.noConfusionType" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Eq.ndrec", + "PCP.Machine.Sym.noConfusionType", + "PCP.Machine.Sym.casesOn", + "Bool", + "Eq.refl" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.oracleOfWitness.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (w : List Bool) (j : ℕ), PCP.oracleOfWitness w j = w.getD j false", + "type_dependencies": [ + "List", + "Bool", + "Nat", + "Eq", + "PCP.oracleOfWitness", + "List.getD", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (u v : σ → F) (f g : (σ → F) → F),\n (∀ x ∈ PCP.Algebraic.GeneratorLowDegreeTest.queries c ζ u v, f x = g x) →\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v = PCP.Algebraic.GeneratorLowDegreeTest.check c ζ g u v", + "type_dependencies": [ + "Field", + "Nat", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A supplied coarse approximation sharpens to the `4ε` bivariate agreement bound. ", + "end_line": 117, + "is_class": false, + "kind": "theorem", + "line": 104, + "module": "PCP.Algebraic.BivariateAgreementBoost", + "name": "PCP.Algebraic.BivariateAgreementBoost.distance_le_four_mul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (f : F × F → F)\n (R C : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n (∀ (x : F), (C x).natDegree ≤ d) →\n ∀ (P : MvPolynomial (Fin 2) F),\n (∀ (j : Fin 2), MvPolynomial.degreeOf j P ≤ d) →\n ∀ {ε ρ : ℚ},\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.1 (R z.2)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.2 (C z.1)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => (MvPolynomial.eval ![z.1, z.2]) P) ≤ ρ →\n ρ + ε + 2 * (↑d / ↑(Fintype.card F)) ≤ 1 / 3 →\n (PCP.Algebraic.relativeDistance f fun z => (MvPolynomial.eval ![z.1, z.2]) P) ≤ 4 * ε", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Prod", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial.degreeOf", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "theorem", + "line": 48, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.scope_inputSlot", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ} (s : C → Fin d → V) (e : C) (i : Fin d) (j : Fin a),\n PCP.Reduction.FiniteDomainConstraints.scope s (Sum.inl e) (PCP.Reduction.FiniteDomainConstraints.inputSlot i j) =\n (Sum.inl (s e i), j)", + "type_dependencies": [ + "Nat", + "Fin", + "Eq", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.scope", + "Sum.inl", + "PCP.Reduction.FiniteDomainConstraints.inputSlot", + "Prod.mk", + "Sum", + "Unit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateAgreementFromRectangle", + "name": "PCP.Algebraic.BivariateAgreementFromRectangle.exists_nearby_polynomial_one_ninth._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {I : Type u_1} [Fintype I] {d : ℕ}, d + 1 ≤ 10 * d → ¬0 < d → False", + "type_dependencies": [ + "Fintype", + "Nat", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.costPoly.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (k A C D : ℕ),\n PCP.Reduction.NPThreeColorRuntime.costPoly h q k A C D =\n Polynomial.C A * (2 * Polynomial.X + 1) ^ 2 +\n Polynomial.C C *\n (Polynomial.C A * (2 * Polynomial.X + 1) + PCP.Reduction.NPThreeColor.variablesPoly h q k +\n PCP.Reduction.NPThreeColor.constraintsPoly h q k +\n 1) ^\n 6 +\n Polynomial.C A * (2 * Polynomial.X + 1) +\n Polynomial.C D *\n (PCP.Reduction.NPThreeColor.variablesPoly h q k + PCP.Reduction.NPThreeColor.constraintsPoly h q k + 1) ^ 2 +\n 5", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "PCP.Reduction.NPThreeColorRuntime.costPoly", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatAtLeastTwo", + "Polynomial.instNatCast", + "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_1", + "Polynomial.X", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatNat", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_2" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instFintypeSym.match_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : PCP.Machine.Sym → Sort u_1) →\n (x : PCP.Machine.Sym) → ((a : Bool) → motive (PCP.Machine.Sym.bit a)) → (Unit → motive PCP.Machine.Sym.sep) → motive x", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "Unit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "Unit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "In particular the formal difference polynomial has perfect completeness. ", + "end_line": 116, + "is_class": false, + "kind": "theorem", + "line": 109, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.check_differencePolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (P : MvPolynomial σ F) (a b : σ → F) (w : Fin t → ZMod 2),\n PCP.Algebraic.BinaryDifferenceConsistency.check hr\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P))))\n (fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r\n (ρ ((MvPolynomial.eval x) (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)))))\n a b w =\n 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.check", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "Field.toCommRing", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 44, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.eval_coordinate_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ) (x : σ → R),\n x i ∈ H → (MvPolynomial.eval x) (PCP.Algebraic.GridVanishing.coordinate H i) = 0", + "type_dependencies": [ + "CommRing", + "Finset", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.GridVanishing.coordinate", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.digitExponents m c k = ∑ i, Finsupp.single (i, PCP.Algebraic.digit m k ↑i) 1", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitExponents", + "Finset.sum", + "Fin", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "Finsupp.single", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Public bitstrings and the language program use the same zero/one values. ", + "end_line": 125, + "is_class": false, + "kind": "theorem", + "line": 120, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.code_ofBits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool), PCP.Machine.LangSymbolBridge.code (PCP.Machine.ofBits x) = List.map Bool.toNat x", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "Nat", + "PCP.Machine.LangSymbolBridge.code", + "PCP.Machine.ofBits", + "List.map", + "Bool.toNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 193, + "is_class": false, + "kind": "theorem", + "line": 151, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : F → F),\n f 0 = 0 →\n (∀ (i : Fin (c + 1)), f (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i) = 0) →\n (∀ (v : F),\n PCP.Algebraic.WeightedConstraint.predict (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f 0 v =\n 0) →\n ∀ (x : F), f x = 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.WeightedConstraint.predict", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeTest.0.PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3)\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p))\n (h_2 :\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inr p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_2 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.totalDegree_mapCoefficients_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] (ℓ : F →ₗ[ZMod 2] ZMod 2)\n (q : MvPolynomial σ F), (PCP.Algebraic.HadamardComposition.mapCoefficients ℓ q).totalDegree ≤ q.totalDegree", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Algebra.toModule", + "Semiring.toModule", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.HadamardComposition.mapCoefficients" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 208, + "is_class": false, + "kind": "theorem", + "line": 206, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.normalize_base", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V)\n (f : (PCP.Reduction.NAEThreeColor.graph Q).Coloring (Fin 3)) (i : Fin 3),\n (PCP.Reduction.NAEThreeColor.normalize Q f) (PCP.Reduction.NAEThreeColor.base i) = i", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "Eq", + "DFunLike.coe", + "RelHom.instFunLike", + "SimpleGraph.Adj", + "SimpleGraph.completeGraph", + "PCP.Reduction.NAEThreeColor.normalize", + "PCP.Reduction.NAEThreeColor.base" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.check._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {F : Type u_2} →\n {n m c t : ℕ} →\n {t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t} →\n {F' : Type u_2} →\n {n' m' c' t' : ℕ} →\n {t'_1 : PCP.Algebraic.ThreeColorVerifier.Query F' n' m' c' t'} →\n F = F' →\n n = n' →\n m = m' →\n c = c' → t = t' → t_1 ≍ t'_1 → PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType P t_1 t'_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "HEq", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "HEq.refl", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 53, + "is_class": false, + "kind": "definition", + "line": 50, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} →\n (h : PCP.Machine.NPTableau.Checker R) →\n Polynomial ℕ →\n [DecidableEq h.tm.Λ] →\n [DecidableEq h.tm.σ] →\n [(k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)] →\n PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk →\n {k a : ℕ} → h.tm.K ≃ Fin k → PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a → List Bool → List Bool", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Reduction.NPTableauGraphLang.encode", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "PCP.Machine.NPCellConstraints.accepting_length_le" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness uses the two formal identities and imposes no shape restriction on `M`. ", + "end_line": 71, + "is_class": false, + "kind": "theorem", + "line": 61, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.IsCertificate.vanishesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] {H : Finset R} {p : MvPolynomial σ R} {M : MvPolynomial (σ ⊕ σ) R},\n PCP.Algebraic.GridVanishing.IsCertificate H p M → PCP.Algebraic.GridVanishing.VanishesOn H p", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.GridVanishing.VanishesOn" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.colorValue.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (ω : F) (i : Fin 3), PCP.Algebraic.ThreeColorAlgebra.colorValue ω i = ω ^ ↑i", + "type_dependencies": [ + "Field", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorAlgebra.colorValue", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.interpolate._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽], IsScalarTower 𝔽 𝔽 (AddMonoidAlgebra 𝔽 (σ →₀ ℕ))", + "type_dependencies": [ + "Field", + "IsScalarTower", + "AddMonoidAlgebra", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddMonoidWithOne.toAddMonoid", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "AddMonoidAlgebra.instAddMonoid", + "AddMonoidAlgebra.smulZeroClass" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 63, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.inY_C", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (a : F),\n PCP.Algebraic.BerlekampWelchCertificate.inY (Polynomial.C a) = MvPolynomial.C a", + "type_dependencies": [ + "Field", + "Eq", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "DFunLike.coe", + "RingHom", + "Polynomial", + "CommSemiring.toSemiring", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.BerlekampWelchCertificate.inY", + "Polynomial.C", + "MvPolynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The chosen grid has room for every vertex, not merely for the logarithm of its count. ", + "end_line": 55, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.size_le_grid_capacity", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n N ≤\n (PCP.Algebraic.ThreeColorParameters.grid (PCP.Algebraic.ThreeColorParameterChoice.exponent N)).card ^\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent N)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Finset.card", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorParameters.size" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The three chosen colors exhaust the solutions of the vertex equation. ", + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.cube_eq_one_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {ω : F},\n IsPrimitiveRoot ω 3 → ∀ (x : F), x ^ 3 = 1 ↔ ∃ i, PCP.Algebraic.ThreeColorAlgebra.colorValue ω i = x", + "type_dependencies": [ + "Field", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Iff", + "Eq", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Exists", + "Fin", + "PCP.Algebraic.ThreeColorAlgebra.colorValue" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instReprSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "Repr PCP.Machine.Sym", + "type_dependencies": [ + "Repr", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Repr.mk", + "PCP.Machine.Sym", + "PCP.Machine.instReprSym.repr" + ] + }, + { + "axioms": [], + "doc": "A \"proxy type\" equivalent to `PCP.Machine.Sym` that is constructed from `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum`. See `PCP.Machine.Sym.proxyTypeEquiv` for the equivalence. (Generated by the `proxy_equiv%` elaborator.)", + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.proxyType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "Sum", + "Bool", + "Unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.distance_correction_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] [inst_4 : Fintype F] [inst_5 : DecidableEq F] [inst_6 : Fintype V] (a w : I → F) (f : V → F),\n PCP.Algebraic.relativeDistance f (PCP.Algebraic.WeightedConstraint.correction a w f) ≤\n 2 * PCP.Algebraic.WeightedConstraint.rejectionRate a w f", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.WeightedConstraint.correction", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.WeightedConstraint.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : Bool → Sort u} → (t : Bool) → motive false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t", + "type_dependencies": [ + "Bool", + "Bool.false", + "Nat.hasNotBit", + "Bool.ctorIdx" + ], + "value_dependencies": [ + "Bool", + "Bool.false", + "Bool.rec", + "Nat.hasNotBit", + "Bool.ctorIdx", + "Bool.true", + "Nat.ne_of_beq_eq_false", + "Nat.land", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Nat.shiftRight", + "Eq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.rejectionProbability.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] [inst_1 : Add V] (H : V → ZMod 2),\n PCP.Algebraic.BLR.rejectionProbability H =\n PCP.Algebraic.relativeDistance (fun p => H (p.1 + p.2)) fun p => H p.1 + H p.2", + "type_dependencies": [ + "Fintype", + "Add", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.rejectionProbability", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "ZMod.decidableEq", + "HAdd.hAdd", + "instHAdd", + "Prod.fst", + "Prod.snd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 330, + "is_class": false, + "kind": "theorem", + "line": 322, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.exists_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ],\n 2 * c < Fintype.card F →\n ∀ {a : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes a →\n ∀ (f : (σ → F) → F) {δ : ℚ},\n PCP.Algebraic.FixedLagrangeConstraint.rejectionRate a f ≤ δ →\n δ < 1 / (2 * (↑c + 2) ^ 2) →\n ∃ P, P.totalDegree ≤ c ∧ (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤ 2 * δ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.checker_program_reduction._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Option (ZMod 2) → Option (ZMod 2) → Option (ZMod 2) → Sort u_1) (p m₀ mZ : ZMod 2)\n (h_1 : (p m₀ mZ : ZMod 2) → motive (some p) (some m₀) (some mZ))\n (h_2 : (x x_1 x_2 : Option (ZMod 2)) → motive x x_1 x_2),\n (match some p, some m₀, some mZ with\n | some p, some m₀, some mZ => h_1 p m₀ mZ\n | x, x_1, x_2 => h_2 x x_1 x_2) =\n h_1 p m₀ mZ", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_linearEncode._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 140, + "is_class": false, + "kind": "theorem", + "line": 138, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm_single", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (a : ι → ZMod 2) (i : ι),\n (PCP.Algebraic.BLR.linearForm a) (Pi.single i 1) = a i", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm", + "Pi.single", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodePair._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : List Bool × List Bool), ¬p.1.length + (p.2.length + 1) = p.1.length + p.2.length + 1 → False", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Not", + "Eq", + "Nat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → (n m c t : ℕ) → [SizeOf F] → SizeOf (PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "SizeOf.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_1" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.correct_distance_le._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.totalDegree_validPolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F),\n (PCP.Algebraic.ThreeColorGrid.validPolynomial P).totalDegree ≤ 3 * P.totalDegree", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.substitute Y = MvPolynomial.eval₂Hom MvPolynomial.C (Sum.elim MvPolynomial.X Y)", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.substitute", + "MvPolynomial.eval₂Hom", + "AddMonoidAlgebra.commSemiring", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "MvPolynomial.C", + "Sum.elim", + "MvPolynomial.X" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 192, + "is_class": false, + "kind": "theorem", + "line": 186, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.equations_of_kernel", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] {d e : ℕ} (a : I → F) (columns : I → Polynomial F)\n (v : PCP.Algebraic.BerlekampWelchMatrix.Unknowns d e → Polynomial F),\n (PCP.Algebraic.BerlekampWelchMatrix.matrix d e a columns).mulVec v = 0 →\n ∀ (i : I),\n PCP.Algebraic.PointLineCrossing.rowPolynomial\n (PCP.Algebraic.BerlekampWelchCertificate.assemble fun j => v (Sum.inl j)) (a i) =\n columns i *\n PCP.Algebraic.PointLineCrossing.rowPolynomial\n (PCP.Algebraic.BerlekampWelchCertificate.assemble fun j => v (Sum.inr j)) (a i)", + "type_dependencies": [ + "Field", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BerlekampWelchMatrix.Unknowns", + "Eq", + "Matrix.mulVec", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "Polynomial.commRing", + "Field.toCommRing", + "instFintypeSum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin.fintype", + "PCP.Algebraic.BerlekampWelchMatrix.matrix", + "Zero.toOfNat0", + "Pi.instZero", + "Polynomial.instZero", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "PCP.Algebraic.BerlekampWelchCertificate.assemble", + "Sum.inl", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "Sum.inr" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Fact 2.8, including the constant-polynomial identity. ", + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.correct_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ c →\n ∀ (u v : σ → F),\n PCP.Algebraic.StandardLocalCorrection.correct c ζ (fun x => (MvPolynomial.eval x) P) u v =\n (MvPolynomial.eval u) P", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "PCP.Algebraic.StandardLocalCorrection.correct", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : Type u_1) → [SizeOf V] → SizeOf (PCP.Reduction.NAEThreeColor.Literal V)", + "type_dependencies": [ + "SizeOf", + "PCP.Reduction.NAEThreeColor.Literal" + ], + "value_dependencies": [ + "SizeOf", + "SizeOf.mk", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 113, + "is_class": false, + "kind": "theorem", + "line": 112, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.nodes_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes ⇑(PCP.Algebraic.ThreeColorFields.nodes k)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "DFunLike.coe", + "Function.Embedding", + "Fin", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorFields.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every monomial contains exactly one variable from each block. The zero\npolynomial satisfies this condition because its support is empty. ", + "end_line": 174, + "is_class": false, + "kind": "definition", + "line": 171, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.IsSetMultilinear", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] → (m c : ℕ) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R → Prop", + "type_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial.support", + "Fin", + "Eq", + "Finset.sum", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "DFunLike.coe", + "Finsupp.instFunLike", + "Prod.mk", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False", + "type_dependencies": [ + "Mul", + "Zero", + "NoZeroDivisors", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Eq", + "HMul.hMul", + "instHMul", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (accept : Bool), sizeOf (PCP.QueryTree.leaf accept) = 1 + sizeOf d + sizeOf accept", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "SizeOf.sizeOf", + "PCP.QueryTree", + "PCP.QueryTree._sizeOf_inst", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "instSizeOfNat", + "Bool._sizeOf_inst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 118, + "is_class": false, + "kind": "theorem", + "line": 115, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.totalDegree_outputCoordinate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (i : Fin t), (PCP.Algebraic.HadamardComposition.outputCoordinate ρ P i).totalDegree ≤ P.natDegree", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.HadamardComposition.outputCoordinate", + "Polynomial.natDegree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "definition", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 4 →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Theorem 2.5 (large-field branch), in the pairwise distance form used for decoding. ", + "end_line": 55, + "is_class": false, + "kind": "theorem", + "line": 48, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.eval_distance_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] [inst_2 : DecidableEq 𝔽] {m d : ℕ}\n (p q : MvPolynomial (Fin m) 𝔽),\n p.totalDegree ≤ d →\n q.totalDegree ≤ d →\n p ≠ q →\n 1 - ↑d / ↑(Fintype.card 𝔽) ≤\n PCP.Algebraic.relativeDistance (fun x => (MvPolynomial.eval x) p) fun x => (MvPolynomial.eval x) q", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Ne", + "Rat", + "Rat.instLE", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "OfNat.ofNat", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {P_1 : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {t : PCP.NPCertificate P_1 L} →\n {P' : (List Bool → List Bool → Bool) → Prop} →\n {L' : PCP.Language} →\n {t' : PCP.NPCertificate P' L'} → P_1 = P' → L = L' → t ≍ t' → PCP.NPCertificate.noConfusionType P t t'", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Eq", + "HEq", + "PCP.NPCertificate.noConfusionType" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.NPCertificate.noConfusionType", + "PCP.NPCertificate.casesOn", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Bool.true", + "Eq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The random strings on which `V` accepts `x` given proof `π`. ", + "end_line": 99, + "is_class": false, + "kind": "definition", + "line": 97, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.acceptingRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : PCP.Verifier) → (x : List Bool) → PCP.ProofOracle → Finset (Fin (2 ^ V.randomness x.length))", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Finset", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Finset.filter", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Eq", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "Bool.true", + "instDecidableEqBool", + "Finset.univ", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.nodes._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ),\n Function.Injective (PCP.Algebraic.GeneratorLowDegreeTest.nodes 4 (PCP.Algebraic.ThreeColorFields.generator k))", + "type_dependencies": [ + "Nat", + "Function.Injective", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 215, + "is_class": false, + "kind": "theorem", + "line": 214, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.assignmentFinite", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (tm : Turing.FinTM2) (T B : ℕ), Finite (PCP.Machine.TableauCells.Assignment tm T B)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Finite", + "PCP.Machine.TableauCells.Assignment" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ) (i : Fin (c + 1)), ¬0 < ↑i + 1 + (n - (c + 1)) → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "LT.lt", + "instLTNat", + "Fin.val", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Query proof address `addr`, then continue in `onFalse` or `onTrue`. ", + "end_line": 37, + "is_class": false, + "kind": "constructor", + "line": 36, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query", + "provenance": "lean", + "structural_dependencies": [ + "PCP.QueryTree" + ], + "type": "{d : ℕ} → ℕ → PCP.QueryTree d → PCP.QueryTree d → PCP.QueryTree (d + 1)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 161, + "is_class": false, + "kind": "definition", + "line": 158, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3 →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine" + ] + }, + { + "axioms": [], + "doc": "An equivalence between the \"proxy type\" `PCP.Machine.Sym.proxyType` and `PCP.Machine.Sym`. The proxy type is a reducible definition that represents the inductive type using `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum` (and whatever other inductive types appear within the inductive type), and the intended use is to define typeclass instances uses pre-existing instances on these. (Generated by the `proxy_equiv%` elaborator.)", + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.proxyTypeEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool ⊕ Unit ≃ PCP.Machine.Sym", + "type_dependencies": [ + "Equiv", + "Sum", + "Bool", + "Unit", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Equiv.mk", + "Sum", + "Bool", + "Unit", + "PCP.Machine.Sym", + "PCP.Machine.instFintypeSym.match_3", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.instFintypeSym.match_5", + "Sum.inl", + "Sum.inr", + "Unit.unit", + "Sum.casesOn", + "Eq", + "Eq.ndrec", + "Eq.refl", + "Eq.symm", + "PCP.Machine.Sym.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (c : ℕ) (ζ : F) (i : Fin (c + 1)),\n PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i = ζ ^ (↑i + 1)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Both uses of inner correction, distinguished by the selected parameter. ", + "end_line": 112, + "is_class": false, + "kind": "definition", + "line": 108, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n (Fˣ → F) → PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All constraints are unary, binary, or the fixed-width individual transition checks. ", + "end_line": 223, + "is_class": false, + "kind": "definition", + "line": 217, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.Satisfies", + "provenance": "lean", + "structural_dependencies": [], + "type": "(tm : Turing.FinTM2) → (T B : ℕ) → tm.Cfg → tm.Cfg → PCP.Machine.TableauCells.Assignment tm T B → Prop", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Assignment" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Assignment", + "And", + "PCP.Machine.TableauCells.Boundary", + "Prod.fst", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Fin.instOfNat", + "PCP.Machine.TableauCells.Satisfies._proof_1", + "Prod.snd", + "PCP.Machine.TableauCells.Linked", + "PCP.Machine.TableauCells.Step", + "Fin.castSucc", + "Fin.succ", + "Fin.last" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All three checks must pass; the two tester seeds are independent. ", + "end_line": 57, + "is_class": false, + "kind": "definition", + "line": 48, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n 1 ≤ r →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool.and", + "PCP.Algebraic.Hadamard.test", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "Decidable.decide", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.fullDistance.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} {I : Type u_2} [inst_2 : Fintype I]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (H : I → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) (f : I → F),\n PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ H f =\n PCP.Algebraic.relativeDistance (fun iq => H iq.1 iq.2) fun iq => (PCP.Algebraic.Hadamard.encode r (ρ (f iq.1))) iq.2", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardDerivedOracle.answer._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "Rat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance._proof_1", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 256, + "is_class": false, + "kind": "theorem", + "line": 253, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_differenceCheckQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery q) =\n PCP.Algebraic.BinaryDifferenceConsistency.read π.color π.difference q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery", + "PCP.Algebraic.BinaryDifferenceConsistency.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The average is exactly rejection under a uniform row and an independent\nuniform sample of the existing Hadamard tester's randomness. ", + "end_line": 73, + "is_class": false, + "kind": "theorem", + "line": 65, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.averageRejectionRate_eq_relativeDistance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {t r : ℕ} [inst : Fintype ι] (hr : 1 ≤ r)\n (H : ι → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.averageRejectionRate hr H =\n PCP.Algebraic.relativeDistance (fun s => PCP.Algebraic.Hadamard.test hr (H s.1) s.2) fun x => true", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.Hadamard.averageRejectionRate", + "PCP.Algebraic.relativeDistance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "Bool", + "instFintypeProd", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "instDecidableEqBool", + "PCP.Algebraic.Hadamard.test", + "Prod.fst", + "Prod.snd", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBits_le_budget", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n PCP.Algebraic.ThreeColorBinaryVerifier.randomBits (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x) ≤\n PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget x.length", + "type_dependencies": [ + "List", + "Bool", + "LE.le", + "Nat", + "instLENat", + "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "List.length" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 249, + "is_class": false, + "kind": "theorem", + "line": 244, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ c →\n ∀ (u v : σ → F), PCP.Algebraic.GeneratorLowDegreeTest.check c ζ (fun x => (MvPolynomial.eval x) P) u v = 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every language in the repository's concrete NP model has the certified graph reduction. ", + "end_line": 207, + "is_class": false, + "kind": "theorem", + "line": 201, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.of_inNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language},\n PCP.InNP PCP.Machine.PolyTimeRel L →\n ∃ f p,\n PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits f ∧\n ∀ (x : List Bool),\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧ (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "List", + "Bool", + "Polynomial", + "Nat", + "Nat.instSemiring", + "And", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x x_1 : PCP.Machine.Sym) → Decidable (x = x_1)", + "type_dependencies": [ + "PCP.Machine.Sym", + "Decidable", + "Eq" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.instDecidableEqSym.decEq.match_1", + "Decidable", + "Eq", + "Bool", + "dite", + "PCP.Machine.Sym.bit", + "instDecidableEqBool", + "Eq.ndrec", + "Decidable.isTrue", + "PCP.Machine.instDecidableEqSym.decEq._proof_1", + "Not", + "Decidable.isFalse", + "PCP.Machine.instDecidableEqSym.decEq._proof_2", + "PCP.Machine.Sym.sep", + "PCP.Machine.instDecidableEqSym.decEq._proof_3", + "PCP.Machine.instDecidableEqSym.decEq._proof_4", + "Unit", + "rfl" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness.eq_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : Bool), PCP.Reduction.NAEThreeColor.triangleWitness false true x = ![1, 0, 2]", + "type_dependencies": [ + "Bool", + "Eq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.triangleWitness", + "Bool.false", + "Bool.true", + "Matrix.vecCons", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d),\n sizeOf (PCP.QueryTree.query addr onFalse onTrue) = 1 + sizeOf d + sizeOf addr + sizeOf onFalse + sizeOf onTrue", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "SizeOf.sizeOf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree._sizeOf_inst", + "PCP.QueryTree.query", + "instSizeOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (a : Fin (c + 1) → F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.FixedLagrangeConstraint.check a f u v = PCP.Algebraic.LagrangeConstraint.check a f u v 0", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.FixedLagrangeConstraint.check", + "PCP.Algebraic.LagrangeConstraint.check", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Rejection against the actual nearest line polynomials at one fixed parameter. ", + "end_line": 57, + "is_class": false, + "kind": "definition", + "line": 54, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.rejectionAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} → [Field F] → [Fintype F] → [DecidableEq F] → [Fintype σ] → [DecidableEq σ] → ℕ → ((σ → F) → F) → F → ℚ", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Rat" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "Prod.snd", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Subtype.val", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.decodedTable" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness uses fresh primary randomness and the actual received certificate proof.\nThe replacement loss is explicitly multiplied by the existing grid-soundness coefficient. ", + "end_line": 277, + "is_class": false, + "kind": "theorem", + "line": 244, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate_lower_bound", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [NeZero m] [CharP F 2] {D : ℕ},\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r)\n {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (f : (Fin n → F) → F) (P : MvPolynomial (Fin n) F),\n (∀ (x : Fin n → F), Polynomial.eval (f x) (Q x) = (MvPolynomial.eval x) P) →\n ∀ (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ p f ≤ δP →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δM →\n (1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 ≤\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) *\n (PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ Q hQ nodes ζ H p M' A +\n 2 * δP) +\n 2 * δM +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Eq", + "Polynomial.eval", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "instFintypeSum", + "instDecidableEqSum", + "le_refl", + "Nat.instPreorder", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {P_1 : Sort u} →\n {witnessBound : Polynomial ℕ} →\n {check : List Bool → List Bool → Bool} →\n {check_polyTime : P check} →\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true} →\n {witnessBound' : Polynomial ℕ} →\n {check' : List Bool → List Bool → Bool} →\n {check_polyTime' : P check'} →\n {spec' :\n ∀ (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound' ∧ check' x w = true} →\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound', check := check', check_polyTime := check_polyTime',\n spec := spec' } →\n (witnessBound = witnessBound' → check = check' → P_1) → P_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk", + "id", + "PCP.NPCertificate.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Only the difference-table point is pulled back through the coordinate equivalence. ", + "end_line": 178, + "is_class": false, + "kind": "definition", + "line": 174, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "Function.comp", + "Sum", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "Prod.mk", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type (max u_2 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1) →\n ((x : Fin (n + n) ⊕ Fin (n + n) → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin (n + n) ⊕ Fin (n + n))) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [inst : Fintype F], 1 < Fintype.card F → Fintype.card F - 1 = 0 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Line, full-field parameter, correction direction and label, and both test seeds. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → ℕ → Type (max (max u_4 u_3) u_3)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A fixed positive repetition count, independent of every input and proof. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "PCP.Algebraic.RationalRepetitionBound.repetitions", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n PCP.Algebraic.SetMultilinear.boundedEncode m c d = PCP.Algebraic.SetMultilinear.boundedEncode m c d", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Subtype", + "Polynomial", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.boundedEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 166, + "is_class": false, + "kind": "definition", + "line": 166, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeCallSeedSumFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] → Fintype (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instDecidableEqSum", + "instDecidableEqFin", + "instFintypeSum", + "Fin.fintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 195, + "is_class": false, + "kind": "theorem", + "line": 189, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.linked_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} (c : tm.Cfg) (hs : PCP.Machine.StackSupported tm c.stk),\n (∀ (k : tm.K), (c.stk k).length ≤ B) →\n PCP.Machine.TableauCells.Linked (PCP.Machine.FiniteTransitionTable.prefixRow tm c hs)\n (PCP.Machine.TableauCells.encodeCells B c hs)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "LE.le", + "instLENat", + "List.length", + "PCP.Machine.TableauCells.Linked", + "PCP.Machine.FiniteTransitionTable.prefixRow", + "PCP.Machine.TableauCells.encodeCells" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate_ge_of_not_colorable._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V],\n 5 *\n (((PCP.Algebraic.ThreeColorParameters.grid\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))).card -\n 1) *\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))) <\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)) ^ 4 →\n ¬((PCP.Algebraic.ThreeColorParameters.grid\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))).card -\n 1) *\n PCP.Algebraic.ThreeColorParameters.size\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)) ≤\n 4 *\n PCP.Algebraic.ThreeColorParameters.size\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)) ^\n 4 →\n False", + "type_dependencies": [ + "Fintype", + "LT.lt", + "Nat", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Fintype.card", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorParameters.size", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "LE.le", + "instLENat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "A decision tree over a Boolean proof oracle, of depth at most `d`.\n\n`leaf` may occur at any depth, so `QueryTree d` is \"at most `d` queries\", not \"exactly `d`\". ", + "end_line": 37, + "is_class": false, + "kind": "inductive", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree", + "provenance": "lean", + "structural_dependencies": [ + "PCP.QueryTree.leaf", + "PCP.QueryTree.query", + "PCP.QueryTree" + ], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validGridQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3) →\n ((x : Fin n → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((fst : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n) →\n (x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (fst, Sum.inl (x, q)))) →\n ((a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n) →\n (b : Fin n ⊕ Fin n → F) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr (a, Sum.inr (b, x, q)))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The bit comparison is tested even when either consistency check also fails. ", + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.comparison_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H) fun s =>\n f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2.2.1.2)) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "ZMod.decidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.PolynomialLine.point", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness: a polynomial-time verifier algorithm is computable. This rules out a degenerate\nmodel that counts an arbitrary, even noncomputable, step function as efficient; such a model\nwould let a \"verifier\" decide the language outright. ", + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 89, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.polyTimeAlg_computable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (self : PCP.CostModel) (alg : PCP.VerifierAlg), self.PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2", + "type_dependencies": [ + "PCP.CostModel", + "PCP.VerifierAlg", + "PCP.CostModel.PolyTimeAlg", + "Computable", + "Prod", + "List", + "Bool", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.list", + "Primcodable.bool", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.agreementError.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.PointLineConstants.agreementError = 1 / 100", + "type_dependencies": [ + "Eq", + "Rat", + "PCP.Algebraic.PointLineConstants.agreementError", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder_le_length", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool), PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x ≤ x.length", + "type_dependencies": [ + "List", + "Bool", + "LE.le", + "Nat", + "instLENat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "List.length" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Claim 3.7 supplies one query that works simultaneously for every input. ", + "end_line": 182, + "is_class": false, + "kind": "theorem", + "line": 176, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.exists_query", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n P.natDegree ≤ r →\n ∃ Λ,\n ∀ (u : F),\n (PCP.Algebraic.Hadamard.encode r (ρ u)) Λ = (PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval u P))) L", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Exists", + "Eq", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_linearEncode._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b ≠ 0) = (a ≠ b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "Ne", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "Eq", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → [SizeOf F] → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.rec", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False", + "type_dependencies": [ + "Zero", + "OfNat", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "NeZero", + "Eq", + "Zero.toOfNat0", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n (PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t)\n (s : PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.check ρ nodes ζ H p M A s =\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck\n (some\n (p s.1\n ((PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.BinaryZeroOnGridCorrection.check._proof_1) s.2.1)))\n (PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M (A (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1))\n (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1) s.2.1 s.2.2.1)\n (PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M\n (A (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)) (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)\n s.2.1 s.2.2.2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "Prod.fst", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check._proof_1", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.boundary_represents._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {B : ℕ} (j : ℕ), ¬j < B → ¬B ≤ j → False", + "type_dependencies": [ + "Nat", + "Not", + "LT.lt", + "instLTNat", + "LE.le", + "instLENat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "The logarithmic parameter volume controlling later resource exponents. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.read.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {t r : ℕ} (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (g : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n PCP.Algebraic.BinaryDifferenceConsistency.read f g (Sum.inl p) = f p.1 p.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Sum", + "Prod", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.read", + "Sum.inl", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.rowPolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (P : MvPolynomial (Fin 2) F) (x : F),\n PCP.Algebraic.PointLineCrossing.rowPolynomial P x = (PCP.Algebraic.PointLineCrossing.axisRestrict ![x, 0] 1) P", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.PointLineCrossing.axisRestrict", + "instDecidableEqFin", + "Matrix.vecCons", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "Matrix.vecEmpty", + "Fin.instOfNat", + "PCP.Algebraic.PointLineCrossing.rowPolynomial._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest rejection is zero under exactly the finite sampling used by the tester. ", + "end_line": 164, + "is_class": false, + "kind": "theorem", + "line": 157, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : NeZero m]\n [CharP F 2] [inst_4 : Fintype F] [inst_5 : Fintype σ] [inst_6 : DecidableEq σ] (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree < m ^ c →\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P))))\n (PCP.Algebraic.EncodedLineLowDegreeTest.honestTable ρ P) =\n 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Eq", + "Rat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same bound stated using the received point oracle's exact homogeneous distance. ", + "end_line": 331, + "is_class": false, + "kind": "theorem", + "line": 315, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {D : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a)\n fun s => some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2.2.1.2)) ≤\n (PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a +\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Prod.snd", + "Prod.fst", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.Hadamard.encode", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Equation (3.1): the point at which the encoded polynomial recovers `P(λ)`. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 62, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.evaluationPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → [CommSemiring R] → (m c : ℕ) → R → PCP.Algebraic.SetMultilinear.Variables m c → R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "PCP.Algebraic.SetMultilinear.Variables", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The decision tree used on input `x` and random string `r`. ", + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 91, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.run", + "provenance": "lean", + "structural_dependencies": [], + "type": "(self : PCP.Verifier) → (x : List Bool) → Fin (2 ^ self.randomness x.length) → PCP.QueryTree self.queries", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.queries" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.satisfies_represents._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {T : ℕ} {B : ℕ} {initial : tm.Cfg} (j : ℕ), j + 1 < T + 1 → ¬j < T + 1 → False", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "LT.lt", + "instLTNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "With small rejection, the actual all-parameter correction is an ordinary\ntotal-degree-bounded polynomial in every finite dimension. ", + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.PointLineTest.exists_polynomial_correction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {d : ℕ},\n 0 < d →\n PCP.Algebraic.PointLineConstants.fieldFactor * d ^ 3 ≤ Fintype.card F →\n ∀ (f : (σ → F) → F),\n PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable d f) ≤\n PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ d ∧\n ∀ (x : σ → F),\n (MvPolynomial.eval x) P =\n PCP.Algebraic.PointLineTest.correction (PCP.Algebraic.PointLineTest.decodedTable d f) x", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineTest.decodedTable", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "MvPolynomial.totalDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.PointLineTest.correction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 219, + "is_class": false, + "kind": "theorem", + "line": 216, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_validQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.validQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.validCert π.validLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.validQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Original relations and one one-hot validity constraint per source variable. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.Constraint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → Type (max u_4 u_3)", + "type_dependencies": [], + "value_dependencies": [ + "Sum" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.var.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a : V) (a_1 : Bool) (a_2 : V) (a_3 : Bool),\n (PCP.Reduction.NAEThreeColor.Literal.var a a_1 = PCP.Reduction.NAEThreeColor.Literal.var a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.var", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every concrete NP certificate yields the finite tableau characterization. ", + "end_line": 168, + "is_class": false, + "kind": "theorem", + "line": 163, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.of_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language} (cert : PCP.NPCertificate PCP.Machine.PolyTimeRel L),\n ∃ h, ∀ (x : List Bool), L x ↔ ∃ a, PCP.Machine.NPTableau.Accepts h cert.witnessBound x a", + "type_dependencies": [ + "PCP.Language", + "PCP.NPCertificate", + "PCP.Machine.PolyTimeRel", + "Exists", + "PCP.Machine.NPTableau.Checker", + "PCP.NPCertificate.check", + "List", + "Bool", + "Iff", + "PCP.Machine.NPTableau.Assignment", + "PCP.NPCertificate.witnessBound", + "PCP.Machine.NPTableau.Accepts" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Check the actual machine's initial, adjacent and accepting final configurations. ", + "end_line": 115, + "is_class": false, + "kind": "definition", + "line": 112, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.Accepts", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} →\n (h : PCP.Machine.NPTableau.Checker R) →\n (q : Polynomial ℕ) → (x : List Bool) → PCP.Machine.NPTableau.Assignment h q x → Prop", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "PCP.Machine.NPTableau.Assignment" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "PCP.Machine.NPTableau.Assignment", + "PCP.Machine.ComputationTableau.Satisfies", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "PCP.Machine.NPTableau.input", + "PCP.Machine.NPTableau.witnessList", + "PCP.Machine.NPTableau.BoundedWitness", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.ComputationTableau.Row", + "PCP.Machine.NPTableau.output", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The sum of both local-correction losses and the two direct rejection losses. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HAdd.hAdd", + "Rat", + "instHAdd", + "Rat.instAdd", + "OfNat.ofNat", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "instAddNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.Satisfies._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (T : ℕ), NeZero (T + 1)", + "type_dependencies": [ + "Nat", + "NeZero", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A colorable graph has zero rejection under the actual complete finite seed. ", + "end_line": 141, + "is_class": false, + "kind": "theorem", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_rejectionRate_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [NeZero m] [CharP F 2]\n [inst_4 : Fintype F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n G.Colorable 3 →\n 5 * ((H.card - 1) * n) < m ^ c →\n ∃ π, PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π = 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "SimpleGraph.Colorable", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Exists", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "Classical.propDecidable", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.var.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {a : V} {a_1 : Bool} {a_2 : V} {a_3 : Bool},\n PCP.Reduction.NAEThreeColor.Literal.var a a_1 = PCP.Reduction.NAEThreeColor.Literal.var a_2 a_3 → a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.var", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "theorem", + "line": 34, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.le_volume", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), Nat.clog 2 N ≤ PCP.Algebraic.ThreeColorParameterChoice.volume N", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.volume" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval_congr._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x)\n (f :\n PCP.QueryTree.below (motive := fun x x_2 =>\n ∀ (x_3 x_4 : PCP.ProofOracle), (∀ a ∈ x_2.addresses, x_3 a = x_4 a) → x_2.eval x_3 = x_2.eval x_4) x_1)\n (x_2 x_3 : PCP.ProofOracle), (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → x_1.eval x_2 = x_1.eval x_3", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.eval" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.eval", + "PCP.QueryTree.eval_congr.match_1_1", + "PCP.QueryTree.leaf", + "rfl", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "of_eq_true", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "Eq.trans", + "Or", + "True", + "Finset.mem_insert._simp_1", + "congr", + "congrArg", + "eq_self", + "Finset.mem_union._simp_1", + "true_or", + "PProd", + "Eq.mpr", + "id", + "Iff.mpr", + "Not", + "Classical.or_iff_not_imp_left", + "False.elim", + "ite", + "Bool.true", + "instDecidableEqBool", + "congrFun'", + "ite_congr" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 88, + "is_class": false, + "kind": "definition", + "line": 88, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.base", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → {C : Type u_2} → Fin 3 → PCP.Reduction.NAEThreeColor.Vertex V C", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Vertex" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The combined exceptional-event budget leaves a positive probability of a good ruled surface. ", + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 61, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.rigidity_budget", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {q : ℕ},\n 1000000 ≤ q →\n ∀ {δ : ℚ},\n δ ≤ PCP.Algebraic.PointLineConstants.smallError →\n (2 * (PCP.Algebraic.PointLineConstants.endpointError δ q + 2 * δ) + δ + 4 * δ +\n PCP.Algebraic.PointLineConstants.endpointError δ q +\n 2 / ↑q) /\n PCP.Algebraic.PointLineConstants.agreementError +\n PCP.Algebraic.PointLineConstants.endpointError δ q <\n 1", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineConstants.smallError", + "LT.lt", + "Rat.instLT", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.PointLineConstants.endpointError", + "Nat.cast", + "Rat.instNatCast", + "PCP.Algebraic.PointLineConstants.agreementError" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.splitter._sparseCasesOn_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "{α : Type u} →\n {motive : Option α → Sort u_1} →\n (t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t", + "type_dependencies": [ + "Option", + "Option.some", + "Nat.hasNotBit", + "Option.ctorIdx" + ], + "value_dependencies": [ + "Option", + "Option.some", + "Option.rec", + "Nat.hasNotBit", + "Option.ctorIdx", + "Option.none", + "Nat.ne_of_beq_eq_false", + "Nat.land", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Nat.shiftRight", + "Eq.refl", + "Bool", + "Bool.false" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A strict majority is the chosen plurality, independently of tie breaking. ", + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.Plurality.value_eq_of_error_lt_half", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {A : Type u_2} [inst : Fintype R] [inst_1 : Finite A] [inst_2 : Nonempty A] [inst_3 : DecidableEq A]\n [Nonempty R] (w : R → A) (a : A),\n (PCP.Algebraic.relativeDistance w fun x => a) < 1 / 2 → PCP.Algebraic.Plurality.value w = a", + "type_dependencies": [ + "Fintype", + "Finite", + "Nonempty", + "DecidableEq", + "LT.lt", + "Rat", + "Rat.instLT", + "PCP.Algebraic.relativeDistance", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "Eq", + "PCP.Algebraic.Plurality.value" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → ℕ → ℕ → ℕ → Type u_3", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLowDegreeTest.TestRandomness", + "PCP.Algebraic.SetMultilinear.Variables", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.predecessor_volume_lt._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ},\n 2 < PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1 → False", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Not", + "LE.le", + "instLENat", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.predict.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] (a w : I → F) (f : V → F) (x v : V),\n PCP.Algebraic.WeightedConstraint.predict a w f x v = ∑ i, w i * f (x + a i • v)", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "Eq", + "PCP.Algebraic.WeightedConstraint.predict", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HAdd.hAdd", + "instHAdd", + "AddCommMagma.toAdd", + "AddCommSemigroup.toAddCommMagma", + "AddCommMonoid.toAddCommSemigroup", + "HSMul.hSMul", + "instHSMul", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The explicitly placed vertices induce exactly the input graph. ", + "end_line": 146, + "is_class": false, + "kind": "theorem", + "line": 137, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph_adj_vertexEmbedding", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V) (eV : V ≃ Fin (Fintype.card V)) (u v : V),\n (PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph G eV).Adj\n ((PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding eV) u)\n ((PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding eV) v) ↔\n G.Adj u v", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "Equiv", + "Fin", + "Fintype.card", + "Iff", + "SimpleGraph.Adj", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "DFunLike.coe", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Translation by a vector with nonzero image exchanges the two fibers of a binary homomorphism. ", + "end_line": 75, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.two_mul_nonzero_count", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : AddCommGroup V] [inst_1 : Fintype V] (L : V →+ ZMod 2) (e : V),\n L e ≠ 0 → 2 * {v | L v ≠ 0}.card = Fintype.card V", + "type_dependencies": [ + "AddCommGroup", + "Fintype", + "AddMonoidHom", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "AddMonoidWithOne.toAddMonoid", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Ne", + "DFunLike.coe", + "AddMonoidHom.instFunLike", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "HMul.hMul", + "instHMul", + "instMulNat", + "Finset.card", + "Finset.filter", + "instDecidableNot", + "ZMod.decidableEq", + "Finset.univ", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep.match_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : ℕ → List Bool → Sort u_1) →\n (x : ℕ) →\n (x_1 : List Bool) →\n ((as : List Bool) → motive 0 as) → ((n : ℕ) → (as : List Bool) → motive n.succ as) → motive x x_1", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "OfNat.ofNat", + "instOfNatNat", + "Nat.succ" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "OfNat.ofNat", + "instOfNatNat", + "Nat.succ", + "Nat.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Any proper coloring assigns a permutation of the three colors to the palette. ", + "end_line": 198, + "is_class": false, + "kind": "definition", + "line": 191, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.palette", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) →\n (PCP.Reduction.NAEThreeColor.graph Q).Coloring (Fin 3) → Fin 3 ≃ Fin 3", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "Equiv" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "Function.Injective", + "DFunLike.coe", + "RelHom.instFunLike", + "SimpleGraph.Adj", + "SimpleGraph.completeGraph", + "PCP.Reduction.NAEThreeColor.base", + "PCP.Reduction.NAEThreeColor.palette._proof_1", + "Equiv.ofBijective", + "PCP.Reduction.NAEThreeColor.palette._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Padded, individually addressable stack cells; no whole stack is a variable. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.Cells", + "provenance": "lean", + "structural_dependencies": [], + "type": "Turing.FinTM2 → ℕ → Type", + "type_dependencies": [ + "Turing.FinTM2", + "Nat" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.K", + "Fin", + "Option", + "PCP.Machine.ComputationTableau.Symbol" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : Type u_1) (motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u_2) (a : V) (a_1 : Bool)\n (h_1 : (a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a))\n (h_2 : (a : V) → (a_2 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_2)),\n (match PCP.Reduction.NAEThreeColor.Literal.var a a_1 with\n | PCP.Reduction.NAEThreeColor.Literal.const a => h_1 a\n | PCP.Reduction.NAEThreeColor.Literal.var a a_2 => h_2 a a_2) =\n h_2 a a_1", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Eq", + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {a : ℕ} →\n {t : PCP.QueryTree a} → {a' : ℕ} → {t' : PCP.QueryTree a'} → a = a' → t ≍ t' → PCP.QueryTree.noConfusionType P t t'", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HEq", + "PCP.QueryTree.noConfusionType" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.QueryTree.noConfusionType", + "PCP.QueryTree.casesOn", + "Bool", + "Eq.refl", + "HEq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Interpolation recovers a formal polynomial under the individual-degree bound. ", + "end_line": 166, + "is_class": false, + "kind": "theorem", + "line": 156, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.interpolate_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : DecidableEq 𝔽] {m : ℕ} (H : Finset 𝔽),\n H.Nonempty →\n ∀ (p : MvPolynomial (Fin m) 𝔽),\n (∀ (i : Fin m), MvPolynomial.degreeOf i p ≤ H.card - 1) →\n ((PCP.Algebraic.GridInterpolation.interpolate H) fun a => (MvPolynomial.eval fun i => ↑(a i)) p) = p", + "type_dependencies": [ + "Field", + "DecidableEq", + "Nat", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.degreeOf", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.GridInterpolation.interpolate", + "Fin.fintype", + "instDecidableEqFin", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An alternative simple affine bound in the ceiling logarithm. ", + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 78, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le_log_add_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), PCP.Algebraic.ThreeColorParameterChoice.volume N ≤ 32 * (Nat.clog 2 N + 1)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "PCP.Algebraic.ThreeColorParameterChoice.volume", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "definition", + "line": 51, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits", + "ZMod", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.eval_le_coefficientSum._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (n : ℕ), ¬0 < n + 2 → False", + "type_dependencies": [ + "Nat", + "Not", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.clauseVertex.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (e : C) (i : Fin 3),\n PCP.Reduction.NAEThreeColor.clauseVertex e i = Sum.inr (Sum.inr (e, i))", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.clauseVertex", + "Sum.inr", + "Sum", + "Prod", + "Bool", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.slot.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {a d : ℕ} (i : Fin (max 1 d)) (j : Fin a), PCP.Reduction.FiniteDomainConstraints.slot i j = finProdFinEquiv (i, j)", + "type_dependencies": [ + "Nat", + "Fin", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.slot", + "DFunLike.coe", + "Equiv", + "Prod", + "HMul.hMul", + "instHMul", + "instMulNat", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "finProdFinEquiv", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.read.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n PCP.Algebraic.BinaryLocalCorrection.read f H (Sum.inl p) = f p.1 p.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Prod", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk", + "PCP.Verifier.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The image of `Y ^ k`: one selected variable from every block. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] →\n (m : ℕ) → [NeZero m] → (c : ℕ) → ℕ → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.prod", + "Fin", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "CommSemiring.toCommMonoid", + "AddMonoidAlgebra.commSemiring", + "Finsupp", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "MvPolynomial.X", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 60, + "is_class": false, + "kind": "theorem", + "line": 58, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_X_pow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n (PCP.Algebraic.SetMultilinear.encode m c) (Polynomial.X ^ k) = PCP.Algebraic.SetMultilinear.digitMonomial m c k", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.X", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Query dependence of the actual randomized verifier. ", + "end_line": 133, + "is_class": false, + "kind": "theorem", + "line": 111, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r)\n (p p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (M M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A A' : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n (∀ q ∈ PCP.Algebraic.DerivedZeroOnGrid.queries ρ Q hQ nodes ζ H s,\n PCP.Algebraic.DerivedZeroOnGrid.read p M A q = PCP.Algebraic.DerivedZeroOnGrid.read p' M' A' q) →\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H p M A s =\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H p' M' A' s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "Eq", + "PCP.Algebraic.DerivedZeroOnGrid.read", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.read.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n PCP.Algebraic.BinaryLocalCorrection.read f H (Sum.inr p) = H p.1 p.2.1 p.2.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read", + "Sum.inr", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.inY._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.edgeValue_eq_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (x : Fin (n + n) → F),\n PCP.Algebraic.ThreeColorVerifier.edgeValue H G x =\n (MvPolynomial.eval x) (PCP.Algebraic.ThreeColorVerifier.edgePolynomial H G)", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorVerifier.edgePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The three-color membership polynomial from the algebraic verifier. ", + "end_line": 204, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.cubic", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : CommRing F] → Polynomial F", + "type_dependencies": [ + "CommRing", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring" + ], + "value_dependencies": [ + "CommRing", + "HSub.hSub", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "instHSub", + "Polynomial.instSub", + "CommRing.toRing", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.semiring", + "Polynomial.X", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "Polynomial.instOne" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (3 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.ofBits.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool), PCP.Machine.ofBits x = List.map PCP.Machine.Sym.bit x", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.ofBits", + "List.map", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The gap is a fixed positive rational, independent of graph size. ", + "end_line": 204, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.gap", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℚ", + "type_dependencies": [ + "Rat" + ], + "value_dependencies": [ + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "PCP.Algebraic.ThreeColorSoundnessBudget.gap", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat.instOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 142, + "is_class": false, + "kind": "definition", + "line": 142, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t r : ℕ} →\n [Fintype F] →\n Fintype (PCP.Algebraic.Hadamard.TestRandomness t r × PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 56, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Total degree is additive on nonzero factors over a domain. ", + "end_line": 71, + "is_class": false, + "kind": "theorem", + "line": 66, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.totalDegree_mul_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] {p q : MvPolynomial σ R},\n p ≠ 0 → q ≠ 0 → (p * q).totalDegree = p.totalDegree + q.totalDegree", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "MvPolynomial", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Eq", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.size_le_volume._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬0 < PCP.Algebraic.ThreeColorParameterChoice.exponent N → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Not", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.acceptingRandomness.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.acceptingRandomness x π = {r | (V.run x r).eval π = true}", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Eq", + "Finset", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.acceptingRandomness", + "Finset.filter", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "Bool.true", + "instDecidableEqBool", + "Finset.univ", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The exact coordinate flattening used only by the proper-constraint branch. ", + "end_line": 48, + "is_class": false, + "kind": "definition", + "line": 47, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.flatten", + "provenance": "lean", + "structural_dependencies": [], + "type": "(n : ℕ) → Fin n ⊕ Fin n ≃ Fin (n + n)", + "type_dependencies": [ + "Nat", + "Equiv", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "finSumFinEquiv" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "Eq", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode_val", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool) (v : Fin (PCP.Algebraic.ThreeColorEncoding.vertexCount x)),\n ↑((PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode x) v) = ↑v", + "type_dependencies": [ + "List", + "Bool", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "Eq", + "Nat", + "Fin.val", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 32, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.var.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : SizeOf V] (a : V) (a_1 : Bool),\n sizeOf (PCP.Reduction.NAEThreeColor.Literal.var a a_1) = 1 + sizeOf a + sizeOf a_1", + "type_dependencies": [ + "SizeOf", + "Bool", + "Eq", + "Nat", + "SizeOf.sizeOf", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal._sizeOf_inst", + "PCP.Reduction.NAEThreeColor.Literal.var", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Bool._sizeOf_inst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 122, + "is_class": false, + "kind": "theorem", + "line": 115, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.rejection_bias", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] [Nonempty V] [inst_2 : Add V] (H : V → ZMod 2),\n (PCP.Algebraic.BLR.average fun x =>\n PCP.Algebraic.BLR.average fun y =>\n PCP.Algebraic.BLR.sign (H x) * PCP.Algebraic.BLR.sign (H y) * PCP.Algebraic.BLR.sign (H (x + y))) =\n 1 - 2 * PCP.Algebraic.BLR.rejectionProbability H", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Add", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.average", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.sign", + "HAdd.hAdd", + "instHAdd", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "PCP.Algebraic.BLR.rejectionProbability" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Close polynomial columns and exact polynomial rows construct a nearby bivariate\npolynomial. This is the two-dimensional coarse agreement theorem, with all its\nalgebraic existence steps proved rather than supplied. ", + "end_line": 136, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.BivariateAgreement", + "name": "PCP.Algebraic.BivariateAgreement.exists_nearby_of_close_columns", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ},\n 0 < d →\n 1000 * d ^ 3 ≤ Fintype.card F →\n ∀ (a : Fin (10 * d) → F),\n Function.Injective a →\n ∀ (C : Fin (10 * d) → Polynomial F),\n (∀ (i : Fin (10 * d)), (C i).natDegree ≤ d) →\n ∀ (R : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n (∀ (i : Fin (10 * d)),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x =>\n Polynomial.eval x (C i)) ≤\n 1 / 10) →\n ∃ P,\n (∀ (j : Fin 2), MvPolynomial.degreeOf j P ≤ d) ∧\n (∀ (i : Fin (10 * d)), PCP.Algebraic.PointLineCrossing.rowPolynomial P (a i) = C i) ∧\n PCP.Algebraic.relativeDistance R (PCP.Algebraic.PointLineCrossing.columnPolynomial P) ≤\n 1 / 9 ∧\n (PCP.Algebraic.relativeDistance (fun z => Polynomial.eval z.1 (R z.2)) fun z =>\n (MvPolynomial.eval ![z.1, z.2]) P) ≤\n 1 / 9", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "Fin", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial.natDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Polynomial.eval", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.degreeOf", + "Eq", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "Polynomial.instDecidableEq", + "PCP.Algebraic.PointLineCrossing.columnPolynomial", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "SMulCommClass (ZMod 2) (ZMod 2) (ZMod 2)", + "type_dependencies": [ + "SMulCommClass", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Algebra.toSMul", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Algebra.id", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.finiteWitnessCheck.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w =\n decide (∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true)", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Eq", + "PCP.finiteWitnessCheck", + "Decidable.decide", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "PCP.oracleOfWitness", + "Bool.true", + "Nat.decidableForallFin", + "instDecidableEqBool" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), sizeOf (PCP.Machine.Sym.bit b) = 1 + sizeOf b", + "type_dependencies": [ + "Bool", + "Eq", + "Nat", + "SizeOf.sizeOf", + "PCP.Machine.Sym", + "PCP.Machine.Sym._sizeOf_inst", + "PCP.Machine.Sym.bit", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Bool._sizeOf_inst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "theorem", + "line": 29, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.BLR.sign 0 = 1", + "type_dependencies": [ + "Eq", + "Rat", + "PCP.Algebraic.BLR.sign", + "OfNat.ofNat", + "ZMod", + "Nat", + "instOfNatNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{α : Type u} →\n {β : Type v} →\n {motive : α ⊕ β → Sort u_1} →\n (t : α ⊕ β) → ((val : α) → motive (Sum.inl val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t", + "type_dependencies": [ + "Sum", + "Sum.inl", + "Nat.hasNotBit", + "Sum.ctorIdx" + ], + "value_dependencies": [ + "Sum", + "Sum.inl", + "Sum.rec", + "Nat.hasNotBit", + "Sum.ctorIdx", + "Sum.inr", + "Nat.ne_of_beq_eq_false", + "Nat.land", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Nat.shiftRight", + "Eq.refl", + "Bool", + "Bool.false" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 124, + "is_class": false, + "kind": "theorem", + "line": 119, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "_private.PCP.Algebraic.ThreeColorCanonicalVerifier.0.PCP.Algebraic.ThreeColorCanonicalVerifier.power_bound_mono", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N n : ℕ}, N ≤ n → ∀ (k : ℕ), (4 * max 1 N) ^ k ≤ Polynomial.eval n ((Polynomial.C 4 * (Polynomial.X + 1)) ^ k)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Polynomial.eval", + "Nat.instSemiring", + "Polynomial", + "Semiring.toMonoid", + "Polynomial.semiring", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "Polynomial.C", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "Polynomial.X", + "One.toOfNat1", + "Polynomial.instOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Quantitative endpoint predictions force genuine degree-`d` polynomials on\nevery affine line. All parameters are handled on the same target-line polynomial. ", + "end_line": 91, + "is_class": false, + "kind": "theorem", + "line": 72, + "module": "PCP.Algebraic.RuledSurfaceRigidity", + "name": "PCP.Algebraic.RuledSurface.hasLowDegreeLines_of_endpoint_bounds", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {d : ℕ},\n 0 < d →\n 1000 * d ^ 3 ≤ Fintype.card F →\n ∀ (f g : (σ → F) → F) (T : PCP.Algebraic.PointLineTest.LineTable F σ d) {η γ δ ℓ ε : ℚ},\n PCP.Algebraic.relativeDistance f g ≤ η →\n (∀ (u : σ → F) (t : F),\n (PCP.Algebraic.AffineLineSampling.fraction fun v =>\n Polynomial.eval t ↑(T (u, v)) ≠ g (PCP.Algebraic.PolynomialLine.point u v t)) ≤\n γ) →\n PCP.Algebraic.PointLineTest.rejectionRate f T ≤ δ →\n (∀ (t : F),\n (PCP.Algebraic.relativeDistance (fun uv => f (PCP.Algebraic.PolynomialLine.point uv.1 uv.2 t))\n fun uv => Polynomial.eval t ↑(T uv)) ≤\n ℓ) →\n 0 < ε →\n ε ≤ 1 / 100 →\n 6 * ε + 2 * (↑d / ↑(Fintype.card F)) < 1 / 2 →\n (2 * (γ + η) + δ + ℓ + γ + 2 / ↑(Fintype.card F)) / ε + γ < 1 →\n PCP.Algebraic.PolynomialLine.HasLowDegreeLines d g", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "PCP.Algebraic.PointLineTest.LineTable", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.AffineLineSampling.fraction", + "Ne", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Subtype.val", + "Polynomial", + "Polynomial.natDegree", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.RuledSurface.Seed", + "instFintypeProd", + "Prod.fst", + "Prod.snd", + "Rat.instLT", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "PCP.Algebraic.PolynomialLine.HasLowDegreeLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "(4 + 1).AtLeastTwo", + "type_dependencies": [ + "Nat.AtLeastTwo", + "HAdd.hAdd", + "Nat", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {t r : ℕ} (hr : 1 ≤ r)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (g : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) (a b : σ → F) (w : Fin t → ZMod 2),\n PCP.Algebraic.BinaryDifferenceConsistency.check hr f g a b w =\n g (Sum.elim a b) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) w) -\n (f a ((PCP.Algebraic.Hadamard.homogeneousIndex hr) w) - f b ((PCP.Algebraic.Hadamard.homogeneousIndex hr) w))", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Sum", + "Fin", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.check", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Sum.elim", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk", + "PCP.NPCertificate.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.sizePoly.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (k D : ℕ),\n PCP.Reduction.NPThreeColorRuntime.sizePoly h q k D =\n Polynomial.C D *\n (PCP.Reduction.NPThreeColor.variablesPoly h q k + PCP.Reduction.NPThreeColor.constraintsPoly h q k + 1) ^ 2", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "PCP.Reduction.NPThreeColorRuntime.sizePoly", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_comm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β → ℚ),\n (PCP.Algebraic.BLR.average fun x => PCP.Algebraic.BLR.average (f x)) =\n PCP.Algebraic.BLR.average fun y => PCP.Algebraic.BLR.average fun x => f x y", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`NP ⊆ PCP(O(log n), O(1))`, with one polynomial-time verifier for each language.\nAll constants and the proof-length polynomial are independent of the input. ", + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 23, + "module": "PCP.Theorem", + "name": "PCP.np_subset_pcp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (L : PCP.Language),\n PCP.InNP PCP.Machine.PolyTimeRel L →\n ∃ V alg a b q p,\n PCP.Machine.PolyTimeAlg alg ∧\n V.ImplementedBy alg ∧\n V.queries = q ∧\n V.CanonicalRandomness a b ∧\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) ∧\n (∀ (x : List Bool), L x → V.CompleteAt x) ∧ ∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)", + "type_dependencies": [ + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "And", + "PCP.Machine.PolyTimeAlg", + "PCP.Verifier.ImplementedBy", + "Eq", + "PCP.Verifier.queries", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A uniform cost model: what \"polynomial time\" means for witness-checking relations and for\nverifier algorithms, together with the coherence and closure properties any genuine model has.\n\nThe field docstrings explain why each field is present. **The machine model is no longer a choice**:\n`PCP/Complexity/Machine.lean` fixes it as `Turing.TM2ComputableInPolyTime`. Showing those concrete\npredicates satisfy this interface was obligation NP-1, now discharged: the two coherence fields in\n`PCP/Complexity/Bridge.lean`, the closure field below in `PCP/Complexity/StandardModel.lean`.\nNote the known cost of that choice: *some* certified composition or subroutine result is needed for\nthe closure field, and mathlib's `comp` is an open `proof_wanted` at the pinned revision. That\nupstream theorem is one route; a specialised call-and-return construction for these fixed encodings\nis another, and is the one that was built. ", + "end_line": 108, + "is_class": false, + "kind": "inductive", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel", + "provenance": "lean", + "structural_dependencies": [ + "PCP.CostModel.mk", + "PCP.CostModel" + ], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All seven branches must accept. ", + "end_line": 121, + "is_class": false, + "kind": "definition", + "line": 117, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.test", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.Sample F n m c t → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.FiniteConjunction.test", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "definition", + "line": 49, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.correct", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat" + ], + "value_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.WeightedConstraint.predict", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Reading the positive variable vertex recovers a satisfying assignment. ", + "end_line": 238, + "is_class": false, + "kind": "theorem", + "line": 214, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.exists_assignment_of_coloring", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V)\n (f : (PCP.Reduction.NAEThreeColor.graph Q).Coloring (Fin 3)),\n ∃ a, ∀ (e : C), PCP.Reduction.NAEThreeColor.NAE fun i => PCP.Reduction.NAEThreeColor.Literal.eval a (Q e i)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "Exists", + "Bool", + "PCP.Reduction.NAEThreeColor.NAE", + "PCP.Reduction.NAEThreeColor.Literal.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The Corollary 70 argument with an explicit nearby bivariate polynomial.\n\nThe comparison polynomial has degree at most `d` in each variable. Its existence\nis an explicit hypothesis; `BivariateCrossingSoundness` supplies it using the\nseparately proved bivariate agreement theorem.\nThe two line approximants at the crossing need only satisfy their usual minimum\ndistance property. Global errors `ε`, polynomial error `ρ`, and slice error `ε'`\nare kept separate so this lemma can be reused with other agreement bounds. ", + "end_line": 292, + "is_class": false, + "kind": "theorem", + "line": 238, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.crossing_eq_of_nearby_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {d : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F] (f : F × F → F)\n (R C : F → Polynomial F),\n (∀ (x : F), (R x).natDegree ≤ d) →\n (∀ (y : F), (C y).natDegree ≤ d) →\n ∀ (P : MvPolynomial (Fin 2) F),\n (∀ (i : Fin 2), MvPolynomial.degreeOf i P ≤ d) →\n ∀ (x₀ y₀ : F) {ε ρ ε' : ℚ},\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.2 (R z.1)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.1 (C z.2)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => (MvPolynomial.eval ![z.1, z.2]) P) ≤ ρ →\n (PCP.Algebraic.relativeDistance (fun y => f (x₀, y)) fun y => Polynomial.eval x₀ (C y)) ≤ ε' →\n (PCP.Algebraic.relativeDistance (fun x => f (x, y₀)) fun x => Polynomial.eval y₀ (R x)) ≤ ε' →\n (∀ (p : Polynomial F),\n p.natDegree ≤ d →\n (PCP.Algebraic.relativeDistance (fun y => f (x₀, y)) fun x => Polynomial.eval x (R x₀)) ≤\n PCP.Algebraic.relativeDistance (fun y => f (x₀, y)) fun x => Polynomial.eval x p) →\n (∀ (p : Polynomial F),\n p.natDegree ≤ d →\n (PCP.Algebraic.relativeDistance (fun x => f (x, y₀)) fun x => Polynomial.eval x (C y₀)) ≤\n PCP.Algebraic.relativeDistance (fun x => f (x, y₀)) fun x => Polynomial.eval x p) →\n 2 * (ε' + ε + ρ + ↑d / ↑(Fintype.card F)) < 1 - ↑d / ↑(Fintype.card F) →\n Polynomial.eval y₀ (R x₀) = Polynomial.eval x₀ (C y₀)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Prod", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial.degreeOf", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "Prod.snd", + "Prod.fst", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty", + "Prod.mk", + "LT.lt", + "Rat.instLT", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "_private.PCP.Algebraic.BinaryLocalCorrection.0.PCP.Algebraic.BinaryLocalCorrection.read.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t : ℕ} →\n (motive : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → Sort u_3) →\n (x : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl p)) →\n ((p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.inr" + ], + "value_dependencies": [ + "PCP.Algebraic.BinaryLocalCorrection.read.match_1" + ] + }, + { + "axioms": [], + "doc": "The sign bit is false for a positive literal and true for its negation. ", + "end_line": 81, + "is_class": false, + "kind": "definition", + "line": 78, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → (V → Bool) → PCP.Reduction.NAEThreeColor.Literal V → Bool", + "type_dependencies": [ + "Bool", + "PCP.Reduction.NAEThreeColor.Literal" + ], + "value_dependencies": [ + "Bool", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5", + "Bool.xor" + ] + }, + { + "axioms": [], + "doc": "The depth-`d` decision tree generated by unfolding a step function, starting from the answers\n`as` received so far.\n\nIf the step function has not halted within its `d`-query budget the tree rejects: an algorithm\nclaiming a `q`-query verifier must halt within `q` queries, and `ImplementedBy` below is what\nforces that to match the verifier's actual behaviour. ", + "end_line": 47, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Nat.brecOn", + "PCP.QueryTree", + "PCP.QueryTree.ofStep._f" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "Extend a satisfying Boolean assignment to all gadget vertices. ", + "end_line": 128, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.color", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n (C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) → (V → Bool) → PCP.Reduction.NAEThreeColor.Vertex V C → Fin 3", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Vertex" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.color.match_1", + "PCP.Reduction.NAEThreeColor.boolColor", + "Bool.xor", + "PCP.Reduction.NAEThreeColor.triangleWitness", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 77, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.expect_sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ]\n (k : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r → ℚ),\n (Finset.univ.expect fun s => k s) =\n Finset.univ.expect fun uv =>\n Finset.univ.expect fun z => Finset.univ.expect fun vw => Finset.univ.expect fun hi => k (uv, z, vw, hi)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "instFintypeProd", + "Pi.instFintype", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed_1", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 49, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "_private.PCP.Algebraic.WeightedConstraintSoundness.0.PCP.Algebraic.WeightedConstraint.weighted_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_3} [inst : Field F] [inst_1 : Fintype I] [inst_2 : DecidableEq F] {R : Type u_4}\n [inst_3 : Fintype R] (w : I → F) (f g : I → R → F),\n (PCP.Algebraic.relativeDistance (fun s => ∑ i, w i * f i s) fun s => ∑ i, w i * g i s) ≤\n ∑ i, PCP.Algebraic.relativeDistance (f i) (g i)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Finset.sum", + "Semiring.toAddCommMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "Rat.addCommMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every branch's list is mapped to physical proof-table locations. ", + "end_line": 201, + "is_class": false, + "kind": "definition", + "line": 184, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n (i : Fin 7) →\n PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i →\n List (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Fin.cases", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Fin.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_1", + "List.map", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.ThreeColorVerifier.colorQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_3", + "Fin.succ", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_2", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.validQuery", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_4", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_3", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_4", + "PCP.Algebraic.ThreeColorVerifier.properQuery", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_6", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_8", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery", + "PCP.Algebraic.BinaryDifferenceConsistency.queries", + "Prod.fst", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "Prod", + "Prod.snd", + "Fin.elim0" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Pack the structured proof into the same finite word. ", + "end_line": 78, + "is_class": false, + "kind": "definition", + "line": 76, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.encodeProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "{N : ℕ} → PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof N → PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord N", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.size", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "DFunLike.coe", + "Equiv", + "PCP.Algebraic.ThreeColorBinaryVerifier.Address", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator_goodNodes._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ),\n 16 ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) →\n ¬2 * 4 < Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "Not", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A §3.4: at every requested entry, success is at least `1 - 2ε`. ", + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.HadamardCorrection", + "name": "PCP.Algebraic.Hadamard.selfCorrect_success_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (x : Fin t → ZMod 2) (w : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (P : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) {ε : ℚ},\n PCP.Algebraic.relativeDistance w ⇑(PCP.Algebraic.Hadamard.encode r x) ≤ ε →\n 1 - 2 * ε ≤\n PCP.Algebraic.relativeAgreement (PCP.Algebraic.Hadamard.selfCorrect w P) fun x_1 =>\n (PCP.Algebraic.Hadamard.encode r x) P", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.relativeAgreement", + "PCP.Algebraic.Hadamard.selfCorrect", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "theorem", + "line": 45, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.call_eq_sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} {σ : Type u_2}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ f A a w s =\n PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f A a\n (PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv (w, s))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "Eq", + "Option", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "DFunLike.coe", + "Equiv", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "No branch loses its normalized marginal through an empty independent seed. ", + "end_line": 399, + "is_class": false, + "kind": "theorem", + "line": 397, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchSeedNonempty", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c t : ℕ} (i : Fin 7),\n Nonempty (PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Nonempty", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 387, + "is_class": false, + "kind": "theorem", + "line": 386, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyCallSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t : ℕ} {σ : Type u_2},\n Nonempty (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The normalized rejection of one concrete branch on its own seed. ", + "end_line": 411, + "is_class": false, + "kind": "definition", + "line": 407, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Fin 7 → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "instDecidableEqBool", + "PCP.Algebraic.ThreeColorVerifier.branchTest", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 377, + "is_class": false, + "kind": "definition", + "line": 376, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeProdTestRandomnessInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t : ℕ} →\n [Fintype F] →\n {r : ℕ} →\n Fintype (PCP.Algebraic.Hadamard.TestRandomness t r × PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 222, + "is_class": false, + "kind": "theorem", + "line": 221, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.eval_cubic", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] (u : F), Polynomial.eval u PCP.Algebraic.HadamardDerivedOracle.cubic = u ^ 3 - 1", + "type_dependencies": [ + "CommRing", + "Eq", + "Polynomial.eval", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Full coefficient-space error of the primary received oracle. ", + "end_line": 106, + "is_class": false, + "kind": "definition", + "line": 102, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : CommRing F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {t r : ℕ} →\n {I : Type u_2} →\n [Fintype I] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (I → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) → (I → F) → ℚ", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat" + ], + "value_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardDerivedOracle.answer._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance._proof_1", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.6: concatenate the encodings of a function's values. ", + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 106, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encodeFunction", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t : ℕ} →\n {ι : Type u_1} → (r : ℕ) → (ι → Fin t → ZMod 2) → ι × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.field_bound_linear._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {q : ℕ}, 1 < q → ¬2 * 0 < q → False", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 218, + "is_class": false, + "kind": "theorem", + "line": 217, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.natDegree_weightedCubic_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [Nontrivial F] (a : F),\n (PCP.Algebraic.HadamardDerivedOracle.weightedCubic a).natDegree ≤ 3", + "type_dependencies": [ + "CommRing", + "Nontrivial", + "LE.le", + "Nat", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 203, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Fintype F] → {m c : ℕ} → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Fintype", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Fintype", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct.eq_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V)\n (x : PCP.Reduction.NAEThreeColor.Vertex V C) (e : C) (i : Fin 3),\n (∀ (f : C) (j : Fin 3), x = Sum.inr (Sum.inr (f, j)) → False) →\n PCP.Reduction.NAEThreeColor.direct Q (Sum.inr (Sum.inr (e, i))) x =\n (x = PCP.Reduction.NAEThreeColor.literalVertex (Q e i))", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Vertex", + "Eq", + "Sum.inr", + "Sum", + "Prod", + "Bool", + "Prod.mk", + "False", + "PCP.Reduction.NAEThreeColor.direct", + "PCP.Reduction.NAEThreeColor.literalVertex" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a : V) (a_1 : Bool),\n PCP.Reduction.NAEThreeColor.Literal.var a a_1 = PCP.Reduction.NAEThreeColor.Literal.var a a_1", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_vanishesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ),\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.GridVanishing.coordinate H i)", + "type_dependencies": [ + "CommRing", + "Finset", + "PCP.Algebraic.GridVanishing.VanishesOn", + "PCP.Algebraic.GridVanishing.coordinate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every address the tree could query, along any branch. ", + "end_line": 49, + "is_class": false, + "kind": "definition", + "line": 46, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.brecOn", + "Finset", + "PCP.QueryTree.addresses._f" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Concrete NP certificates reduce to the actual encoded graph language in polynomial time. ", + "end_line": 199, + "is_class": false, + "kind": "theorem", + "line": 192, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.of_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language} (cert : PCP.NPCertificate PCP.Machine.PolyTimeRel L),\n ∃ f p,\n PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits f ∧\n ∀ (x : List Bool),\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧ (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "PCP.Language", + "PCP.NPCertificate", + "PCP.Machine.PolyTimeRel", + "Exists", + "List", + "Bool", + "Polynomial", + "Nat", + "Nat.instSemiring", + "And", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One actual verifier has all mathematical resource and probability properties,\nincluding the standard soundness target. Efficiency and NP transfer are not asserted. ", + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 70, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verification_guarantees", + "provenance": "lean", + "structural_dependencies": [], + "type": "0 < PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions ∧\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.queries =\n PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 187 ∧\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CanonicalRandomness\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000)\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000) ∧\n (∀ (x : List Bool),\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.ReadsBelow x\n (Polynomial.eval x.length PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound)) ∧\n (∀ (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CompleteAt x) ∧\n ∀ (x : List Bool),\n ¬(PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.SoundAt x (1 / 2)", + "type_dependencies": [ + "And", + "LT.lt", + "Nat", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "Eq", + "PCP.Verifier.queries", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "Nat.instSemiring", + "List.length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.call.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} {σ : Type u_2}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ f A a w s =\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ f A a s.1 s.2.1 s.2.2.1 w s.2.2.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "Eq", + "Option", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "PCP.Algebraic.BinaryLocalCorrection.run", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.readCell.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} (s : PCP.Machine.TableauCells.Cells tm B) (k : tm.K) (j : ℕ),\n PCP.Machine.TableauCells.readCell s k j = if h : j < B then Option.map Subtype.val (s k ⟨j, h⟩) else none", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "Eq", + "Option", + "Turing.FinTM2.Γ", + "PCP.Machine.TableauCells.readCell", + "dite", + "LT.lt", + "instLTNat", + "Nat.decLt", + "Option.map", + "Subtype", + "PCP.Machine.Supported", + "Subtype.val", + "Fin.mk", + "Not", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Embedding the primary-color low-degree test's queries. ", + "end_line": 152, + "is_class": false, + "kind": "definition", + "line": 149, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.colorQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.colorQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.eval_properPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (E Q : MvPolynomial σ F) (x : σ → F),\n (MvPolynomial.eval x) (PCP.Algebraic.ThreeColorGrid.properPolynomial E Q) =\n (MvPolynomial.eval x) E * ((MvPolynomial.eval x) Q ^ 3 - 1)", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Machine.TableauNumericIndex.variableCount.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k T B : ℕ),\n PCP.Machine.TableauNumericIndex.variableCount k T B = (T + 1) * PCP.Machine.TableauNumericIndex.sites k B + 1", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Machine.TableauNumericIndex.variableCount", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.TableauNumericIndex.sites" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Replacing one derived answer costs only its marginal error.\nOther randomness may be included in the label seed, before drawing the fresh correction seed. ", + "end_line": 162, + "is_class": false, + "kind": "theorem", + "line": 147, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.decision_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} {I : Type u_2} [inst_2 : Fintype I]\n {A : Type u_3} {B : Type u_4} [inst_3 : Fintype A] [inst_4 : DecidableEq B] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : I → Polynomial F) (hP : ∀ (i : I), (P i).natDegree ≤ r)\n (H : I → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) (f : I → F)\n (L : I → A → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (decision : I → A → ZMod 2 → B),\n (PCP.Algebraic.relativeDistance\n (fun s => decision s.1 s.2.1 (PCP.Algebraic.HadamardDerivedOracle.answer ρ (P s.1) ⋯ (H s.1) (L s.1 s.2.1) s.2.2))\n fun s =>\n decision s.1 s.2.1 ((PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval (f s.1) (P s.1)))) (L s.1 s.2.1))) ≤\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ H f", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A query list valid for every branch, including both correction sums. ", + "end_line": 79, + "is_class": false, + "kind": "definition", + "line": 69, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (σ → F) →\n (σ → F) →\n Fˣ →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n (Fin t → ZMod 2) →\n PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t →\n List (PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "List", + "PCP.Algebraic.BinaryLocalCorrection.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "List.cons", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "Units.val", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "HAppend.hAppend", + "List", + "Sum", + "PCP.Algebraic.SetMultilinear.Variables", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest binary answers observe the actual field difference discrepancy. ", + "end_line": 99, + "is_class": false, + "kind": "theorem", + "line": 93, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.check_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (f : (σ → F) → F) (g : (σ ⊕ σ → F) → F) (a b : σ → F) (w : Fin t → ZMod 2),\n PCP.Algebraic.BinaryDifferenceConsistency.check hr (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x))))\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (g x)))) a b w =\n (PCP.Algebraic.Hadamard.linearEncode (ρ (g (Sum.elim a b) - (f a - f b)))) w", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Sum", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.check", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.Hadamard.linearEncode", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Sum.elim" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a : V) (a_1 b : Bool),\n ¬a_1 = b → PCP.Reduction.NAEThreeColor.Literal.var a a_1 = PCP.Reduction.NAEThreeColor.Literal.var a b → False", + "type_dependencies": [ + "Bool", + "Not", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.var", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (f : PCP.QueryTree.below x_1), x_1.addresses.card < 2 ^ x", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", + "Bool", + "PCP.QueryTree.leaf", + "of_eq_true", + "Preorder.toLT", + "PartialOrder.toPreorder", + "Nat.instPartialOrder", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass", + "Nat.instMonoidWithZero", + "MonoidWithZero.toMonoid", + "pow_pos._simp_1", + "LinearOrderedCommMonoidWithZero.toPosMulStrictMono", + "Nat.instLinearOrderedCommMonoidWithZero", + "Nat.instZeroLEOneClass", + "SemilatticeInf.toPartialOrder", + "Lattice.toSemilatticeInf", + "DistribLattice.toLattice", + "instDistribLatticeOfLinearOrder", + "Nat.instLinearOrder", + "instOfNatAtLeastTwo", + "AddMonoidWithOne.toNatCast", + "Nat.instAddMonoidWithOne", + "Nat.instAtLeastTwoHAddOfNat", + "Nat.instNeZeroSucc", + "Eq.trans", + "LE.le", + "Preorder.toLE", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "True", + "Order.lt_two_iff._simp_1", + "Nat.instSuccAddOrder", + "Nat.instNoMaxOrder", + "zero_le._simp_1", + "LinearOrderedCommMonoidWithZero.toIsBotZeroClass", + "Nat.succ", + "PCP.QueryTree.query", + "PProd", + "instLENat", + "Insert.insert", + "Finset", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le.trans", + "Nat.instPreorder", + "Finset.card_insert_le", + "Finset.card_union_le", + "Decidable.byContradiction", + "Nat.decLe", + "Not", + "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", + "id", + "Eq", + "Mathlib.Tactic.Ring.of_eq", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Nat.instCommSemiring", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "Semiring.toMonoid", + "Nat.rawCast", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "instMulZeroClassOfSemiring", + "instMulNat", + "Mathlib.Tactic.Ring.Common.pow_congr", + "Mathlib.Tactic.Ring.cast_pos", + "Mathlib.Meta.NormNum.isNat_ofNat", + "Eq.refl", + "Mathlib.Tactic.Ring.Common.add_congr", + "Mathlib.Tactic.Ring.Common.atom_pf", + "rfl", + "Eq.mpr", + "congrArg", + "Eq.symm", + "Mathlib.Tactic.Ring.Common.add_pf_add_gt", + "Mathlib.Tactic.Ring.Common.add_pf_add_zero", + "Mathlib.Tactic.Ring.Common.pow_add", + "Mathlib.Tactic.Ring.Common.pow_one_cast_of_isNat", + "Mathlib.Meta.NormNum.IsNat.mk", + "Mathlib.Tactic.Ring.Common.single_pow", + "Mathlib.Tactic.Ring.Common.pow_prod_atom", + "Mathlib.Tactic.Ring.Common.pow_zero", + "Mathlib.Tactic.Ring.Common.add_mul", + "Mathlib.Tactic.Ring.Common.mul_add", + "Mathlib.Tactic.Ring.Common.mul_pf_left", + "Mathlib.Meta.NormNum.IsNat.to_raw_eq", + "Mathlib.Meta.NormNum.isNat_mul", + "Mathlib.Meta.NormNum.IsNat.of_raw", + "Mathlib.Tactic.Ring.Common.mul_zero", + "Mathlib.Tactic.Ring.Common.zero_mul", + "Mathlib.Tactic.Ring.Common.mul_pf_right", + "Mathlib.Tactic.Ring.Common.add_pf_add_overlap", + "Mathlib.Tactic.Ring.Common.add_overlap_pf", + "Mathlib.Meta.NormNum.isNat_add", + "Mathlib.Tactic.Ring.Common.add_pf_zero_add", + "Nat.decLt", + "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.encode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (r : ℕ) (x : Fin t → ZMod 2),\n PCP.Algebraic.Hadamard.encode r x = PCP.Algebraic.BinaryPolynomialSpace.evaluate x", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.evaluate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.natDegree_axisRestrict_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {σ : Type u_1} (i : σ) (s : σ →₀ ℕ), ¬0 ≤ s i → False", + "type_dependencies": [ + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "Zero.toOfNat0", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddCommMonoid.toAddMonoid", + "Nat.instAddCommMonoid", + "DFunLike.coe", + "Finsupp.instFunLike", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct.eq_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (v : V) (b : Bool) (w : V)\n (d : Bool),\n PCP.Reduction.NAEThreeColor.direct Q (Sum.inr (Sum.inl (v, b))) (Sum.inr (Sum.inl (w, d))) = (v = w ∧ b ≠ d)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.direct", + "Sum.inr", + "Sum", + "Prod", + "Sum.inl", + "Prod.mk", + "And", + "Ne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R)", + "type_dependencies": [ + "CommSemiring", + "RingHomCompTriple", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The edge constraint, using the difference table's polynomial. ", + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [inst : Field F] → MvPolynomial σ F → MvPolynomial σ F → MvPolynomial σ F", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.ThreeColorGrid.validPolynomial" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Below the grid size, the only polynomial vanishing on the grid is zero. ", + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 82, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.eq_zero_of_totalDegree_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R) (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p → p.totalDegree < H.card → p = 0", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "MvPolynomial", + "PCP.Algebraic.GridVanishing.VanishesOn", + "LT.lt", + "Nat", + "instLTNat", + "MvPolynomial.totalDegree", + "Finset.card", + "Eq", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : PCP.Machine.Sym → PCP.Machine.Sym → Sort u_1) →\n (x x_1 : PCP.Machine.Sym) →\n ((a b : Bool) → motive (PCP.Machine.Sym.bit a) (PCP.Machine.Sym.bit b)) →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b) PCP.Machine.Sym.sep) →\n ((b : Bool) → motive PCP.Machine.Sym.sep (PCP.Machine.Sym.bit b)) →\n (Unit → motive PCP.Machine.Sym.sep PCP.Machine.Sym.sep) → motive x x_1", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "Unit" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "Unit", + "PCP.Machine.Sym.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Some constant word has error at most the mean discrepancy of two independent values. ", + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.exists_constant_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {A : Type u_2} [inst : Fintype V] [Nonempty V] [inst_2 : DecidableEq A] (f : V → A),\n ∃ a, (PCP.Algebraic.relativeDistance f fun x => a) ≤ PCP.Algebraic.PointLineTest.pairDisagreement f", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Exists", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.PointLineTest.pairDisagreement" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.color" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Under the coarse proximity threshold, at most `3ε` of the formal rows differ. ", + "end_line": 102, + "is_class": false, + "kind": "theorem", + "line": 87, + "module": "PCP.Algebraic.BivariateAgreementBoost", + "name": "PCP.Algebraic.BivariateAgreementBoost.rowDistance_le_three_mul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (f : F × F → F)\n (R C : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n (∀ (x : F), (C x).natDegree ≤ d) →\n ∀ (P : MvPolynomial (Fin 2) F),\n (∀ (j : Fin 2), MvPolynomial.degreeOf j P ≤ d) →\n ∀ {ε ρ : ℚ},\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.1 (R z.2)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.2 (C z.1)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => (MvPolynomial.eval ![z.1, z.2]) P) ≤ ρ →\n ρ + ε + 2 * (↑d / ↑(Fintype.card F)) ≤ 1 / 3 →\n PCP.Algebraic.relativeDistance R (PCP.Algebraic.PointLineCrossing.columnPolynomial P) ≤ 3 * ε", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Prod", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial.degreeOf", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Polynomial.instDecidableEq", + "PCP.Algebraic.PointLineCrossing.columnPolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A certificate that `L` is in NP relative to a notion `P` of polynomial-time checkability: a\npolynomial witness bound and a witness-checking relation that `P` accepts.\n\n`P` is a plain parameter here, and that is safe *because nothing is proved by quantifying over it*.\n`InNP` is a definition, not a theorem. The two consumers each pin it down:\n\n* `pcp_subset_np` instantiates `P := M.PolyTimeRel` for a `CostModel` `M`, whose closure field is\n what makes the conclusion non-vacuous;\n* `np_subset_pcp` instantiates `P := PCP.Machine.PolyTimeRel`, the concrete machine definition.\n\nNeither quantifies over an arbitrary `P`. The distinction matters:\na *theorem* over an unconstrained interface is refutable by choosing a degenerate instance; a\n*definition* parameterised by one is just a definition. ", + "end_line": 39, + "is_class": false, + "kind": "inductive", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate", + "provenance": "lean", + "structural_dependencies": [ + "PCP.NPCertificate.mk", + "PCP.NPCertificate" + ], + "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Type", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instNonemptyInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F] {m c t : ℕ}, Nonempty (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n PCP.Algebraic.SetMultilinear.encode m c =\n Polynomial.lsum fun k => LinearMap.id.smulRight (PCP.Algebraic.SetMultilinear.digitMonomial m c k)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.lsum", + "LinearMap.smulRight", + "PCP.Algebraic.SetMultilinear.encode._proof_1", + "LinearMap.id", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p)) →\n ((p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual verifier uses a freshly self-corrected derived primary bit. ", + "end_line": 59, + "is_class": false, + "kind": "definition", + "line": 50, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Q : (Fin n → F) → Polynomial F) →\n (∀ (x : Fin n → F), (Q x).natDegree ≤ r) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n ((Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t →\n PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r → Option (ZMod 2 × ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Option", + "Prod" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "Field.toCommRing", + "Prod.fst", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le._proof_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n PCP.Algebraic.ThreeColorParameterChoice.exponent N = PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1 + 1 →\n ¬PCP.Algebraic.ThreeColorParameterChoice.exponent N * 2 ≤\n 4 * (PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1) →\n False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Not", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 110, + "is_class": false, + "kind": "theorem", + "line": 110, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.assignmentFinite", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (x : List Bool),\n Finite (PCP.Machine.NPTableau.Assignment h q x)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Finite", + "PCP.Machine.NPTableau.Assignment" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.outputCoordinate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (i : Fin t),\n PCP.Algebraic.HadamardComposition.outputCoordinate ρ P i =\n PCP.Algebraic.HadamardComposition.mapCoefficients (LinearMap.proj i ∘ₗ ↑ρ)\n (PCP.Algebraic.HadamardComposition.fieldPolynomial ρ P)", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "Eq", + "MvPolynomial", + "PCP.Algebraic.HadamardComposition.outputCoordinate", + "PCP.Algebraic.HadamardComposition.mapCoefficients", + "LinearMap.comp", + "Pi.module", + "PCP.Algebraic.HadamardComposition.outputCoordinate._proof_1", + "LinearMap.proj", + "LinearEquiv.toLinearMap", + "PCP.Algebraic.HadamardComposition.fieldPolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.correct.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.correct c ζ f u v =\n PCP.Algebraic.WeightedConstraint.predict (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f u v", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.correct", + "PCP.Algebraic.WeightedConstraint.predict", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries_length_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n (PCP.Algebraic.BinaryLowDegreeTest.queries ⋯ ρ nodes s.2.2.2.2).length ≤ max (2 * 1 + 4) (c + 2) →\n ¬2 * r + 4 +\n (PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1 ρ nodes\n s.2.2.2.2).length +\n (c + 1) +\n (0 + 1) ≤\n 2 * r + 2 * c + 12 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "LE.le", + "instLENat", + "List.length", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "Prod.snd", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Max.max", + "Nat.instMax", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same equality oriented from the concrete certificate definition. ", + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Complexity.ReferenceNPConverse", + "name": "PCP.ReferenceNP.inNP_iff_mem", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : Complexity.Language}, PCP.InNP PCP.Machine.PolyTimeRel L ↔ L ∈ Complexity.NP", + "type_dependencies": [ + "Complexity.Language", + "Iff", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Membership.mem", + "Set", + "Set.instMembership", + "Complexity.NP" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (color : PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t)\n (validLines differenceLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t)\n (properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t)\n (color_1 :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (validCert_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (difference_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (properCert_1 :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (colorLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t)\n (validLines_1 differenceLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t)\n (properLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t),\n ({ color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines } =\n { color := color_1, validCert := validCert_1, difference := difference_1, properCert := properCert_1,\n colorLines := colorLines_1, validLines := validLines_1, differenceLines := differenceLines_1,\n properLines := properLines_1 }) =\n (color = color_1 ∧\n validCert = validCert_1 ∧\n difference = difference_1 ∧\n properCert = properCert_1 ∧\n colorLines = colorLines_1 ∧\n validLines = validLines_1 ∧ differenceLines = differenceLines_1 ∧ properLines = properLines_1)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Arbitrary point-dependent weights, including zero, are supported by the cubic transfer. ", + "end_line": 226, + "is_class": false, + "kind": "theorem", + "line": 214, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.weightedCubic_rejection_transfer", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (E : (Fin n → F) → F) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) (f : (Fin n → F) → F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ (E x * (f x ^ 3 - 1))))) M A ≤\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ (fun x => PCP.Algebraic.HadamardDerivedOracle.weightedCubic (E x)) ⋯\n nodes ζ H p M A +\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ p f", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Rat.instAdd", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_weightedCubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Replacing the two received tables changes rejection by at most their actual query errors. ", + "end_line": 231, + "is_class": false, + "kind": "theorem", + "line": 203, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate_le_add_errors", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [Field F] [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] {t r : ℕ}\n (hr : 1 ≤ r) (f f' : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (g g' : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr f' g' ≤\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr f g +\n 2 * PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f f' +\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr g g'", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Sum", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "instFintypeSum", + "instDecidableEqSum" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each actual vertex coordinate is the corresponding digit of its supplied index. ", + "end_line": 128, + "is_class": false, + "kind": "theorem", + "line": 121, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding_coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (eV : V ≃ Fin (Fintype.card V)) (v : V)\n (i :\n Fin (PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))),\n ↑((PCP.Algebraic.ThreeColorParameters.gridCode (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))\n ((PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding eV) v i)) =\n ↑(eV v) /\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)) ^\n ↑i %\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))", + "type_dependencies": [ + "Fintype", + "Equiv", + "Fin", + "Fintype.card", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Eq", + "Nat", + "Fin.val", + "DFunLike.coe", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorParameters.gridCode", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorBinaryVerifier.vertexEmbedding", + "HMod.hMod", + "instHMod", + "Nat.instMod", + "HDiv.hDiv", + "instHDiv", + "Nat.instDiv", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Express the decoded binary messages as field elements using the supplied\ncoordinate equivalence. The same field function satisfies both distance bounds. ", + "end_line": 135, + "is_class": false, + "kind": "theorem", + "line": 121, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.exists_field_function_of_average_rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} {F : Type u_2} {σ : Type u_3} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n ∃ f,\n PCP.Algebraic.relativeDistance (fun p => H p.1 p.2) (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ (f x)) ≤\n 28 * PCP.Algebraic.Hadamard.averageRejectionRate hr H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr H fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x)))) ≤\n 28 * PCP.Algebraic.Hadamard.averageRejectionRate hr H", + "type_dependencies": [ + "Nat", + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Exists", + "And", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.Hadamard.averageRejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The number of disagreements in a row, restricted to the given columns. ", + "end_line": 80, + "is_class": false, + "kind": "definition", + "line": 78, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.rowErrors", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {I : Type u_2} →\n [inst : Field F] → [DecidableEq F] → [Fintype I] → (I → F) → (I → Polynomial F) → (F → Polynomial F) → F → ℕ", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Nat" + ], + "value_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "hammingDist", + "Polynomial.eval" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.direct.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2}\n (motive : PCP.Reduction.NAEThreeColor.Vertex V C → PCP.Reduction.NAEThreeColor.Vertex V C → Sort u_3) (i j : Fin 3)\n (h_1 : (i j : Fin 3) → motive (Sum.inl i) (Sum.inl j))\n (h_2 : (val : V × Bool) → (i : Fin 3) → motive (Sum.inr (Sum.inl val)) (Sum.inl i))\n (h_3 : (v : V) → (b : Bool) → (w : V) → (d : Bool) → motive (Sum.inr (Sum.inl (v, b))) (Sum.inr (Sum.inl (w, d))))\n (h_4 : (e : C) → (i : Fin 3) → (f : C) → (j : Fin 3) → motive (Sum.inr (Sum.inr (e, i))) (Sum.inr (Sum.inr (f, j))))\n (h_5 : (e : C) → (i : Fin 3) → (x : PCP.Reduction.NAEThreeColor.Vertex V C) → motive (Sum.inr (Sum.inr (e, i))) x)\n (h_6 : (x x_1 : PCP.Reduction.NAEThreeColor.Vertex V C) → motive x x_1),\n (match Sum.inl i, Sum.inl j with\n | Sum.inl i, Sum.inl j => h_1 i j\n | Sum.inr (Sum.inl val), Sum.inl i => h_2 val i\n | Sum.inr (Sum.inl (v, b)), Sum.inr (Sum.inl (w, d)) => h_3 v b w d\n | Sum.inr (Sum.inr (e, i)), Sum.inr (Sum.inr (f, j)) => h_4 e i f j\n | Sum.inr (Sum.inr (e, i)), x => h_5 e i x\n | x, x_1 => h_6 x x_1) =\n h_1 i j", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk", + "Eq", + "PCP.Reduction.NAEThreeColor.direct.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The total-degree estimate in Fact 2.4. ", + "end_line": 109, + "is_class": false, + "kind": "theorem", + "line": 99, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.totalDegree_interpolate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽] [inst_1 : DecidableEq 𝔽] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n (H : Finset 𝔽) (f : (σ → ↥H) → 𝔽),\n ((PCP.Algebraic.GridInterpolation.interpolate H) f).totalDegree ≤ (H.card - 1) * Fintype.card σ", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "Semifield.toCommSemiring", + "Field.toSemifield", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.GridInterpolation.interpolate", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_2.else_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u} {β : Type v} {motive : α ⊕ β → Sort u_1} (t : α ⊕ β) (inr : (val : β) → motive (Sum.inr val))\n («else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),\n PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_2 t inr «else» = «else» h", + "type_dependencies": [ + "Sum", + "Sum.inr", + "Nat.hasNotBit", + "Sum.ctorIdx", + "Eq", + "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_2" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 87, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.eval_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (Q : σ → MvPolynomial σ R) (x y : σ → R),\n (MvPolynomial.eval (Sum.elim x y)) (PCP.Algebraic.GridVanishing.certificate Q) =\n ∑ i, (MvPolynomial.eval x) (Q i) * y i", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum.elim", + "PCP.Algebraic.GridVanishing.certificate", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The agreement threshold for equality is strict. ", + "end_line": 69, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.eq_of_eval_agreement_gt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] [inst_2 : DecidableEq 𝔽] {m d : ℕ}\n (p q : MvPolynomial (Fin m) 𝔽),\n p.totalDegree ≤ d →\n q.totalDegree ≤ d →\n (↑d / ↑(Fintype.card 𝔽) <\n PCP.Algebraic.relativeAgreement (fun x => (MvPolynomial.eval x) p) fun x => (MvPolynomial.eval x) q) →\n p = q", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "LT.lt", + "Rat", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.relativeAgreement", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The concrete full-field test has a positive size-independent soundness gap. ", + "end_line": 214, + "is_class": false, + "kind": "theorem", + "line": 198, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate_ge_of_not_colorable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F] [NeZero m]\n [CharP F 2],\n 1 ≤ c →\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n 100 * (c * m ^ c) * H.card ≤ Fintype.card F →\n (H.card - 1) * n ≤ c * m ^ c →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n ¬G.Colorable 3 →\n ∀ (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorSoundnessBudget.gap c / 16 ≤\n PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "Finset.card", + "HSub.hSub", + "instHSub", + "instSubNat", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Not", + "SimpleGraph.Colorable", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat", + "Rat.instLE", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "PCP.Algebraic.ThreeColorSoundnessBudget.gap", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R}\n {polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)}\n {PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg_1 : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R}\n {polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)},\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 } →\n PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.interpolate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽] [inst_1 : DecidableEq 𝔽] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n (H : Finset 𝔽),\n PCP.Algebraic.GridInterpolation.interpolate H =\n ∑ a, (LinearMap.proj a).smulRight (PCP.Algebraic.GridInterpolation.basis H a)", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.GridInterpolation.interpolate", + "Finset.sum", + "LinearMap.addCommMonoid", + "Finset.univ", + "Pi.instFintype", + "Finset.Subtype.fintype", + "LinearMap.smulRight", + "PCP.Algebraic.GridInterpolation.interpolate._proof_1", + "LinearMap.proj", + "PCP.Algebraic.GridInterpolation.basis" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.distance_expect", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : DecidableEq B] (k l : A → B),\n PCP.Algebraic.relativeDistance k l = Finset.univ.expect fun a => if k a ≠ l a then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "ite", + "Ne", + "instDecidableNot", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.triangleWitness.match_1.eq_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Bool → Bool → Bool → Sort u_1) (x : Bool) (h_1 : Unit → motive false false true)\n (h_2 : Unit → motive true true false) (h_3 : (x : Bool) → motive false true x)\n (h_4 : (x x_1 x_2 : Bool) → motive x x_1 x_2),\n (match false, true, x with\n | false, false, true => h_1 ()\n | true, true, false => h_2 ()\n | false, true, x => h_3 x\n | x, x_1, x_2 => h_4 x x_1 x_2) =\n h_3 x", + "type_dependencies": [ + "Bool", + "Unit", + "Bool.false", + "Bool.true", + "Eq", + "PCP.Reduction.NAEThreeColor.triangleWitness.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Corollary 2.10, with the necessary nonempty-alphabet hypothesis. ", + "end_line": 130, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R),\n H.Nonempty →\n ∀ (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p ↔\n ∃ M, M.totalDegree ≤ p.totalDegree ∧ PCP.Algebraic.GridVanishing.IsCertificate H p M", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Iff", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Exists", + "Sum", + "And", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.GridVanishing.IsCertificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.triangleWitness.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool → Bool → Bool → Sort u_1) →\n (x x_1 x_2 : Bool) →\n (Unit → motive false false true) →\n (Unit → motive true true false) →\n ((x : Bool) → motive false true x) →\n ((x x_3 x_4 : Bool) →\n (x = false → x_3 = false → x_4 = true → False) →\n (x = true → x_3 = true → x_4 = false → False) → (x = false → x_3 = true → False) → motive x x_3 x_4) →\n motive x x_1 x_2", + "type_dependencies": [ + "Bool", + "Unit", + "Bool.false", + "Bool.true", + "Eq", + "False" + ], + "value_dependencies": [ + "Bool", + "Unit", + "Bool.false", + "Bool.true", + "Eq", + "False", + "Bool.casesOn", + "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_1", + "Unit.unit", + "Nat.hasNotBit", + "Bool.ctorIdx", + "Eq.ndrec", + "absurd", + "Nat", + "Nat.land", + "OfNat.ofNat", + "instOfNatNat", + "Nat.shiftRight", + "Nat.eq_of_beq_eq_true", + "Eq.refl", + "Eq.symm", + "False.elim", + "noConfusion_of_Nat", + "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_2" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A canonical budget *is* the closed-form function of the two constants.\n\nNamed for what it says. It is an equality of functions, not a proposition of type\n`Computable V.randomness`. None is needed downstream: the closed form is evidently computable, and\nthe verifier's efficiency is certified separately through `Verifier.ImplementedBy` and the machine\npredicates of `PCP/Complexity/Machine.lean`. ", + "end_line": 167, + "is_class": false, + "kind": "theorem", + "line": 160, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CanonicalRandomness.eq_closedForm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.randomness = fun n => a * Nat.clog 2 (n + 2) + b", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "Eq", + "PCP.Verifier.randomness", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.callQueries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n)\n (w : Fin t → ZMod 2) (s : PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t),\n PCP.Algebraic.DerivedZeroOnGrid.callQueries ρ nodes ζ a w s =\n PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ a s.1 s.2.1 s.2.2.1 w s.2.2.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Semiring.toMonoid", + "Eq", + "List", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.DerivedZeroOnGrid.callQueries", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.weightedCubic.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] (a : F),\n PCP.Algebraic.HadamardDerivedOracle.weightedCubic a = Polynomial.C a * PCP.Algebraic.HadamardDerivedOracle.cubic", + "type_dependencies": [ + "CommRing", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "PCP.Algebraic.HadamardDerivedOracle.cubic" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 249, + "is_class": false, + "kind": "theorem", + "line": 234, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier_translate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ) (x a : ι → ZMod 2),\n PCP.Algebraic.BLR.fourier (fun y => f (x + y)) a = PCP.Algebraic.BLR.fourier f a * PCP.Algebraic.BLR.character a x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.fourier", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The original all-parameter tester controls pair discrepancy when its table has degree zero. ", + "end_line": 150, + "is_class": false, + "kind": "theorem", + "line": 144, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.pairDisagreement_le_twice_rejectionRate_degree_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ 0),\n PCP.Algebraic.PointLineTest.pairDisagreement f ≤ 2 * PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.pairDisagreement", + "Pi.instFintype", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.PointLineTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 154, + "is_class": false, + "kind": "theorem", + "line": 146, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.eq_of_eval_grid_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] {m : ℕ} (H : Finset 𝔽) (p q : MvPolynomial (Fin m) 𝔽),\n (∀ (i : Fin m), MvPolynomial.degreeOf i p < H.card) →\n (∀ (i : Fin m), MvPolynomial.degreeOf i q < H.card) →\n (∀ (a : Fin m → ↥H), (MvPolynomial.eval fun i => ↑(a i)) p = (MvPolynomial.eval fun i => ↑(a i)) q) → p = q", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LT.lt", + "instLTNat", + "MvPolynomial.degreeOf", + "Finset.card", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A two-event union bound for normalized finite fractions. ", + "end_line": 194, + "is_class": false, + "kind": "theorem", + "line": 179, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.fraction_le_add_of_imp_or", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {I : Type u_1} [inst : Fintype I] (E B C : I → Prop),\n (∀ (i : I), E i → B i ∨ C i) →\n PCP.Algebraic.AffineLineSampling.fraction E ≤\n PCP.Algebraic.AffineLineSampling.fraction B + PCP.Algebraic.AffineLineSampling.fraction C", + "type_dependencies": [ + "Fintype", + "Or", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.AffineLineSampling.fraction", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 157, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CanonicalRandomness.logRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.LogRandomness a b", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.LogRandomness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.card_vertex._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} [inst : Fintype V] [inst_1 : Fintype C],\n ¬3 + (Fintype.card V * 2 + Fintype.card C * 3) = 3 + 2 * Fintype.card V + 3 * Fintype.card C → False", + "type_dependencies": [ + "Fintype", + "Not", + "Eq", + "Nat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 173, + "is_class": false, + "kind": "definition", + "line": 173, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.correction._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F], Nonempty F", + "type_dependencies": [ + "Field", + "Nonempty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Claim 3.2: evaluating the encoding at the power point recovers `P(x)`. ", + "end_line": 107, + "is_class": false, + "kind": "theorem", + "line": 100, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c →\n ∀ (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n ((PCP.Algebraic.SetMultilinear.encode m c) P) =\n Polynomial.eval x P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "LinearMap", + "RingHom.id", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Setting the certificate variables to zero does not increase total degree. ", + "end_line": 138, + "is_class": false, + "kind": "theorem", + "line": 133, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.totalDegree_substitute_zero_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] (M : MvPolynomial (σ ⊕ σ) R),\n ((PCP.Algebraic.GridVanishing.substitute fun x => 0) M).totalDegree ≤ M.totalDegree", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "MvPolynomial", + "Sum", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Some Walsh coefficient bounds the third moment whenever the energy is one. ", + "end_line": 298, + "is_class": false, + "kind": "theorem", + "line": 284, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.exists_coefficient_ge_cubic", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ),\n (PCP.Algebraic.BLR.average fun x => f x ^ 2) = 1 →\n ∃ a, ∑ b, PCP.Algebraic.BLR.fourier f b ^ 3 ≤ PCP.Algebraic.BLR.fourier f a", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "Rat.instOfNat", + "Exists", + "LE.le", + "Rat.instLE", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "PCP.Algebraic.BLR.fourier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t),\n PCP.Algebraic.ThreeColorFullFieldSampling.queries ρ nodes ζ H G s =\n match PCP.Algebraic.ThreeColorFullFieldSampling.decode s with\n | none => []\n | some a => PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorFullFieldSampling.test._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "Eq", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorFullFieldSampling.queries", + "PCP.Algebraic.ThreeColorFullFieldSampling.test.match_1", + "Option", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorFullFieldSampling.decode", + "Unit", + "List.nil", + "PCP.Algebraic.ThreeColorVerifier.queries" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d addr : ℕ} {onFalse onTrue : PCP.QueryTree d} {addr_1 : ℕ} {onFalse_1 onTrue_1 : PCP.QueryTree d},\n PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1 →\n addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 154, + "is_class": false, + "kind": "theorem", + "line": 146, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.degreeOf_assemble_one_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {k K : ℕ} (v : Fin (k + 1) → Polynomial F),\n (∀ (j : Fin (k + 1)), (v j).natDegree ≤ K) →\n MvPolynomial.degreeOf 1 (PCP.Algebraic.BerlekampWelchCertificate.assemble v) ≤ K", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial.degreeOf", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BerlekampWelchCertificate.assemble" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 37, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ}, 1 ≤ r → Function.Injective (PCP.Algebraic.Hadamard.encode r)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Fin", + "ZMod", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x = PCP.Algebraic.ThreeColorEncoding.vertexCount x", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "Nat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "PCP.Algebraic.ThreeColorEncoding.vertexCount" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.brecOn.eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {motive : (a : ℕ) → PCP.QueryTree a → Sort u} {a : ℕ} (t : PCP.QueryTree a)\n (F_1 : (a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t),\n PCP.QueryTree.brecOn t F_1 = F_1 a t (PCP.QueryTree.brecOn.go t F_1).2", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "Eq", + "PCP.QueryTree.brecOn", + "PProd", + "PCP.QueryTree.brecOn.go" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H =\n PCP.Algebraic.relativeDistance (PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ f H) fun x => true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Eq", + "Rat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample", + "instDecidableEqBool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual represented witness and rows obey one polynomial symbol-count bound. ", + "end_line": 161, + "is_class": false, + "kind": "theorem", + "line": 154, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.assignment_size_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (x : List Bool)\n (a : PCP.Machine.NPTableau.Assignment h q x),\n (PCP.Machine.NPTableau.witnessList a.1).length + PCP.Machine.ComputationTableau.tableauSize a.2 ≤\n Polynomial.eval x.length (PCP.Machine.NPTableau.sizePoly h q)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "PCP.Machine.NPTableau.Assignment", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "PCP.Machine.NPTableau.witnessList", + "Polynomial.eval", + "Prod.fst", + "PCP.Machine.NPTableau.BoundedWitness", + "Fin", + "PCP.Machine.NPTableau.timePoly", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.ComputationTableau.Row", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.snd", + "PCP.Machine.NPTableau.spacePoly", + "PCP.Machine.ComputationTableau.tableauSize", + "PCP.Machine.NPTableau.sizePoly" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), ¬M ≤ 1 → ¬1 < M → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), 8 ≤ max 8 (Nat.clog 2 N) → ¬2 * 2 ^ 2 ≤ 4 * max 8 (Nat.clog 2 N) → False", + "type_dependencies": [ + "Nat", + "LE.le", + "Preorder.toLE", + "PartialOrder.toPreorder", + "LinearOrder.toPartialOrder", + "Nat.instLinearOrder", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "LinearOrder.toMax", + "Nat.clog", + "Not", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Nat.instMax", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "theorem", + "line": 24, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.boolColor_inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : Bool), PCP.Reduction.NAEThreeColor.boolColor a = PCP.Reduction.NAEThreeColor.boolColor b ↔ a = b", + "type_dependencies": [ + "Bool", + "Iff", + "Eq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.boolColor" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 258, + "is_class": false, + "kind": "theorem", + "line": 251, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.autocorrelation", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ) (x : ι → ZMod 2),\n (PCP.Algebraic.BLR.average fun y => f y * f (x + y)) =\n ∑ a, PCP.Algebraic.BLR.fourier f a ^ 2 * PCP.Algebraic.BLR.character a x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} {a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.validCert a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The rejection of a fresh randomized derived read inherits any fixed honest-decision bound.\nThis theorem does not freeze a correction seed or postulate a fixed derived oracle. ", + "end_line": 195, + "is_class": false, + "kind": "theorem", + "line": 164, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.rejection_transfer", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} {I : Type u_2} [inst_2 : Fintype I]\n {A : Type u_3} {B : Type u_4} [inst_3 : Fintype A] [inst_4 : DecidableEq B] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : I → Polynomial F) (hP : ∀ (i : I), (P i).natDegree ≤ r)\n (H : I → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) (f : I → F)\n (L : I → A → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (decision : I → A → ZMod 2 → B)\n (accept : I → A → B),\n (PCP.Algebraic.relativeDistance\n (fun s => decision s.1 s.2 ((PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval (f s.1) (P s.1)))) (L s.1 s.2)))\n fun s => accept s.1 s.2) ≤\n (PCP.Algebraic.relativeDistance\n (fun s =>\n decision s.1 s.2.1 (PCP.Algebraic.HadamardDerivedOracle.answer ρ (P s.1) ⋯ (H s.1) (L s.1 s.2.1) s.2.2))\n fun s => accept s.1 s.2.1) +\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ H f", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Pi.instFintype", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every nonzero parameter sends a uniform direction to a uniform field point. ", + "end_line": 131, + "is_class": false, + "kind": "theorem", + "line": 120, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.affine_units_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (a : σ → F) (f g : (σ → F) → F),\n (PCP.Algebraic.relativeDistance (fun s => f (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2)) fun s =>\n g (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.PolynomialLine.point", + "Prod.fst", + "Units.val", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {randomness : ℕ → ℕ} {queries : ℕ} {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries}\n {randomness_1 : ℕ → ℕ} {queries_1 : ℕ}\n {run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1},\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 } →\n randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "And", + "HEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.totalDegree_interpolateSlices_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n d : ℕ} {a : Fin (d + 1) → F} (P : Fin (d + 1) → MvPolynomial (Fin n) F)\n (i : Fin (d + 1)),\n (Lagrange.basis Finset.univ a i).natDegree = d →\n ((Polynomial.toMvPolynomial 0) (Lagrange.basis Finset.univ a i)).totalDegree ≤\n (Lagrange.basis Finset.univ a i).natDegree →\n ((MvPolynomial.rename Fin.succ) (P i)).totalDegree ≤ d →\n ¬((Polynomial.toMvPolynomial 0) (Lagrange.basis Finset.univ a i)).totalDegree +\n ((MvPolynomial.rename Fin.succ) (P i)).totalDegree ≤\n 2 * d →\n False", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "Lagrange.basis", + "instDecidableEqFin", + "Finset.univ", + "Fin.fintype", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "AlgHom", + "Polynomial", + "Polynomial.semiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Polynomial.algebraOfAlgebra", + "Algebra.id", + "AddMonoidAlgebra.algebra", + "AlgHom.funLike", + "Polynomial.toMvPolynomial", + "Fin.instOfNat", + "instNeZeroNatHAdd_1", + "Nat.instNeZeroSucc", + "Preorder.toLE", + "Nat.instPreorder", + "MvPolynomial.rename", + "Fin.succ", + "Not", + "PCP.Algebraic.PolynomialLine.interpolateSlices._proof_1", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A Boolean solution yields actual symbols, and each relation sees those same symbols. ", + "end_line": 116, + "is_class": false, + "kind": "theorem", + "line": 97, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.exists_symbols", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ} (R : C → (Fin d → Fin a) → Bool) (s : C → Fin d → V)\n (b : PCP.Reduction.FiniteDomainConstraints.Variable V a → Bool),\n PCP.Reduction.FiniteBooleanConstraints.LocalHolds (PCP.Reduction.FiniteDomainConstraints.relation R)\n (PCP.Reduction.FiniteDomainConstraints.scope s) b →\n ∃ x, PCP.Reduction.FiniteDomainConstraints.Holds R s x", + "type_dependencies": [ + "Nat", + "Fin", + "Bool", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.LocalHolds", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.relation", + "PCP.Reduction.FiniteDomainConstraints.scope", + "Exists", + "PCP.Reduction.FiniteDomainConstraints.Holds" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Small actual rejection implies ordinary three-colorability, with every\npolynomial and proximity bound constructed from the four low-degree checks. ", + "end_line": 112, + "is_class": false, + "kind": "theorem", + "line": 56, + "module": "PCP.Algebraic.ThreeColorVerifierSoundness", + "name": "PCP.Algebraic.ThreeColorVerifier.colorable_of_rejection_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] {n m c t : ℕ} [NeZero m]\n [CharP F 2],\n 1 ≤ c →\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n 100 * (c * m ^ c) * H.card ≤ Fintype.card F →\n (H.card - 1) * n ≤ c * m ^ c →\n ∀ (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π <\n PCP.Algebraic.ThreeColorSoundnessBudget.gap c →\n G.Colorable 3", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "Finset.card", + "HSub.hSub", + "instHSub", + "instSubNat", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "LT.lt", + "Rat", + "Rat.instLT", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.ThreeColorSoundnessBudget.gap", + "SimpleGraph.Colorable" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 74, + "is_class": false, + "kind": "definition", + "line": 74, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.const.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u} →\n (t : PCP.Reduction.NAEThreeColor.Literal V) →\n t.ctorIdx = 0 → ((a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a)) → motive t", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "Nat", + "PCP.Reduction.NAEThreeColor.Literal.ctorIdx", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "Nat", + "PCP.Reduction.NAEThreeColor.Literal.ctorIdx", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 113, + "is_class": false, + "kind": "theorem", + "line": 111, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.rejectionProbability_addHom", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] [inst_1 : AddZeroClass V] (L : V →+ ZMod 2),\n PCP.Algebraic.BLR.rejectionProbability ⇑L = 0", + "type_dependencies": [ + "Fintype", + "AddZeroClass", + "AddMonoidHom", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddMonoidWithOne.toAddMonoid", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Eq", + "Rat", + "PCP.Algebraic.BLR.rejectionProbability", + "AddZero.toAdd", + "DFunLike.coe", + "AddMonoidHom.instFunLike", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Homogeneous linear forms, parametrized by their `t` binary coefficients. ", + "end_line": 139, + "is_class": false, + "kind": "definition", + "line": 136, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{t : ℕ} → (Fin t → ZMod 2) → (Fin t → ZMod 2) →ₗ[ZMod 2] ZMod 2", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Finset.sum", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.addCommMonoid", + "Finset.univ", + "Fin.fintype", + "HSMul.hSMul", + "Pi.module", + "instHSMul", + "LinearMap.instSMul", + "NonUnitalNonAssocSemiring.toDistribSMul", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "ZMod.commRing", + "PCP.Algebraic.Hadamard.linearEncode._proof_1", + "LinearMap.proj" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eq_interpolation", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v =\n PCP.Algebraic.LagrangeConstraint.check (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) f u v 0", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "PCP.Algebraic.LagrangeConstraint.check", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → [SizeOf F] → PCP.Algebraic.ThreeColorVerifier.Query F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.rec", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "SizeOf.sizeOf", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (6 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 85, + "is_class": false, + "kind": "definition", + "line": 84, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.output", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} → (h : PCP.Machine.NPTableau.Checker R) → Bool → List (h.tm.Γ h.tm.k₁)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Turing.FinTM2.Γ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.k₁" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "List.map", + "PCP.Machine.Sym", + "Turing.FinTM2.Γ", + "Turing.TM2ComputableAux.tm", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.k₁", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "Turing.TM2ComputableAux.outputAlphabet" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t", + "type_dependencies": [ + "Bool", + "Bool.true", + "Nat.hasNotBit", + "Bool.ctorIdx" + ], + "value_dependencies": [ + "Bool", + "Bool.true", + "Bool.rec", + "Nat.hasNotBit", + "Bool.ctorIdx", + "Bool.false", + "Nat.ne_of_beq_eq_false", + "Nat.land", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Nat.shiftRight", + "Eq.refl" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.field_bounds._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d q : ℕ}, 1000000 * d ^ 3 ≤ q → ¬1000 * d ^ 3 ≤ q → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each concrete NP checker has an unconditional polynomial-time graph reduction. ", + "end_line": 190, + "is_class": false, + "kind": "theorem", + "line": 167, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.checker_reduction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ),\n ∃ f p,\n PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits f ∧\n ∀ (x : List Bool),\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔\n ∃ w, w.length ≤ Polynomial.eval x.length q ∧ R x w = true) ∧\n (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Exists", + "And", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 106, + "is_class": false, + "kind": "theorem", + "line": 92, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.distance_sample_origin", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] {A : Type u_3} [inst_5 : DecidableEq A]\n (k l : (σ → F) → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k s.1 s.2.2.1.2) fun s => l s.1 s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v = f u - PCP.Algebraic.GeneratorLowDegreeTest.correct c ζ f u v", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.GeneratorLowDegreeTest.correct" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "definition", + "line": 131, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t r : ℕ} →\n (motive : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t r → Sort u_2) →\n (x : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t r) →\n ((q : (Fin n → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl q)) →\n ((q :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n ×\n PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t) →\n motive (Sum.inr q)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 45, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.properLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries_length_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n (PCP.Algebraic.BinaryZeroOnGridCorrection.queries ρ nodes ζ H (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)).length ≤\n 6 * c + 19 →\n ¬(PCP.Algebraic.BinaryZeroOnGridCorrection.queries ρ nodes ζ H\n (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)).length +\n 1 ≤\n 6 * c + 20 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "PCP.Algebraic.BinaryZeroOnGridCorrection.queries", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A point-dependent weight can be absorbed into the same cubic query. ", + "end_line": 207, + "is_class": false, + "kind": "definition", + "line": 206, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : CommRing F] → F → Polynomial F", + "type_dependencies": [ + "CommRing", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring" + ], + "value_dependencies": [ + "CommRing", + "HMul.hMul", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "PCP.Algebraic.HadamardDerivedOracle.cubic" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.queries c ζ u v =\n u :: List.ofFn fun i => PCP.Algebraic.PolynomialLine.point u v (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i)", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "List", + "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "List.cons", + "List.ofFn", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.exists_nonzero_columns._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype I] {d e : ℕ} (a : I → F)\n (E : MvPolynomial (Fin 2) F),\n d + e < Fintype.card I →\n {i | PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i) = 0}.card ≤ e →\n {i | PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i) = 0}.card +\n {a_1 | ¬PCP.Algebraic.PointLineCrossing.rowPolynomial E (a a_1) = 0}.card =\n Finset.univ.card →\n {i | PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i) = 0}.card +\n {i | PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i) ≠ 0}.card =\n Fintype.card I →\n ¬d + 1 ≤ {i | PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i) ≠ 0}.card → False", + "type_dependencies": [ + "Field", + "Fintype", + "Nat", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LT.lt", + "instLTNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fintype.card", + "LE.le", + "instLENat", + "Finset.card", + "Finset.filter", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "Zero.toOfNat0", + "Polynomial.instZero", + "Polynomial.instDecidableEq", + "Classical.propDecidable", + "Finset.univ", + "Not", + "instDecidableNot", + "Ne", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 82, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "_private.PCP.Algebraic.WeightedConstraintSoundness.0.PCP.Algebraic.WeightedConstraint.grid_error", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] [inst_4 : DecidableEq F] [inst_5 : Fintype V] (a w : I → F),\n (∀ (i : I), a i ≠ 0) →\n ∀ (f : V → F) (x z : V),\n (PCP.Algebraic.relativeDistance (fun s => PCP.Algebraic.WeightedConstraint.predict a w f x s.1) fun s =>\n ∑ i, w i * PCP.Algebraic.WeightedConstraint.predict a w f (x + a i • s.1) (z + a i • s.2)) ≤\n ↑(Fintype.card I) * PCP.Algebraic.WeightedConstraint.rejectionRate a w f", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "PCP.Algebraic.WeightedConstraint.predict", + "Prod.fst", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HAdd.hAdd", + "instHAdd", + "AddCommMagma.toAdd", + "AddCommSemigroup.toAddCommMagma", + "AddCommMonoid.toAddCommSemigroup", + "HSMul.hSMul", + "instHSMul", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction", + "Prod.snd", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.WeightedConstraint.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Zero weights need no exclusion; the honest weighted cubic identity still holds. ", + "end_line": 241, + "is_class": false, + "kind": "theorem", + "line": 235, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.answer_weightedCubic_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} [inst_2 : Nontrivial F]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (a u : F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (R : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n PCP.Algebraic.HadamardDerivedOracle.answer ρ (PCP.Algebraic.HadamardDerivedOracle.weightedCubic a) ⋯\n (⇑(PCP.Algebraic.Hadamard.encode 3 (ρ u))) L R =\n (PCP.Algebraic.Hadamard.encode 1 (ρ (a * (u ^ 3 - 1)))) L", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Nontrivial", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_weightedCubic_le", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t →\n {F' : Type u_2} → {n' m' c' t' : ℕ} → PCP.Algebraic.ThreeColorVerifier.Query F' n' m' c' t' → Sort u", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "dite", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Nat.decEq", + "PCP.Algebraic.ThreeColorVerifier.Query.color.elim", + "HEq", + "Not", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.difference.elim", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert.elim", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine.elim" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A row always has a decoded message satisfying both linear-in-rejection bounds.\nRows above the soundness threshold use only the universal distance bound. ", + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.exists_row_message_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n ∃ x,\n PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.Hadamard.encode r x) ≤\n 28 * PCP.Algebraic.Hadamard.testRejectionRate hr H ∧\n (PCP.Algebraic.relativeDistance (fun w => H ((PCP.Algebraic.Hadamard.homogeneousIndex hr) w)) fun w =>\n (PCP.Algebraic.Hadamard.encode r x) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) w)) ≤\n 28 * PCP.Algebraic.Hadamard.testRejectionRate hr H", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Exists", + "Fin", + "And", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.Hadamard.testRejectionRate", + "PCP.Algebraic.Hadamard.homogeneousIndex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate_nodes._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.LagrangeConstraint.check (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) f u v 0 =\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.LagrangeConstraint.check", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.check" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Encode all source symbols in one-hot form; the unused dummy block is false. ", + "end_line": 70, + "is_class": false, + "kind": "definition", + "line": 67, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.encodeAssignment", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → {a : ℕ} → (V → Fin a) → PCP.Reduction.FiniteDomainConstraints.Variable V a → Bool", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "Bool" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.encodeAssignment.match_1", + "Bool", + "Decidable.decide", + "Eq", + "instDecidableEqFin", + "Unit", + "Bool.false" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 154, + "is_class": false, + "kind": "definition", + "line": 150, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.secondLabelEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_3} → {W : Type u_4} → (V × V) × W ≃ (V × W) × V", + "type_dependencies": [ + "Equiv", + "Prod" + ], + "value_dependencies": [ + "Equiv.mk", + "Prod", + "Prod.mk", + "Prod.snd", + "Prod.fst", + "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.secondLabelEquiv._proof_1", + "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.secondLabelEquiv._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.test.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t : ℕ} →\n (motive : Option (PCP.Algebraic.ThreeColorVerifier.Sample F n m c t) → Sort u_2) →\n (x : Option (PCP.Algebraic.ThreeColorVerifier.Sample F n m c t)) →\n (Unit → motive none) → ((a : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t) → motive (some a)) → motive x", + "type_dependencies": [ + "Field", + "Nat", + "Option", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Unit", + "Option.none", + "Option.some" + ], + "value_dependencies": [ + "Field", + "Nat", + "Option", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Unit", + "Option.none", + "Option.some", + "Option.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness for every random seed of the actual corrected test. ", + "end_line": 156, + "is_class": false, + "kind": "theorem", + "line": 139, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.check_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {H : Finset F} (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n M.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H P M →\n ∀ (s : PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.check ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P))))\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M))))\n (PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M) s =\n some (0, 0)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "MvPolynomial", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary", + "Option.some", + "Prod.mk", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The outer theorem's field hypothesis implies the weaker inner tester bound,\nincluding degree zero. ", + "end_line": 59, + "is_class": false, + "kind": "theorem", + "line": 52, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.field_bound_linear", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d q : ℕ}, 1 < q → PCP.Algebraic.PointLineConstants.fieldFactor * d ^ 3 ≤ q → 2 * d < q", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.eq_def", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 : PCP.ProofOracle),\n x_1.eval x_2 =\n match x, x_1, x_2 with\n | x, PCP.QueryTree.leaf b, x_3 => b\n | .(d + 1), PCP.QueryTree.query a f t, π => if π a = true then t.eval π else f.eval π", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Eq", + "Bool", + "PCP.QueryTree.eval", + "PCP.QueryTree.eval.match_1", + "ite", + "Bool.true", + "instDecidableEqBool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.correctedAt.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (ζ : F) (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (parameter : Fˣ → F) (s : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H parameter s =\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H s.1)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c (parameter s.2.1)) s.2.2.1.1 s.2.2.1.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Five small errors force a candidate row and a nearest column to agree at\ntheir crossing. The comparison bivariate polynomial is constructed by agreement. ", + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 25, + "module": "PCP.Algebraic.CandidateCrossing", + "name": "PCP.Algebraic.CandidateCrossing.crossing_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ},\n 0 < d →\n 1000 * d ^ 3 ≤ Fintype.card F →\n ∀ (M : F × F → F) (R C : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n (∀ (z : F), (C z).natDegree ≤ d) →\n ∀ (y₀ z₀ : F) {ε : ℚ},\n ε ≤ 1 / 100 →\n (PCP.Algebraic.relativeDistance M fun yz => Polynomial.eval yz.2 (R yz.1)) ≤ ε →\n (PCP.Algebraic.relativeDistance M fun yz => Polynomial.eval yz.1 (C yz.2)) ≤ ε →\n (PCP.Algebraic.relativeDistance (fun z => M (y₀, z)) fun z => Polynomial.eval y₀ (C z)) ≤ ε →\n (PCP.Algebraic.relativeDistance (fun y => M (y, z₀)) fun y => Polynomial.eval z₀ (R y)) ≤ ε →\n (PCP.Algebraic.relativeDistance (fun z => M (y₀, z)) fun x => Polynomial.eval x (R y₀)) ≤ ε →\n (∀ (p : Polynomial F),\n p.natDegree ≤ d →\n (PCP.Algebraic.relativeDistance (fun y => M (y, z₀)) fun x =>\n Polynomial.eval x (C z₀)) ≤\n PCP.Algebraic.relativeDistance (fun y => M (y, z₀)) fun x => Polynomial.eval x p) →\n 6 * ε + 2 * (↑d / ↑(Fintype.card F)) < 1 / 2 →\n Polynomial.eval z₀ (R y₀) = Polynomial.eval y₀ (C z₀)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "Prod", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial.natDegree", + "Rat", + "Rat.instLE", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "Prod.snd", + "Prod.fst", + "Prod.mk", + "Rat.instLT", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual correction error averaged over every seed, for an arbitrary chosen inner table. ", + "end_line": 232, + "is_class": false, + "kind": "theorem", + "line": 206, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.correction_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (Q :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F),\n (∀ (uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ), (Q uv).totalDegree ≤ c) →\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H) fun s =>\n (PCP.Algebraic.Hadamard.linearEncode\n (ρ (Polynomial.eval s.2.1 ((PCP.Algebraic.SetMultilinear.decode m c) (Q s.1)))))\n s.2.2.1.2) ≤\n ↑(c + 1) *\n Finset.univ.expect fun uv =>\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ (H uv) fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) (Q uv))))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "ZMod.decidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "Fin.fintype", + "instDecidableEqProd", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "PCP.Algebraic.Hadamard.encode", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.expect_sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (k : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → ℚ),\n (Finset.univ.expect fun s => k s) =\n Finset.univ.expect fun b =>\n Finset.univ.expect fun z => Finset.univ.expect fun vw => Finset.univ.expect fun s => k (b, z, vw, s)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 152, + "is_class": false, + "kind": "theorem", + "line": 142, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.predictedCell_step", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} {p : PCP.Machine.TableauCells.Prefix tm} {s : PCP.Machine.TableauCells.Cells tm B}\n {c : tm.Cfg},\n PCP.Machine.TableauCells.Represents p s c →\n PCP.Machine.TableauCells.Linked p s →\n ∀ (k : tm.K) (j : ℕ),\n PCP.Machine.TableauCells.predictedCell p k j (PCP.Machine.TableauCells.candidates s k j) =\n ((PCP.Machine.keepStep tm.step c).stk k)[j]?", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Represents", + "PCP.Machine.TableauCells.Linked", + "Turing.FinTM2.K", + "Eq", + "Option", + "Turing.FinTM2.Γ", + "PCP.Machine.TableauCells.predictedCell", + "PCP.Machine.TableauCells.candidates", + "GetElem?.getElem?", + "List", + "LT.lt", + "instLTNat", + "List.length", + "List.instGetElem?NatLtLength", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.keepStep", + "Turing.FinTM2.step" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Search the coordinate-induced field order for the first nontrivial cube root. ", + "end_line": 86, + "is_class": false, + "kind": "definition", + "line": 83, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.cubeRoot", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → PCP.Algebraic.ThreeColorFields.FieldFamily k", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorFields.FieldFamily" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.FiniteRootSearch.root", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Equiv.decidableEq", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.ThreeColorFields.fieldCode", + "instDecidableEqFin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Zero rejection for the actual honest proof and both honest correction tables. ", + "end_line": 188, + "is_class": false, + "kind": "theorem", + "line": 178, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : NeZero m] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {H : Finset F} (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n M.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H P M →\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P))))\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M))))\n (PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M) =\n 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "MvPolynomial", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "Eq", + "Rat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.firstSlot", + "provenance": "lean", + "structural_dependencies": [], + "type": "{a d : ℕ} → Fin a → Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.arity" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.slot", + "Fin.mk", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.FiniteDomainConstraints.firstSlot._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} {a_2 : PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3},\n PCP.Algebraic.ThreeColorVerifier.Query.color a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.color a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The explicit graph is three-colorable exactly for satisfiable NAE instances. ", + "end_line": 247, + "is_class": false, + "kind": "theorem", + "line": 240, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.colorable_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V),\n (PCP.Reduction.NAEThreeColor.graph Q).Colorable 3 ↔\n ∃ a, ∀ (e : C), PCP.Reduction.NAEThreeColor.NAE fun i => PCP.Reduction.NAEThreeColor.Literal.eval a (Q e i)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Iff", + "SimpleGraph.Colorable", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "Exists", + "Bool", + "PCP.Reduction.NAEThreeColor.NAE", + "PCP.Reduction.NAEThreeColor.Literal.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeAnswer.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((a : ℕ) → motive (Sum.inr a)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "constructor", + "line": 128, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.rejectionAt.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] {inst_2 : DecidableEq F} [inst_3 : DecidableEq F]\n [inst_4 : Fintype σ] {inst_5 : DecidableEq σ} [inst_6 : DecidableEq σ] (c c_1 : ℕ),\n c = c_1 →\n ∀ (f f_1 : (σ → F) → F),\n f = f_1 →\n ∀ (t t_1 : F),\n t = t_1 → PCP.Algebraic.PointLineTest.rejectionAt c f t = PCP.Algebraic.PointLineTest.rejectionAt c_1 f_1 t_1", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "PCP.Algebraic.PointLineTest.rejectionAt" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Average of the actual normalized HadTest rejection rates over all rows. ", + "end_line": 63, + "is_class": false, + "kind": "definition", + "line": 60, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.averageRejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{ι : Type u_1} →\n {t r : ℕ} → [Fintype ι] → 1 ≤ r → (ι → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) → ℚ", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Rat" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "PCP.Algebraic.Hadamard.testRejectionRate", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The noncentral weights sum to one, so with `η₀ = -1` and `0^0 = 1` the weighted sum of the\nconstant monomial vanishes. The forward direction of Fact 2.7 is proved through uniqueness of\nLagrange interpolation instead and does not use this identity; it is retained for\n`PCP/Audit/GeneratorLowDegree.lean`. ", + "end_line": 109, + "is_class": false, + "kind": "theorem", + "line": 103, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.sum_weights", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) → ∑ i, PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i = 1", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "Finset.sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Semiring.toAddCommMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Finset.univ", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (f : α → ℚ), PCP.Algebraic.BLR.average f = (∑ x, f x) / ↑(Fintype.card α)", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.eval_differencePolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (P : MvPolynomial σ R) (a b : σ → R),\n (MvPolynomial.eval (Sum.elim a b)) (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P) =\n (MvPolynomial.eval a) P - (MvPolynomial.eval b) P", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum.elim", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Only the first `N` proof bits matter when `V.ReadsBelow x N`. ", + "end_line": 128, + "is_class": false, + "kind": "theorem", + "line": 121, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_congr_of_readsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) {N : ℕ},\n V.ReadsBelow x N → ∀ {π π' : PCP.ProofOracle}, (∀ a < N, π a = π' a) → V.accProb x π = V.accProb x π'", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Nat", + "PCP.Verifier.ReadsBelow", + "PCP.ProofOracle", + "LT.lt", + "instLTNat", + "Eq", + "Rat", + "PCP.Verifier.accProb" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V) (eV : V ≃ Fin (Fintype.card V)),\n PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph G eV =\n PCP.Algebraic.ThreeColorGridIndex.pad\n (PCP.Algebraic.ThreeColorParameters.gridCode (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))\n (PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))\n (SimpleGraph.comap (⇑eV.symm) G)", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "Equiv", + "Fin", + "Fintype.card", + "Eq", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "PCP.Algebraic.ThreeColorGridIndex.pad", + "PCP.Algebraic.ThreeColorParameters.gridCode", + "SimpleGraph.comap", + "DFunLike.coe", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "SMulCommClass (ZMod 2) (ZMod 2) (ZMod 2)", + "type_dependencies": [ + "SMulCommClass", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Algebra.toSMul", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Algebra.id", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.fraction_shared_snd", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (E : W × S → Prop),\n (PCP.Algebraic.AffineLineSampling.fraction fun s => E (s.1, s.2.2)) = PCP.Algebraic.AffineLineSampling.fraction E", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.AffineLineSampling.fraction", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : Type u_1) →\n (motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u_2) →\n (x : PCP.Reduction.NAEThreeColor.Literal V) →\n ((a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a)) →\n ((a : V) → (a_1 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)) → motive x", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ),\n PCP.Algebraic.SetMultilinear.decode m c =\n MvPolynomial.eval₂Hom Polynomial.C fun ij => Polynomial.X ^ (↑ij.2 * m ^ ↑ij.1)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "Eq", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "PCP.Algebraic.SetMultilinear.decode", + "MvPolynomial.eval₂Hom", + "Polynomial.commSemiring", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.X", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "definition", + "line": 133, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 6 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 226, + "is_class": false, + "kind": "theorem", + "line": 222, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_differenceQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.differenceQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.difference π.differenceLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 90, + "is_class": false, + "kind": "theorem", + "line": 87, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.input_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) {x w : List Bool},\n w.length ≤ Polynomial.eval x.length q →\n (PCP.Machine.NPTableau.input h x w).length ≤ Polynomial.eval x.length (PCP.Machine.NPTableau.inputPoly q)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Turing.FinTM2.Γ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.k₀", + "PCP.Machine.NPTableau.input", + "PCP.Machine.NPTableau.inputPoly" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A bound linear in the inner degree and primary Hadamard degree. ", + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 71, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries hr ρ nodes ζ s).length ≤ 2 * r + 2 * c + 12", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm_comm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2),\n (PCP.Algebraic.BLR.linearForm a) x = (PCP.Algebraic.BLR.linearForm x) a", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Reduction.NAEThreeColor.triangleWitness false false true = ![1, 2, 0]", + "type_dependencies": [ + "Eq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.triangleWitness", + "Bool.false", + "Bool.true", + "Matrix.vecCons", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Different formal polynomials force the predicted half-distance rejection. ", + "end_line": 292, + "is_class": false, + "kind": "theorem", + "line": 279, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate_encode_ge_of_ne", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n {t r D : ℕ} [inst_4 : Algebra (ZMod 2) F] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (P : MvPolynomial σ F)\n (Q : MvPolynomial (σ ⊕ σ) F),\n P.totalDegree ≤ D →\n Q.totalDegree ≤ D →\n Q ≠ PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P →\n (1 - ↑D / ↑(Fintype.card F)) / 2 ≤\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P)))) fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) Q)))", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Algebra", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "MvPolynomial.totalDegree", + "Ne", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "Field.toCommRing", + "Rat", + "Rat.instLE", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "recursor", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → (t : PCP.Machine.Sym) → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 156, + "is_class": false, + "kind": "theorem", + "line": 155, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character_sq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2), PCP.Algebraic.BLR.character a x ^ 2 = 1", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.character", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.honestProof._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.PointLineEndpointConsistency.mixedGrid.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (f : (σ → F) → F) (u : σ → F)\n (seed : PCP.Algebraic.MixedPlaneSampling.MixedSeed F σ) (yz : F × F),\n PCP.Algebraic.PointLineEndpointConsistency.mixedGrid f u seed yz =\n f (PCP.Algebraic.MixedPlaneSampling.mixedPlanePoint u seed yz.1 yz.2)", + "type_dependencies": [ + "Field", + "PCP.Algebraic.MixedPlaneSampling.MixedSeed", + "Prod", + "Eq", + "PCP.Algebraic.PointLineEndpointConsistency.mixedGrid", + "PCP.Algebraic.MixedPlaneSampling.mixedPlanePoint", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Interpolate polynomials in the remaining variables at selected first coordinates. ", + "end_line": 53, + "is_class": false, + "kind": "definition", + "line": 50, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.interpolateSlices", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n d : ℕ} → (Fin (d + 1) → F) → (Fin (d + 1) → MvPolynomial (Fin n) F) → MvPolynomial (Fin (n + 1)) F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "DFunLike.coe", + "AlgHom", + "Polynomial", + "Polynomial.semiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Polynomial.algebraOfAlgebra", + "Algebra.id", + "AddMonoidAlgebra.algebra", + "AlgHom.funLike", + "Polynomial.toMvPolynomial", + "Fin.instOfNat", + "PCP.Algebraic.PolynomialLine.interpolateSlices._proof_1", + "Lagrange.basis", + "instDecidableEqFin", + "MvPolynomial.rename", + "Fin.succ" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.run_length_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {T B : ℕ} {initial : tm.Cfg},\n PCP.Machine.mass initial.stk + PCP.Machine.machinePushBound tm * T ≤ B →\n ∀ (i : Fin (T + 1)),\n PCP.Machine.mass (PCP.Machine.boundedEval tm (↑i) initial).stk ≤\n PCP.Machine.mass initial.stk + PCP.Machine.machinePushBound tm * ↑i →\n PCP.Machine.machinePushBound tm * ↑i ≤ PCP.Machine.machinePushBound tm * T →\n ¬PCP.Machine.mass (PCP.Machine.boundedEval tm (↑i) initial).stk ≤ B → False", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.mass", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.kFin", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Machine.machinePushBound", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.boundedEval", + "Fin.val", + "Not", + "Preorder.toLE", + "Nat.instPreorder", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_comm._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),\n ∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a", + "type_dependencies": [ + "DivisionSemiring", + "Finset", + "Eq", + "Finset.sum", + "Semiring.toAddCommMonoid", + "DivisionSemiring.toSemiring", + "HDiv.hDiv", + "instHDiv", + "DivInvMonoid.toDiv", + "GroupWithZero.toDivInvMonoid", + "DivisionSemiring.toGroupWithZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "definition", + "line": 127, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.difference a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.sizePoly", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} → PCP.Machine.NPTableau.Checker R → Polynomial ℕ → ℕ → ℕ → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (c : ℕ) (ζ : F)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (u v : σ → F) (w : Fin t → ZMod 2),\n PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ u v w =\n List.ofFn fun i =>\n (PCP.Algebraic.PolynomialLine.point u v (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i),\n (PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_2)\n ((PCP.Algebraic.HadamardWeights.scaleLabel ρ (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i)) w))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "List", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "List.ofFn", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_2", + "PCP.Algebraic.HadamardWeights.scaleLabel", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (a b : σ → F) (z : Fˣ)\n (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ a b z v w s =\n Sum.inl\n (PCP.Algebraic.PolynomialLine.point a b ↑z,\n (PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.BinaryLocalCorrection.run._proof_2) w) ::\n (List.map (fun p => Sum.inr (b, p))\n (PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.BinaryLocalCorrection.run._proof_2 ρ nodes s) ++\n List.map (fun p => Sum.inr (b, p))\n (PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c ↑z) v w) ++\n List.map (fun p => Sum.inr (b, p))\n (PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c 0) v w))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Eq", + "List", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "List.cons", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "Units.val", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "HAppend.hAppend", + "Sum", + "PCP.Algebraic.SetMultilinear.Variables", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (P : MvPolynomial σ R),\n PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P =\n (MvPolynomial.rename Sum.inl) P - (MvPolynomial.rename Sum.inr) P", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "Sum", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "DFunLike.coe", + "AlgHom", + "AddMonoidAlgebra.semiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) (a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.difference a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (color : PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t)\n (validLines differenceLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t)\n (properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t),\n sizeOf\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines } =\n 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.1's constant total-degree bound. ", + "end_line": 151, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.totalDegree_encode_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n ((PCP.Algebraic.SetMultilinear.encode m c) P).totalDegree ≤ c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ) (b : PCP.Algebraic.BinaryMaterializedField.Element (4 * (k + 1))),\n b ∈\n Finset.map { toFun := ⇑(PCP.Algebraic.BinaryMaterializedField.coefficientEquiv (4 * (k + 1))).symm, inj' := ⋯ }\n Finset.univ", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryMaterializedField.Element", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.map", + "Fin", + "ZMod", + "Function.Embedding.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.BinaryMaterializedField.coefficientEquiv", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_1", + "Finset.univ", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryMaterializedField.instFintypeElement._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each branch has its genuine finite uniform sample space. ", + "end_line": 395, + "is_class": false, + "kind": "definition", + "line": 391, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t : ℕ} →\n [Fintype F] → [DecidableEq F] → (i : Fin 7) → Fintype (PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Fin.cases", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "id", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_1", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.ThreeColorVerifier.instFintypeSampleOfDecidableEq", + "Fin.fintype", + "instDecidableEqFin", + "Fin.succ", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_2", + "Sum", + "instFintypeSum", + "instDecidableEqSum", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_3", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_4", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "PCP.Algebraic.ThreeColorVerifier.instFintypeTestSample", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "ZMod", + "instFintypeProd", + "Pi.instFintype", + "ZMod.fintype", + "Fin.elim0" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.rigidity_budget._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {q : ℕ}, 1000000 ≤ q → ¬0 < q → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Forget only the newly drawn primary-correction seed. ", + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t r : ℕ} →\n PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r →\n PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample" + ], + "value_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.mk", + "Fin", + "Prod", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual derived-grid verifier uses at most `6c+20` bit queries. ", + "end_line": 102, + "is_class": false, + "kind": "theorem", + "line": 95, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n (PCP.Algebraic.DerivedZeroOnGrid.queries ρ Q hQ nodes ζ H s).length ≤ 6 * c + 20", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "List.length", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n PCP.NPCertificate P L →\n {P' : (List Bool → List Bool → Bool) → Prop} → {L' : PCP.Language} → PCP.NPCertificate P' L' → Sort u", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "PCP.NPCertificate.casesOn", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 155, + "is_class": false, + "kind": "theorem", + "line": 153, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.totalDegree_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c → P ≠ 0 → ((PCP.Algebraic.SetMultilinear.encode m c) P).totalDegree = c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Polynomial.instZero", + "Eq", + "MvPolynomial.totalDegree", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym → ℕ", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.Sym.casesOn", + "Nat", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Recovery proves injectivity on the bounded-degree domain, even over finite fields. ", + "end_line": 121, + "is_class": false, + "kind": "theorem", + "line": 115, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_injective_on", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n Set.InjOn ⇑(PCP.Algebraic.SetMultilinear.encode m c) {P | P.natDegree < m ^ c}", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Set.InjOn", + "Polynomial", + "CommSemiring.toSemiring", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Set.ofPred", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest binary rejection is half the distance between the evaluated formal polynomials. ", + "end_line": 276, + "is_class": false, + "kind": "theorem", + "line": 264, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate_encode_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n {t r : ℕ} [inst_4 : DecidableEq F] [inst_5 : Algebra (ZMod 2) F] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : MvPolynomial σ F) (Q : MvPolynomial (σ ⊕ σ) F),\n (PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P)))) fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) Q)))) =\n 1 / 2 *\n PCP.Algebraic.relativeDistance (fun x => (MvPolynomial.eval x) Q) fun x =>\n (MvPolynomial.eval x) (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Algebra", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "Eq", + "Rat", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "instDecidableEqSum", + "instFintypeSum", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "Field.toCommRing" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The Boolean positions of one finite-domain variable. ", + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 24, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.Variable", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → ℕ → Type (max u_3 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "Sum", + "Unit", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n [Fintype F] → [Fintype σ] → [DecidableEq σ] → Fintype (PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "instFintypeProd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 87, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.correct_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {c t : ℕ} {ζ : F} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H G : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) (u : σ → F),\n (PCP.Algebraic.relativeDistance\n (fun vw => PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ H u vw.1 vw.2) fun vw =>\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ G u vw.1 vw.2) ≤\n ↑(c + 1) * PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ H G", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "Prod.fst", + "Prod.snd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The verifier performs every listed branch, so its complete list concatenates all seven. ", + "end_line": 207, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Sample F n m c t →\n List (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "List.flatten", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List.ofFn", + "List", + "PCP.Algebraic.ThreeColorVerifier.branchQueries" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.arity", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "theorem", + "line": 26, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.GoodNodes.weight_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (i : Fin (c + 1)), PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i ≠ 0", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Ne", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateAgreement", + "name": "PCP.Algebraic.BivariateAgreement.exists_nearby_of_close_columns._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [Fintype F] [DecidableEq F] {d : ℕ},\n 0 < d → ∀ (a : Fin (10 * d) → F) (C : Fin (10 * d) → Polynomial F) (R : F → Polynomial F), ¬d + 2 * d < 10 * d → False", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Not", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.field_bounds", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d q : ℕ},\n 0 < d →\n PCP.Algebraic.PointLineConstants.fieldFactor * d ^ 3 ≤ q →\n 1000 * d ^ 3 ≤ q ∧\n 3 * d ≤ q ∧\n 2 * d < q ∧ 1000000 ≤ q ∧ 6 * PCP.Algebraic.PointLineConstants.agreementError + 2 * (↑d / ↑q) < 1 / 2", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "And", + "Rat", + "Rat.instLT", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.PointLineConstants.agreementError", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The reverse inclusion follows by guessing the bounded proof prefix and\nchecking all logarithmically many random bits. The concrete machine model\nsatisfies the cost-model closure properties in `PCP.Complexity.StandardModel`. ", + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Theorem", + "name": "PCP.pcp_subset_np", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : PCP.CostModel) (L : PCP.Language) (V : PCP.Verifier) (a b : ℕ) (p : Polynomial ℕ),\n M.Efficient V →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n (∀ (x : List Bool), L x → V.CompleteAt x) →\n (∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)) → PCP.InNP M.PolyTimeRel L", + "type_dependencies": [ + "PCP.CostModel", + "PCP.Language", + "PCP.Verifier", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.CostModel.Efficient", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.InNP", + "PCP.CostModel.PolyTimeRel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual normalized rejection on independent uniform points and a shared uniform label. ", + "end_line": 132, + "is_class": false, + "kind": "definition", + "line": 125, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [Fintype F] →\n [Fintype σ] →\n [DecidableEq σ] →\n {t r : ℕ} →\n 1 ≤ r →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n ((σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) → ℚ", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Sum", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Sum", + "PCP.Algebraic.relativeDistance", + "Prod", + "Fin", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate._proof_1", + "ZMod.decidableEq", + "Sum.elim", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 429, + "is_class": false, + "kind": "theorem", + "line": 425, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 0 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.color π.colorLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Fin.fintype", + "instDecidableEqFin", + "Decidable.byContradiction", + "LE.le", + "instLENat", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → PCP.Reduction.NAEThreeColor.Literal V → ℕ", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Nat" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.casesOn", + "Nat", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 85, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.test_complete", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n (∀ (a : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π a = true) →\n ∀ (s : PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t),\n PCP.Algebraic.ThreeColorFullFieldSampling.test ρ nodes ζ H G π s = true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "Bool.true", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "PCP.Algebraic.ThreeColorFullFieldSampling.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.linked_prefix._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {p : PCP.Machine.TableauCells.Prefix tm} (k : tm.K) (j : ℕ),\n ¬j < PCP.Machine.TM2Locality.machineWindow tm →\n ((PCP.Machine.ComputationTableau.decodeRow p).stk k).length ≤ PCP.Machine.TM2Locality.machineWindow tm →\n ¬((PCP.Machine.ComputationTableau.decodeRow p).stk k).length ≤ j → False", + "type_dependencies": [ + "Turing.FinTM2", + "PCP.Machine.TableauCells.Prefix", + "Turing.FinTM2.K", + "Nat", + "Not", + "LT.lt", + "instLTNat", + "PCP.Machine.TM2Locality.machineWindow", + "LE.le", + "instLENat", + "List.length", + "Turing.FinTM2.Γ", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.ComputationTableau.decodeRow", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {t r : ℕ} (hr : 1 ≤ r) (a b : σ → F) (w : Fin t → ZMod 2),\n PCP.Algebraic.BinaryDifferenceConsistency.queries hr a b w =\n [Sum.inr (Sum.elim a b, (PCP.Algebraic.Hadamard.homogeneousIndex hr) w),\n Sum.inl (a, (PCP.Algebraic.Hadamard.homogeneousIndex hr) w),\n Sum.inl (b, (PCP.Algebraic.Hadamard.homogeneousIndex hr) w)]", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "List", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "PCP.Algebraic.BinaryDifferenceConsistency.queries", + "List.cons", + "Sum.inr", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum", + "Prod.mk", + "Sum.elim", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Sum.inl", + "List.nil" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a : Bool), PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit a", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The real-valued sign of a binary value, kept in `ℚ`. ", + "end_line": 22, + "is_class": false, + "kind": "definition", + "line": 21, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign", + "provenance": "lean", + "structural_dependencies": [], + "type": "ZMod 2 → ℚ", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "ite", + "Rat", + "Eq", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "ZMod.decidableEq", + "Rat.instOfNat", + "Neg.neg", + "Rat.instNeg" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_clause._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u} (r : V → V → Prop) (v w : V), (SimpleGraph.fromRel r).Adj v w = (v ≠ w ∧ (r v w ∨ r w v))", + "type_dependencies": [ + "Eq", + "SimpleGraph.Adj", + "SimpleGraph.fromRel", + "And", + "Ne", + "Or" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 146, + "is_class": false, + "kind": "theorem", + "line": 145, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character_comm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a x : ι → ZMod 2),\n PCP.Algebraic.BLR.character a x = PCP.Algebraic.BLR.character x a", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The mean of the fixed-parameter errors is exactly the all-parameter rejection. ", + "end_line": 71, + "is_class": false, + "kind": "theorem", + "line": 62, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.mean_rejectionAt_eq_rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (f : (σ → F) → F),\n (Finset.univ.expect fun t => PCP.Algebraic.PointLineTest.rejectionAt c f t) =\n PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable c f)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "PCP.Algebraic.PointLineTest.rejectionAt", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineTest.decodedTable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Unconditional degree-zero soundness, for arbitrary finite dimension and threshold. ", + "end_line": 170, + "is_class": false, + "kind": "theorem", + "line": 166, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.pointLineSoundness_degree_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (m : ℕ) (δ₀ : ℚ),\n PCP.Algebraic.PointLineSoundness F m 0 δ₀", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Rat", + "PCP.Algebraic.PointLineSoundness", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Uniqueness of a nearby low-degree function, independent of its chosen representation. ", + "end_line": 123, + "is_class": false, + "kind": "theorem", + "line": 116, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.IsLowDegree.eq_of_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] [inst_2 : DecidableEq 𝔽] {m d : ℕ} {f g w : (Fin m → 𝔽) → 𝔽}\n {ε : ℚ},\n PCP.Algebraic.IsLowDegree d f →\n PCP.Algebraic.IsLowDegree d g →\n 2 * ε < 1 - ↑d / ↑(Fintype.card 𝔽) →\n PCP.Algebraic.relativeDistance w f ≤ ε → PCP.Algebraic.relativeDistance w g ≤ ε → f = g", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Fin", + "Rat", + "PCP.Algebraic.IsLowDegree", + "LT.lt", + "Rat.instLT", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.eq_def", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x),\n x_1.addresses =\n match x, x_1 with\n | x, PCP.QueryTree.leaf accept => ∅\n | .(d + 1), PCP.QueryTree.query a f t => insert a (f.addresses ∪ t.addresses)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "Finset", + "PCP.QueryTree.addresses", + "PCP.QueryTree.addresses.match_1", + "Bool", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Read one tagged query from the two tables. ", + "end_line": 73, + "is_class": false, + "kind": "definition", + "line": 69, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {t r : ℕ} →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n ((σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.BinaryDifferenceConsistency.Query F σ t r → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Sum", + "PCP.Algebraic.BinaryDifferenceConsistency.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Sum", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "PCP.Algebraic.BinaryDifferenceConsistency.read.match_1", + "Prod", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A shared homogeneous label detects exactly half of the field discrepancies. ", + "end_line": 246, + "is_class": false, + "kind": "theorem", + "line": 235, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n {t r : ℕ} [inst_4 : DecidableEq F] [inst_5 : Algebra (ZMod 2) F] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (f : (σ → F) → F) (g : (σ ⊕ σ → F) → F),\n (PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x))))\n fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (g x)))) =\n 1 / 2 * PCP.Algebraic.relativeDistance (fun ab => g (Sum.elim ab.1 ab.2)) fun ab => f ab.1 - f ab.2", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Algebra", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Sum", + "Eq", + "Rat", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "Sum.elim", + "Prod.fst", + "Prod.snd", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "definition", + "line": 127, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 2 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.difference" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Lemma 2.9: a bounded family of multiples of the coordinate vanishing polynomials. ", + "end_line": 148, + "is_class": false, + "kind": "theorem", + "line": 133, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_decomposition", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] [inst_3 : Fintype σ] (H : Finset R)\n (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p ↔\n ∃ Q,\n (∀ (i : σ), (Q i).totalDegree ≤ p.totalDegree - H.card) ∧\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Fintype", + "Finset", + "MvPolynomial", + "Iff", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Exists", + "And", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 115, + "is_class": false, + "kind": "theorem", + "line": 103, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.linked_prefix", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} {p : PCP.Machine.TableauCells.Prefix tm} {s : PCP.Machine.TableauCells.Cells tm B}\n {c : tm.Cfg},\n PCP.Machine.TableauCells.Represents p s c →\n PCP.Machine.TableauCells.Linked p s →\n PCP.Machine.ComputationTableau.decodeRow p =\n PCP.Machine.TM2Locality.prefixCfg tm (PCP.Machine.TM2Locality.machineWindow tm) c", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Represents", + "PCP.Machine.TableauCells.Linked", + "Eq", + "PCP.Machine.ComputationTableau.decodeRow", + "PCP.Machine.TM2Locality.machineWindow", + "PCP.Machine.TM2Locality.prefixCfg" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness remains true after whole-field padding. ", + "end_line": 194, + "is_class": false, + "kind": "theorem", + "line": 183, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.exists_proof_rejectionRate_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F] [NeZero m]\n [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n G.Colorable 3 →\n 5 * ((H.card - 1) * n) < m ^ c →\n ∃ π, PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate ρ nodes ζ H G π = 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "SimpleGraph.Colorable", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Exists", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A uniform decoding constant, incorporating the proved soundness threshold. ", + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "Rat", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.test.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V)\n (π : PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (Fintype.card V))\n (s : PCP.Algebraic.ThreeColorBinaryVerifier.Seed (Fintype.card V)) (eV : V ≃ Fin (Fintype.card V)),\n PCP.Algebraic.ThreeColorBinaryVerifier.test G π s eV =\n PCP.Algebraic.ThreeColorFullFieldSampling.test\n (PCP.Algebraic.ThreeColorParameters.coordinates\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))\n (⇑(PCP.Algebraic.ThreeColorParameters.nodes (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))))\n (PCP.Algebraic.ThreeColorParameters.generator (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))\n (PCP.Algebraic.ThreeColorParameters.grid (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))\n (PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph G eV) (PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof π)\n ((PCP.Algebraic.ThreeColorBinaryVerifier.seedEquiv (Fintype.card V)).symm s)", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Fintype.card", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "Equiv", + "Fin", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorBinaryVerifier.test", + "PCP.Algebraic.ThreeColorFullFieldSampling.test", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "Nat", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorParameters.fieldIndex", + "PCP.Algebraic.ThreeColorBinaryVerifier.test._proof_1", + "PCP.Algebraic.BinaryMaterializedField.instAlgebraZModOfNatNatElement", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorParameters.coordinates", + "DFunLike.coe", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorParameters.nodes", + "PCP.Algebraic.ThreeColorParameters.generator", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof", + "PCP.Algebraic.ThreeColorBinaryVerifier.RawSeed", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.ThreeColorBinaryVerifier.seedEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 124, + "is_class": false, + "kind": "theorem", + "line": 122, + "module": "PCP.Complexity.NPTableau", + "name": "_private.PCP.Complexity.NPTableau.0.PCP.Machine.NPTableau.output_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R),\n Function.Injective (PCP.Machine.NPTableau.output h)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Function.Injective", + "Turing.FinTM2.Γ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.k₁", + "PCP.Machine.NPTableau.output" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.validCert a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 80, + "is_class": false, + "kind": "theorem", + "line": 78, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.represents_boundary", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} {p : PCP.Machine.TableauCells.Prefix tm} {s : PCP.Machine.TableauCells.Cells tm B}\n {c : tm.Cfg}, PCP.Machine.TableauCells.Represents p s c → PCP.Machine.TableauCells.Boundary p s c", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Represents", + "PCP.Machine.TableauCells.Boundary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 123, + "is_class": false, + "kind": "theorem", + "line": 113, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.eval_zero_eq_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} {a : Fin (c + 1) → F},\n Function.Injective a →\n ∀ (P : Polynomial F),\n P.natDegree ≤ c →\n Polynomial.eval 0 P = ∑ i, PCP.Algebraic.LagrangeConstraint.weight a 0 i * Polynomial.eval (a i) P", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "Polynomial.eval", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "PCP.Algebraic.LagrangeConstraint.weight" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 105, + "is_class": false, + "kind": "theorem", + "line": 103, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator_goodNodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), PCP.Algebraic.StandardLocalCorrection.GoodNodes 4 (PCP.Algebraic.ThreeColorFields.generator k)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "theorem", + "line": 72, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.canonicalVerifier_randomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) {a b : ℕ} (hr : V.CanonicalRandomness a b) (f : List Bool → List Bool) (p : Polynomial ℕ)\n (hp : ∀ (x : List Bool), (f x).length ≤ Polynomial.eval x.length p),\n (PCP.Verifier.Reduction.canonicalVerifier V hr f p hp).CanonicalRandomness (a * p.natDegree)\n (a * Nat.clog 2 (Polynomial.eval 1 p + 2) + b)", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "Polynomial", + "Nat.instSemiring", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "PCP.Verifier.Reduction.canonicalVerifier", + "HMul.hMul", + "instHMul", + "instMulNat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 166, + "is_class": false, + "kind": "definition", + "line": 163, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1 →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.properQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p m₀ mZ : Option (ZMod 2)),\n (∀ (p_1 m₀_1 mZ_1 : ZMod 2), p = some p_1 → m₀ = some m₀_1 → mZ = some mZ_1 → False) →\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck p m₀ mZ = none", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Option.some", + "False", + "Prod", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.coloring._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (a : V → Bool),\n (∀ (e : C), PCP.Reduction.NAEThreeColor.NAE fun i => PCP.Reduction.NAEThreeColor.Literal.eval a (Q e i)) →\n ∀ {u w : PCP.Reduction.NAEThreeColor.Vertex V C},\n (PCP.Reduction.NAEThreeColor.graph Q).Adj u w →\n PCP.Reduction.NAEThreeColor.color Q a u ≠ PCP.Reduction.NAEThreeColor.color Q a w", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.NAE", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "PCP.Reduction.NAEThreeColor.Vertex", + "SimpleGraph.Adj", + "PCP.Reduction.NAEThreeColor.graph", + "Ne", + "PCP.Reduction.NAEThreeColor.color" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n (motive : PCP.Reduction.NAEThreeColor.Vertex V C → PCP.Reduction.NAEThreeColor.Vertex V C → Sort u_3) →\n (x x_1 : PCP.Reduction.NAEThreeColor.Vertex V C) →\n ((i j : Fin 3) → motive (Sum.inl i) (Sum.inl j)) →\n ((val : V × Bool) → (i : Fin 3) → motive (Sum.inr (Sum.inl val)) (Sum.inl i)) →\n ((v : V) →\n (b : Bool) → (w : V) → (d : Bool) → motive (Sum.inr (Sum.inl (v, b))) (Sum.inr (Sum.inl (w, d)))) →\n ((e : C) →\n (i : Fin 3) → (f : C) → (j : Fin 3) → motive (Sum.inr (Sum.inr (e, i))) (Sum.inr (Sum.inr (f, j)))) →\n ((e : C) →\n (i : Fin 3) → (x : PCP.Reduction.NAEThreeColor.Vertex V C) → motive (Sum.inr (Sum.inr (e, i))) x) →\n ((x x_2 : PCP.Reduction.NAEThreeColor.Vertex V C) → motive x x_2) → motive x x_1", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk", + "Sum.casesOn", + "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_1", + "Nat.hasNotBit", + "Sum.ctorIdx", + "Prod.casesOn", + "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_2" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.read.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {t r : ℕ} (motive : PCP.Algebraic.BinaryDifferenceConsistency.Query F σ t r → Sort u_3)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p))\n (h_2 : (p : (σ ⊕ σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inr p)),\n (match Sum.inl p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_1 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Sum", + "Sum.inr", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.slot", + "provenance": "lean", + "structural_dependencies": [], + "type": "{a d : ℕ} → Fin (max 1 d) → Fin a → Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)", + "type_dependencies": [ + "Nat", + "Fin", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.FiniteDomainConstraints.arity" + ], + "value_dependencies": [ + "Nat", + "Fin", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "DFunLike.coe", + "Equiv", + "Prod", + "HMul.hMul", + "instHMul", + "instMulNat", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "finProdFinEquiv", + "Prod.mk" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 134, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.color_direct", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (a : V → Bool),\n (∀ (e : C), PCP.Reduction.NAEThreeColor.NAE fun i => PCP.Reduction.NAEThreeColor.Literal.eval a (Q e i)) →\n ∀ (u w : PCP.Reduction.NAEThreeColor.Vertex V C),\n PCP.Reduction.NAEThreeColor.direct Q u w →\n PCP.Reduction.NAEThreeColor.color Q a u ≠ PCP.Reduction.NAEThreeColor.color Q a w", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.NAE", + "PCP.Reduction.NAEThreeColor.Literal.eval", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.direct", + "Ne", + "PCP.Reduction.NAEThreeColor.color" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (x : ℕ) (accept : Bool)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match x, PCP.QueryTree.leaf accept with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_1 x accept", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.addresses.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ), ¬n ≤ c + 1 → ¬c + 1 + (n - (c + 1)) = n → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The randomness budget is a closed formula in encoded input length. ", + "end_line": 47, + "is_class": false, + "kind": "definition", + "line": 46, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Only the prefix variable has a compound alphabet; its size depends solely on the machine. ", + "end_line": 212, + "is_class": false, + "kind": "definition", + "line": 210, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.Assignment", + "provenance": "lean", + "structural_dependencies": [], + "type": "Turing.FinTM2 → ℕ → ℕ → Type", + "type_dependencies": [ + "Turing.FinTM2", + "Nat" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "Prod", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 85, + "is_class": false, + "kind": "definition", + "line": 85, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {randomness : ℕ → ℕ} →\n {queries : ℕ} →\n {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries} →\n {randomness' : ℕ → ℕ} →\n {queries' : ℕ} →\n {run' : (x : List Bool) → Fin (2 ^ randomness' x.length) → PCP.QueryTree queries'} →\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness', queries := queries', run := run' } →\n (randomness = randomness' → queries = queries' → run ≍ run' → P) → P", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "HEq" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "HEq", + "id", + "PCP.Verifier.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1) →\n ((x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin n ⊕ Fin n)) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 138, + "is_class": false, + "kind": "theorem", + "line": 125, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.polynomial_predict", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} {a : Fin (c + 1) → F},\n Function.Injective a →\n ∀ (P : Polynomial F),\n P.natDegree ≤ c →\n ∀ (u v : F),\n Polynomial.eval u P =\n PCP.Algebraic.WeightedConstraint.predict a (PCP.Algebraic.LagrangeConstraint.weight a 0)\n (fun x => Polynomial.eval x P) u v", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "Polynomial.eval", + "PCP.Algebraic.WeightedConstraint.predict", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.LagrangeConstraint.weight", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries_length_eq._proof_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n ¬2 +\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1)\n s.2.1.2.1.1 s.2.1.2.1.2.1 s.2.1.2.1.2.2.1 s.2.1.1 s.2.1.2.1.2.2.2).length +\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)\n s.2.1.2.2.1 s.2.1.2.2.2.1 s.2.1.2.2.2.2.1 s.2.1.1 s.2.1.2.2.2.2.2).length =\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1)\n s.2.1.2.1.1 s.2.1.2.1.2.1 s.2.1.2.1.2.2.1 s.2.1.1 s.2.1.2.1.2.2.2).length +\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ\n (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1) s.2.1.2.2.1 s.2.1.2.2.2.1 s.2.1.2.2.2.2.1 s.2.1.1\n s.2.1.2.2.2.2.2).length +\n 1 +\n 1 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Not", + "Eq", + "List.length", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "Prod.fst", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A correct difference function passes for every random seed. ", + "end_line": 107, + "is_class": false, + "kind": "theorem", + "line": 101, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.check_encode_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (f : (σ → F) → F) (a b : σ → F) (w : Fin t → ZMod 2),\n PCP.Algebraic.BinaryDifferenceConsistency.check hr (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x))))\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f (x ∘ Sum.inl) - f (x ∘ Sum.inr))))) a b w =\n 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.check", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Sum", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Function.comp", + "Sum.inl", + "Sum.inr", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.consecutiveSamplesEquiv._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (s : ((σ → F) × (σ → F)) × F),\n ((PCP.Algebraic.PointLineTest.consecutivePointsEquiv\n ((PCP.Algebraic.PointLineTest.consecutivePointsEquiv s.2).symm s.1, s.2).2)\n ((PCP.Algebraic.PointLineTest.consecutivePointsEquiv s.2).symm s.1, s.2).1,\n ((PCP.Algebraic.PointLineTest.consecutivePointsEquiv s.2).symm s.1, s.2).2) =\n s", + "type_dependencies": [ + "Field", + "Prod", + "Eq", + "Prod.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.PointLineTest.consecutivePointsEquiv", + "Prod.snd", + "Equiv.symm", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "definition", + "line": 79, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R} →\n {polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)} →\n {PolyTimeRel' : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg' : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable' : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel' R → Computable₂ R} →\n {polyTimeAlg_computable' :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg' alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck' :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg' alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel' (PCP.finiteWitnessCheck V)} →\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel', PolyTimeAlg := PolyTimeAlg',\n polyTimeRel_computable := polyTimeRel_computable',\n polyTimeAlg_computable := polyTimeAlg_computable',\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck' } →\n (PolyTimeRel = PolyTimeRel' → PolyTimeAlg = PolyTimeAlg' → P) → P", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk", + "id", + "PCP.CostModel.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Vanishing at every point of the Cartesian grid, including zero-dimensional grids. ", + "end_line": 31, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.VanishesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → Finset R → MvPolynomial σ R → Prop", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring" + ], + "value_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.colorQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3) →\n ((x : Fin n → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin n)) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 107, + "is_class": false, + "kind": "theorem", + "line": 106, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), 0 ≤ V.accProb x π", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Verifier.accProb" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 223, + "is_class": false, + "kind": "theorem", + "line": 214, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_boundedEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c →\n ∀ (P : ↥(Polynomial.degreeLE R ↑d)) (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n ((PCP.Algebraic.SetMultilinear.boundedEncode m c d) P) =\n Polynomial.eval x ↑P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "LinearMap", + "RingHom.id", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.boundedEncode", + "Polynomial.eval", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.run.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a b : σ → F) (z : Fˣ)\n (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ f H a b z v w s =\n if\n PCP.Algebraic.BinaryLowDegreeTest.test PCP.Algebraic.BinaryLocalCorrection.run._proof_2 ρ nodes (H b) s =\n true then\n if\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H b)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c ↑z) v w =\n f (PCP.Algebraic.PolynomialLine.point a b ↑z)\n ((PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.BinaryLocalCorrection.run._proof_2) w) then\n some\n (PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H b)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c 0) v w)\n else none\n else none", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.run", + "ite", + "Bool", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_2", + "Bool.true", + "instDecidableEqBool", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq", + "Option.some", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A fresh independent coefficient seed is drawn after the original grid sample. ", + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Prod", + "Fin", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every coloring has a low-degree extension satisfying both grid constraints. ", + "end_line": 132, + "is_class": false, + "kind": "theorem", + "line": 116, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_constraints", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F) (G : SimpleGraph (σ → ↥H)),\n G.Colorable 3 ↔\n ∃ P,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) ∧\n PCP.Algebraic.GridVanishing.VanishesOn H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P))", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Fintype.card", + "PCP.Algebraic.GridVanishing.VanishesOn", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "Sum", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 94, + "is_class": false, + "kind": "definition", + "line": 93, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`V` is efficiently implementable in the model `M`. ", + "end_line": 115, + "is_class": false, + "kind": "definition", + "line": 114, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.Efficient", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → PCP.Verifier → Prop", + "type_dependencies": [ + "PCP.CostModel", + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.CostModel", + "PCP.Verifier", + "Exists", + "PCP.VerifierAlg", + "And", + "PCP.CostModel.PolyTimeAlg", + "PCP.Verifier.ImplementedBy" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 57, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] (H : Finset R) (i : σ),\n PCP.Algebraic.GridVanishing.coordinate H i ≠ 0", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finset", + "Ne", + "MvPolynomial", + "PCP.Algebraic.GridVanishing.coordinate", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 72, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {V : Type u_1} →\n {t : PCP.Reduction.NAEThreeColor.Literal V} →\n {V' : Type u_1} →\n {t' : PCP.Reduction.NAEThreeColor.Literal V'} →\n V = V' → t ≍ t' → PCP.Reduction.NAEThreeColor.Literal.noConfusionType P t t'", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "HEq", + "PCP.Reduction.NAEThreeColor.Literal.noConfusionType" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.Reduction.NAEThreeColor.Literal.noConfusionType", + "PCP.Reduction.NAEThreeColor.Literal.casesOn", + "Bool", + "Eq.refl", + "HEq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 206, + "is_class": false, + "kind": "theorem", + "line": 206, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.gap_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "0 < PCP.Algebraic.ThreeColorBinaryVerifier.gap", + "type_dependencies": [ + "LT.lt", + "Rat", + "Rat.instLT", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "definition", + "line": 131, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 5 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Rejection probability of the binary three-query linearity test. ", + "end_line": 109, + "is_class": false, + "kind": "definition", + "line": 107, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.rejectionProbability", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → [Fintype V] → [Add V] → (V → ZMod 2) → ℚ", + "type_dependencies": [ + "Fintype", + "Add", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "Add", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "ZMod.decidableEq", + "HAdd.hAdd", + "instHAdd", + "Prod.fst", + "Prod.snd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "definition", + "line": 133, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual rejection of the concrete procedure, including either failed check. ", + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n [Fintype σ] →\n [DecidableEq σ] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) → (σ → F) → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.AffineLineSampling.fraction", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_2", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.none" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 77, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_digitMonomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ) (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n (PCP.Algebraic.SetMultilinear.digitMonomial m c k) =\n x ^ (k % m ^ c)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "HMod.hMod", + "instHMod", + "Nat.instMod", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 33, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_rename", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R) (p : MvPolynomial σ R),\n (PCP.Algebraic.GridVanishing.substitute Y) ((MvPolynomial.rename Sum.inl) p) = p", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "AlgHom", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Sum.inl" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.base.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (i : Fin 3), PCP.Reduction.NAEThreeColor.base i = Sum.inl i", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.base", + "Sum.inl", + "Sum", + "Prod", + "Bool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Wrong origin values imply a formal discrepancy with the honest restricted polynomial. ", + "end_line": 77, + "is_class": false, + "kind": "theorem", + "line": 71, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.table_ne_restrict_of_origin_ne", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (T : (σ → F) → Polynomial F) (P : MvPolynomial σ F) (a b : σ → F),\n Polynomial.eval 0 (T b) ≠ (MvPolynomial.eval a) P → T b ≠ (PCP.Algebraic.PolynomialLine.restrict a b) P", + "type_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "Ne", + "Polynomial.eval", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Polynomial.semiring", + "PCP.Algebraic.PolynomialLine.restrict" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.inputSlot.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {a d : ℕ} (i : Fin d) (j : Fin a),\n PCP.Reduction.FiniteDomainConstraints.inputSlot i j = PCP.Reduction.FiniteDomainConstraints.slot (Fin.castLE ⋯ i) j", + "type_dependencies": [ + "Nat", + "Fin", + "Eq", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.inputSlot", + "PCP.Reduction.FiniteDomainConstraints.slot", + "Fin.castLE", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Reduction.FiniteDomainConstraints.inputSlot._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.symbolicX.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F],\n PCP.Algebraic.BerlekampWelchCertificate.symbolicX =\n MvPolynomial.eval₂Hom (Polynomial.C.comp Polynomial.C) ![Polynomial.X, Polynomial.C Polynomial.X]", + "type_dependencies": [ + "Field", + "Eq", + "RingHom", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial", + "CommSemiring.toSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BerlekampWelchCertificate.symbolicX", + "MvPolynomial.eval₂Hom", + "Polynomial.commSemiring", + "RingHom.comp", + "Polynomial.C", + "Matrix.vecCons", + "Polynomial.X", + "DFunLike.coe", + "RingHom.instFunLike", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 379, + "is_class": false, + "kind": "definition", + "line": 378, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeSampleOfDecidableEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t : ℕ} →\n [Fintype F] →\n {σ : Type u_2} →\n [Fintype σ] → [DecidableEq σ] → {r : ℕ} → Fintype (PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "instFintypeProd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.instFintypeProdTestRandomnessInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 60, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.eval_basis", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽] [inst_1 : DecidableEq 𝔽] [inst_2 : Fintype σ] (H : Finset 𝔽)\n (a b : σ → ↥H),\n (MvPolynomial.eval fun i => ↑(b i)) (PCP.Algebraic.GridInterpolation.basis H a) = if a = b then 1 else 0", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val", + "PCP.Algebraic.GridInterpolation.basis", + "ite", + "Fintype.decidablePiFintype", + "Subtype.instDecidableEq", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_ne_zero._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)", + "type_dependencies": [ + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The forward bridge is stated for the concrete `FinTM2` definition of NP. ", + "end_line": 176, + "is_class": false, + "kind": "theorem", + "line": 170, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.of_inNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language},\n PCP.InNP PCP.Machine.PolyTimeRel L → ∃ R q h, ∀ (x : List Bool), L x ↔ ∃ a, PCP.Machine.NPTableau.Accepts h q x a", + "type_dependencies": [ + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "List", + "Bool", + "Polynomial", + "Nat", + "Nat.instSemiring", + "PCP.Machine.NPTableau.Checker", + "Iff", + "PCP.Machine.NPTableau.Assignment", + "PCP.Machine.NPTableau.Accepts" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A constant lines table controls the global discrepancy of independently sampled values. ", + "end_line": 126, + "is_class": false, + "kind": "theorem", + "line": 114, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.pairDisagreement_le_twice_lineError", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n {A : Type u_3} [inst_4 : DecidableEq A] (f : (σ → F) → A) (b : (σ → F) × (σ → F) → A),\n PCP.Algebraic.PointLineTest.pairDisagreement f ≤\n 2 * PCP.Algebraic.relativeDistance (fun s => f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2)) fun s => b s.1", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Prod", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.pairDisagreement", + "Pi.instFintype", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (f : List Bool → Bool ⊕ ℕ) (as : List Bool),\n PCP.QueryTree.ofStep f 0 as =\n match f as with\n | Sum.inl b => PCP.QueryTree.leaf b\n | Sum.inr val => PCP.QueryTree.leaf false", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Eq", + "PCP.QueryTree", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.ofStep", + "PCP.QueryTree.ofStep.match_1", + "PCP.QueryTree.leaf", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness only needs the decoded difference identity and the two grid equations;\nit imposes no interpolation-degree restriction on the decoded coloring. ", + "end_line": 171, + "is_class": false, + "kind": "theorem", + "line": 162, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_of_vanishing", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F) (G : SimpleGraph (σ → ↥H)) (P : MvPolynomial σ F) (Q : MvPolynomial (σ ⊕ σ) F),\n Q = PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P →\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) →\n PCP.Algebraic.GridVanishing.VanishesOn H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G) Q) →\n G.Colorable 3", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.GridVanishing.VanishesOn", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "SimpleGraph.Colorable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Observation 3.8: concatenation halves the relative distance of two functions. ", + "end_line": 116, + "is_class": false, + "kind": "theorem", + "line": 110, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encodeFunction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} {ι : Type u_1} [inst : Fintype ι],\n 1 ≤ r →\n ∀ (f g : ι → Fin t → ZMod 2),\n PCP.Algebraic.relativeDistance (PCP.Algebraic.Hadamard.encodeFunction r f)\n (PCP.Algebraic.Hadamard.encodeFunction r g) =\n 1 / 2 * PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.Hadamard.encodeFunction", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Fintype.decidablePiFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "In particular, a nonzero polynomial is nonzero on at least a `1 - d / |𝔽|` fraction. ", + "end_line": 61, + "is_class": false, + "kind": "theorem", + "line": 57, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.eval_distance_zero_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] [inst_2 : DecidableEq 𝔽] {m d : ℕ} (p : MvPolynomial (Fin m) 𝔽),\n p.totalDegree ≤ d →\n p ≠ 0 → 1 - ↑d / ↑(Fintype.card 𝔽) ≤ PCP.Algebraic.relativeDistance (fun x => (MvPolynomial.eval x) p) 0", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Rat", + "Rat.instLE", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Pi.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Correct a point by the plurality of all line predictions through that point. ", + "end_line": 132, + "is_class": false, + "kind": "definition", + "line": 130, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.correction", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n {c : ℕ} →\n [Fintype F] →\n [DecidableEq F] → [Fintype σ] → [DecidableEq σ] → PCP.Algebraic.PointLineTest.LineTable F σ c → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "PCP.Algebraic.Plurality.value", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "Finite.of_fintype", + "PCP.Algebraic.PointLineTest.correction._proof_1", + "PCP.Algebraic.PointLineTest.prediction" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.queries ρ Q hQ nodes ζ H s =\n List.map (fun q => Sum.inl (s.1, q))\n (PCP.Algebraic.HadamardDerivedOracle.queries ρ (Q s.1) ⋯\n ((PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.DerivedZeroOnGrid.check._proof_2) s.2.1.1) s.2.2) ++\n List.map (fun q => Sum.inr (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1, q))\n (PCP.Algebraic.DerivedZeroOnGrid.callQueries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1) s.2.1.1\n s.2.1.2.1) ++\n List.map (fun q => Sum.inr (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1, q))\n (PCP.Algebraic.DerivedZeroOnGrid.callQueries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)\n s.2.1.1 s.2.1.2.2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Eq", + "List", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "HAppend.hAppend", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.HadamardDerivedOracle.queries", + "Field.toCommRing", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "PCP.Algebraic.DerivedZeroOnGrid.callQueries", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.direct.match_1.eq_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2}\n (motive : PCP.Reduction.NAEThreeColor.Vertex V C → PCP.Reduction.NAEThreeColor.Vertex V C → Sort u_3) (v : V)\n (b : Bool) (w : V) (d : Bool) (h_1 : (i j : Fin 3) → motive (Sum.inl i) (Sum.inl j))\n (h_2 : (val : V × Bool) → (i : Fin 3) → motive (Sum.inr (Sum.inl val)) (Sum.inl i))\n (h_3 : (v : V) → (b : Bool) → (w : V) → (d : Bool) → motive (Sum.inr (Sum.inl (v, b))) (Sum.inr (Sum.inl (w, d))))\n (h_4 : (e : C) → (i : Fin 3) → (f : C) → (j : Fin 3) → motive (Sum.inr (Sum.inr (e, i))) (Sum.inr (Sum.inr (f, j))))\n (h_5 : (e : C) → (i : Fin 3) → (x : PCP.Reduction.NAEThreeColor.Vertex V C) → motive (Sum.inr (Sum.inr (e, i))) x)\n (h_6 : (x x_1 : PCP.Reduction.NAEThreeColor.Vertex V C) → motive x x_1),\n (match Sum.inr (Sum.inl (v, b)), Sum.inr (Sum.inl (w, d)) with\n | Sum.inl i, Sum.inl j => h_1 i j\n | Sum.inr (Sum.inl val), Sum.inl i => h_2 val i\n | Sum.inr (Sum.inl (v, b)), Sum.inr (Sum.inl (w, d)) => h_3 v b w d\n | Sum.inr (Sum.inr (e, i)), Sum.inr (Sum.inr (f, j)) => h_4 e i f j\n | Sum.inr (Sum.inr (e, i)), x => h_5 e i x\n | x, x_1 => h_6 x x_1) =\n h_3 v b w d", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Bool", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Sum.inr", + "Prod.mk", + "Eq", + "PCP.Reduction.NAEThreeColor.direct.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "theorem", + "line": 128, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.predictedCell_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} (p : PCP.Machine.TableauCells.Prefix tm) (s : PCP.Machine.TableauCells.Cells tm B)\n (k : tm.K) (j : ℕ),\n PCP.Machine.TableauCells.predictedCell p k j (PCP.Machine.TableauCells.candidates s k j) =\n if\n j <\n ((PCP.Machine.ComputationTableau.decodeRow (PCP.Machine.FiniteTransitionTable.localStep tm p)).stk\n k).length then\n ((PCP.Machine.ComputationTableau.decodeRow (PCP.Machine.FiniteTransitionTable.localStep tm p)).stk k)[j]?\n else\n PCP.Machine.TableauCells.readCell s k\n (PCP.Machine.TM2Locality.machineWindow tm +\n (j -\n ((PCP.Machine.ComputationTableau.decodeRow (PCP.Machine.FiniteTransitionTable.localStep tm p)).stk\n k).length))", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "Eq", + "Option", + "Turing.FinTM2.Γ", + "PCP.Machine.TableauCells.predictedCell", + "PCP.Machine.TableauCells.candidates", + "ite", + "LT.lt", + "instLTNat", + "List.length", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.ComputationTableau.decodeRow", + "PCP.Machine.FiniteTransitionTable.outputBound", + "PCP.Machine.FiniteTransitionTable.localStep", + "Nat.decLt", + "GetElem?.getElem?", + "List", + "List.instGetElem?NatLtLength", + "PCP.Machine.TableauCells.readCell", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.TM2Locality.machineWindow", + "HSub.hSub", + "instHSub", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The coefficient sum controls evaluation by a single power. ", + "end_line": 32, + "is_class": false, + "kind": "theorem", + "line": 23, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.eval_le_coefficientSum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : Polynomial ℕ) (n : ℕ), Polynomial.eval n p ≤ Polynomial.eval 1 p * (n + 2) ^ p.natDegree", + "type_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring", + "LE.le", + "instLENat", + "Polynomial.eval", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Polynomial.natDegree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.fieldIndex._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n {inst_3 : DecidableEq F} [inst_4 : DecidableEq F] (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (nodes nodes_1 : Fin (c + 1) → F),\n nodes = nodes_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (H : Finset F) (G G_1 : SimpleGraph (Fin n → ↥H)),\n G = G_1 →\n ∀ (π π_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n π = π_1 →\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π =\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ_1 nodes_1 ζ_1 H G_1 π_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk", + "PCP.Verifier.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "definition", + "line": 43, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → Fintype (PCP.Algebraic.ThreeColorFields.FieldFamily k)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.ThreeColorFields.FieldFamily" + ], + "value_dependencies": [ + "Nat", + "Fintype.mk", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "Finset.map", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "ZMod", + "PCP.Algebraic.BinaryMaterializedField.Element", + "Function.Embedding.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.BinaryMaterializedField.coefficientEquiv", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_1", + "Finset.univ", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryMaterializedField.instFintypeElement._proof_1", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 88, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.eval_interpolate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽] [inst_1 : DecidableEq 𝔽] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n (H : Finset 𝔽) (f : (σ → ↥H) → 𝔽) (a : σ → ↥H),\n (MvPolynomial.eval fun i => ↑(a i)) ((PCP.Algebraic.GridInterpolation.interpolate H) f) = f a", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val", + "LinearMap", + "RingHom.id", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.GridInterpolation.interpolate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "theorem", + "line": 34, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_constant", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (x : Fin t → ZMod 2) (a : ZMod 2),\n (PCP.Algebraic.Hadamard.encode r x) (PCP.Algebraic.BinaryPolynomialSpace.constant a) = a", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.BinaryPolynomialSpace.constant" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Choose the least positive power of sixteen reaching the requested threshold. ", + "end_line": 116, + "is_class": false, + "kind": "definition", + "line": 115, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.index", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "False and true occupy the first two palette colors. ", + "end_line": 22, + "is_class": false, + "kind": "definition", + "line": 21, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.boolColor", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool → Fin 3", + "type_dependencies": [ + "Bool", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat" + ], + "value_dependencies": [ + "Bool", + "ite", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Bool.true", + "instDecidableEqBool", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 120, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.index_add_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), PCP.Algebraic.ThreeColorFields.index M + 1 = max 1 (Nat.clog 16 M)", + "type_dependencies": [ + "Nat", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.index", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The column through `y`, viewed as a polynomial in the first coordinate. ", + "end_line": 220, + "is_class": false, + "kind": "definition", + "line": 218, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.columnPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : Field F] → MvPolynomial (Fin 2) F → F → Polynomial F", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial", + "CommSemiring.toSemiring" + ], + "value_dependencies": [ + "Field", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.PointLineCrossing.axisRestrict", + "instDecidableEqFin", + "Matrix.vecCons", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "Matrix.vecEmpty", + "Fin.instOfNat", + "PCP.Algebraic.PointLineCrossing.rowPolynomial._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The explicit input positions, with a dummy block for any unused padding. ", + "end_line": 46, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.scope", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {a d : ℕ} →\n (C → Fin d → V) →\n PCP.Reduction.FiniteDomainConstraints.Constraint V C →\n Fin (PCP.Reduction.FiniteDomainConstraints.arity a d) → PCP.Reduction.FiniteDomainConstraints.Variable V a", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.Variable" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.scope.match_1", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "Prod", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "DFunLike.coe", + "Equiv", + "HMul.hMul", + "instHMul", + "instMulNat", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "finProdFinEquiv", + "Prod.mk", + "Sum", + "Unit", + "dite", + "LT.lt", + "instLTNat", + "Fin.val", + "Prod.fst", + "Nat.decLt", + "Sum.inl", + "Fin.mk", + "Not", + "Sum.inr", + "Unit.unit", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (π : PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord N),\n PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof π =\n PCP.Algebraic.ThreeColorVerifier.ofOracle fun q => π ((PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv N) q)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Eq", + "PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof", + "PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof", + "PCP.Algebraic.ThreeColorVerifier.ofOracle", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.size", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorVerifier.Query", + "DFunLike.coe", + "Equiv", + "PCP.Algebraic.ThreeColorBinaryVerifier.Address", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The endpoint bounds construct a multivariate polynomial of ordinary total\ndegree at most `d`, rather than only separately low-degree coordinate slices. ", + "end_line": 111, + "is_class": false, + "kind": "theorem", + "line": 93, + "module": "PCP.Algebraic.RuledSurfaceRigidity", + "name": "PCP.Algebraic.RuledSurface.exists_polynomial_of_endpoint_bounds", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {d : ℕ},\n 0 < d →\n 1000 * d ^ 3 ≤ Fintype.card F →\n ∀ (f g : (σ → F) → F) (T : PCP.Algebraic.PointLineTest.LineTable F σ d) {η γ δ ℓ ε : ℚ},\n PCP.Algebraic.relativeDistance f g ≤ η →\n (∀ (u : σ → F) (t : F),\n (PCP.Algebraic.AffineLineSampling.fraction fun v =>\n Polynomial.eval t ↑(T (u, v)) ≠ g (PCP.Algebraic.PolynomialLine.point u v t)) ≤\n γ) →\n PCP.Algebraic.PointLineTest.rejectionRate f T ≤ δ →\n (∀ (t : F),\n (PCP.Algebraic.relativeDistance (fun uv => f (PCP.Algebraic.PolynomialLine.point uv.1 uv.2 t))\n fun uv => Polynomial.eval t ↑(T uv)) ≤\n ℓ) →\n 0 < ε →\n ε ≤ 1 / 100 →\n 6 * ε + 2 * (↑d / ↑(Fintype.card F)) < 1 / 2 →\n (2 * (γ + η) + δ + ℓ + γ + 2 / ↑(Fintype.card F)) / ε + γ < 1 →\n ∃ P, P.totalDegree ≤ d ∧ ∀ (x : σ → F), (MvPolynomial.eval x) P = g x", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "PCP.Algebraic.PointLineTest.LineTable", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.AffineLineSampling.fraction", + "Ne", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Subtype.val", + "Polynomial", + "Polynomial.natDegree", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.RuledSurface.Seed", + "instFintypeProd", + "Prod.fst", + "Prod.snd", + "Rat.instLT", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.correction.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (table : PCP.Algebraic.PointLineTest.LineTable F σ c) (x : σ → F),\n PCP.Algebraic.PointLineTest.correction table x =\n PCP.Algebraic.Plurality.value (PCP.Algebraic.PointLineTest.prediction table x)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "Eq", + "PCP.Algebraic.PointLineTest.correction", + "PCP.Algebraic.Plurality.value", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "Finite.of_fintype", + "PCP.Algebraic.PointLineTest.correction._proof_1", + "PCP.Algebraic.PointLineTest.prediction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate_lower_bound._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", + "type_dependencies": [ + "Fintype", + "Eq", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.univ", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Plurality correction is within twice the actual tester rejection probability. ", + "end_line": 139, + "is_class": false, + "kind": "theorem", + "line": 134, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.distance_correction_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ c),\n PCP.Algebraic.relativeDistance f (PCP.Algebraic.PointLineTest.correction table) ≤\n 2 * PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.PointLineTest.correction", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.PointLineTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGrid.optionCheck._sparseCasesOn_1.else_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))\n («else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck._sparseCasesOn_1 t some «else» = «else» h", + "type_dependencies": [ + "Option", + "Option.some", + "Nat.hasNotBit", + "Option.ctorIdx", + "Eq", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck._sparseCasesOn_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A colorable grid graph supplies an actual eight-table proof accepted on every seed. ", + "end_line": 124, + "is_class": false, + "kind": "theorem", + "line": 100, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n G.Colorable 3 →\n 5 * ((H.card - 1) * n) < m ^ c →\n ∃ π,\n ∀ (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s = true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "SimpleGraph.Colorable", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Exists", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One actual correction call at a separately supplied homogeneous label. ", + "end_line": 43, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n {σ : Type u_2} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n (σ → F) →\n (Fin t → ZMod 2) → PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t → Option (ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "Option" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.run", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Probability that all four whole-field correction parameters are nonzero. ", + "end_line": 109, + "is_class": false, + "kind": "definition", + "line": 108, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.retention", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HPow.hPow", + "Rat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Nat.cast", + "Rat.instNatCast", + "OfNat.ofNat", + "Rat.instOfNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 102, + "is_class": false, + "kind": "theorem", + "line": 95, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.rowPolynomial_inY", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (p : Polynomial F) (x : F),\n PCP.Algebraic.PointLineCrossing.rowPolynomial (PCP.Algebraic.BerlekampWelchCertificate.inY p) x = p", + "type_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.BerlekampWelchCertificate.inY" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The concrete `FinTM2` certificate class is exactly ComplexityLib's NP.\nNeither direction requires a supplied machine simulation or cost premise. ", + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Complexity.ReferenceNPConverse", + "name": "PCP.ReferenceNP.mem_iff_inNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : Complexity.Language}, L ∈ Complexity.NP ↔ PCP.InNP PCP.Machine.PolyTimeRel L", + "type_dependencies": [ + "Complexity.Language", + "Iff", + "Membership.mem", + "Set", + "Set.instMembership", + "Complexity.NP", + "PCP.InNP", + "PCP.Machine.PolyTimeRel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The algorithm's actual encoded graph is colorable exactly for bounded-witness acceptance. ", + "end_line": 60, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.decode_colorable_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph (PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x)).Colorable 3 ↔\n ∃ w, w.length ≤ Polynomial.eval x.length q ∧ R x w = true", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "Iff", + "SimpleGraph.Colorable", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Reduction.NPThreeColorRuntime.encode", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "instOfNatNat", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Degree-zero queries see only constants, so they cannot distinguish messages. ", + "end_line": 49, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.encode_degree_zero_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x y : Fin t → ZMod 2), PCP.Algebraic.Hadamard.encode 0 x = PCP.Algebraic.Hadamard.encode 0 y", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] {inst_2 : DecidableEq F} [inst_3 : DecidableEq F]\n [inst_4 : Fintype σ] {inst_5 : DecidableEq σ} [inst_6 : DecidableEq σ] (c c_1 : ℕ),\n c = c_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (f f_1 : (σ → F) → F),\n f = f_1 →\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f =\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c_1 ζ_1 f_1", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One fixed polynomial bounds all reachable proof addresses in input length. ", + "end_line": 117, + "is_class": false, + "kind": "definition", + "line": 116, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound", + "provenance": "lean", + "structural_dependencies": [], + "type": "Polynomial ℕ", + "type_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "HPow.hPow", + "Polynomial", + "Nat", + "Nat.instSemiring", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.semiring", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "Polynomial.C", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "Polynomial.X", + "One.toOfNat1", + "Polynomial.instOne" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The formal linear polynomial reconstructing an algebra element from binary coordinates. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 61, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.coordinatePolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : CommRing F] → [inst_1 : Algebra (ZMod 2) F] → {t : ℕ} → (F ≃ₗ[ZMod 2] Fin t → ZMod 2) → MvPolynomial (Fin t) F", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial" + ], + "value_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Finset.sum", + "MvPolynomial", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.univ", + "Fin.fintype", + "DFunLike.coe", + "LinearMap", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "MvPolynomial.monomial", + "Finsupp.single", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "LinearEquiv.symm", + "Pi.single", + "instMulZeroClassOfSemiring", + "instDecidableEqFin", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "At every target-line parameter, its one fixed nearest polynomial agrees\nwith `g`, under the explicitly stated quantitative prediction bounds. ", + "end_line": 70, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.RuledSurfaceRigidity", + "name": "PCP.Algebraic.RuledSurface.bestApproximation_eval_eq_of_endpoint_bounds", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {d : ℕ},\n 0 < d →\n 1000 * d ^ 3 ≤ Fintype.card F →\n ∀ (f g : (σ → F) → F) (T : PCP.Algebraic.PointLineTest.LineTable F σ d) {η γ δ ℓ ε : ℚ},\n PCP.Algebraic.relativeDistance f g ≤ η →\n (∀ (u : σ → F) (t : F),\n (PCP.Algebraic.AffineLineSampling.fraction fun v =>\n Polynomial.eval t ↑(T (u, v)) ≠ g (PCP.Algebraic.PolynomialLine.point u v t)) ≤\n γ) →\n PCP.Algebraic.PointLineTest.rejectionRate f T ≤ δ →\n (∀ (t : F),\n (PCP.Algebraic.relativeDistance (fun uv => f (PCP.Algebraic.PolynomialLine.point uv.1 uv.2 t))\n fun uv => Polynomial.eval t ↑(T uv)) ≤\n ℓ) →\n 0 < ε →\n ε ≤ 1 / 100 →\n 6 * ε + 2 * (↑d / ↑(Fintype.card F)) < 1 / 2 →\n (2 * (γ + η) + δ + ℓ + γ + 2 / ↑(Fintype.card F)) / ε + γ < 1 →\n ∀ (x h : σ → F) (y : F),\n Polynomial.eval y\n ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun t =>\n g (PCP.Algebraic.PolynomialLine.point x h t)) =\n g (PCP.Algebraic.PolynomialLine.point x h y)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "PCP.Algebraic.PointLineTest.LineTable", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.AffineLineSampling.fraction", + "Ne", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Subtype.val", + "Polynomial", + "Polynomial.natDegree", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.RuledSurface.Seed", + "instFintypeProd", + "Prod.fst", + "Prod.snd", + "Rat.instLT", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Eq", + "PCP.Algebraic.PointLineTest.bestApproximation" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 231, + "is_class": false, + "kind": "theorem", + "line": 225, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c → Function.Injective ⇑(PCP.Algebraic.SetMultilinear.boundedEncode m c d)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Function.Injective", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.boundedEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Homogeneous output queries also retain the factor-two bound; no restriction loss is needed. ", + "end_line": 145, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.homogeneous_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} {I : Type u_2} [inst_2 : Fintype I]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (P : I → Polynomial F) (hP : ∀ (i : I), (P i).natDegree ≤ r)\n (H : I → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) (f : I → F),\n (PCP.Algebraic.relativeDistance\n (fun s =>\n PCP.Algebraic.HadamardDerivedOracle.answer ρ (P s.1) ⋯ (H s.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex ⋯) s.2.1) s.2.2)\n fun s => (PCP.Algebraic.Hadamard.linearEncode (ρ (Polynomial.eval (f s.1) (P s.1)))) s.2.1) ≤\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ H f", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.decidableEq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "Prod.fst", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "le_refl", + "Nat.instPreorder", + "Prod.snd", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {F : Type u_2} →\n {n m c t : ℕ} →\n {t_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t} →\n {F' : Type u_2} →\n {n' m' c' t' : ℕ} →\n {t'_1 : PCP.Algebraic.ThreeColorVerifier.Proof F' n' m' c' t'} →\n F = F' →\n n = n' →\n m = m' →\n c = c' → t = t' → t_1 ≍ t'_1 → PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType P t_1 t'_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "HEq", + "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType", + "PCP.Algebraic.ThreeColorVerifier.Proof.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HEq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Frobenius fixes the difference of two cubic roots. ", + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.sub_fourth_eq_self", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [CharP F 2] {a b : F}, a ^ 3 = 1 → b ^ 3 = 1 → (a - b) ^ 4 = a - b", + "type_dependencies": [ + "Field", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 44, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.smallError_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), PCP.Algebraic.GeneratorLowDegreeTest.smallError c < 1 / (2 * (↑c + 2) ^ 2)", + "type_dependencies": [ + "Nat", + "LT.lt", + "Rat", + "Rat.instLT", + "PCP.Algebraic.GeneratorLowDegreeTest.smallError", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 302, + "is_class": false, + "kind": "definition", + "line": 301, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → {c : ℕ} → (Fin (c + 1) → F) → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.LagrangeConstraint.check", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The auxiliary oracle explicitly uses degree-one Hadamard labels. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → Type (max u_4 u_3)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : Type u_1) (motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u_2) (a : Bool)\n (h_1 : (a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a))\n (h_2 : (a : V) → (a_1 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)),\n (match PCP.Reduction.NAEThreeColor.Literal.const a with\n | PCP.Reduction.NAEThreeColor.Literal.const a => h_1 a\n | PCP.Reduction.NAEThreeColor.Literal.var a a_1 => h_2 a a_1) =\n h_1 a", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "Eq", + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.exists_program._proof_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (P : PCP.Lang.Prog) (A C D : ℕ)\n (x : List Bool),\n PCP.Lang.listSize\n ((PCP.Reduction.NPTableauGraphLang.program h hs eK eA).run\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q) x)) ≤\n D *\n (Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1) ^\n 2 →\n P.cost (List.map Bool.toNat x) ≤ A * (2 * x.length + 1) ^ 2 →\n PCP.Lang.listSize\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q) x) ≤\n A * (2 * x.length + 1) →\n (PCP.Reduction.NPTableauGraphLang.program h hs eK eA).cost\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q) x) ≤\n C *\n (A * (2 * x.length + 1) + Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1) ^\n 6 →\n ¬P.cost (List.map Bool.toNat x) +\n (PCP.Reduction.NPTableauGraphLang.program h hs eK eA).cost\n (PCP.Machine.NPTableauSource.input\n (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q))\n (Polynomial.eval x.length q) x) +\n PCP.Lang.listSize\n (PCP.Machine.NPTableauSource.input\n (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q)\n x) +\n PCP.Lang.listSize\n ((PCP.Reduction.NPTableauGraphLang.program h hs eK eA).run\n (PCP.Machine.NPTableauSource.input\n (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q)\n x)) +\n 5 ≤\n A * (2 * x.length + 1) ^ 2 +\n C *\n (A * (2 * x.length + 1) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1) ^\n 6 +\n A * (2 * x.length + 1) +\n D *\n (Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1) ^\n 2 +\n 5 →\n False", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Lang.Prog", + "LE.le", + "instLENat", + "PCP.Lang.listSize", + "PCP.Lang.Prog.run", + "PCP.Reduction.NPTableauGraphLang.program", + "PCP.Machine.NPTableauSource.input", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Lang.Prog.cost", + "List.map", + "Bool.toNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 126, + "is_class": false, + "kind": "definition", + "line": 126, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 1 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "theorem", + "line": 31, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.expect_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {U : Type u_5} {V : Type u_6} [inst : Fintype U] [inst_1 : Fintype V] (f : U × V → ℚ),\n (Finset.univ.expect fun uv => f uv) = Finset.univ.expect fun u => Finset.univ.expect fun v => f (u, v)", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.expect_shared_snd", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (f : W × S → ℚ),\n (Finset.univ.expect fun s => f (s.1, s.2.2)) = Finset.univ.expect fun s => f s", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An explicit rejection lower bound, with a provably positive denominator. ", + "end_line": 325, + "is_class": false, + "kind": "theorem", + "line": 300, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ p' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) ≤\n δP →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δM →\n ((1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 - δP - 2 * δM -\n ↑D / ↑(Fintype.card F - 1)) /\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) ≤\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p' M' A", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "Fin.fintype", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instFintypeSum", + "instDecidableEqSum", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Rat.instMul", + "instSubNat", + "Rat.instAdd", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The decision depends only on the stated finite query list. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 86, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)\n (f g : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H K : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n (∀ p ∈ PCP.Algebraic.EncodedLineLowDegreeTest.queries hr ρ nodes ζ s,\n PCP.Algebraic.EncodedLineLowDegreeTest.read f H p = PCP.Algebraic.EncodedLineLowDegreeTest.read g K p) →\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ f H s =\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ g K s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The lines-table corrector accepts a wrong origin value with probability at\nmost the comparator's global error plus `D/(|F|-1)`. No small-error premise is needed. ", + "end_line": 226, + "is_class": false, + "kind": "theorem", + "line": 203, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.accepted_wrong_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {D : ℕ} (T : (σ → F) → Polynomial F),\n (∀ (b : σ → F), (T b).natDegree ≤ D) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n ∀ (a : σ → F) (f : (σ → F) → F),\n (PCP.Algebraic.AffineLineSampling.fraction fun s =>\n Polynomial.eval (↑s.2) (T s.1) = f (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2) ∧\n Polynomial.eval 0 (T s.1) ≠ (MvPolynomial.eval a) P) ≤\n (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) + ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.AffineLineSampling.fraction", + "Prod", + "Units", + "Semiring.toMonoid", + "instFintypeProd", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "And", + "Eq", + "Polynomial.eval", + "Units.val", + "Prod.snd", + "Prod.fst", + "PCP.Algebraic.PolynomialLine.point", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "PCP.Algebraic.relativeDistance", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (u v : σ → F),\n PCP.Algebraic.StandardLocalCorrection.queries c ζ u v =\n List.ofFn fun i => PCP.Algebraic.PolynomialLine.point u v (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i)", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "List", + "PCP.Algebraic.StandardLocalCorrection.queries", + "List.ofFn", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.consecutiveSamplesEquiv._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (s : ((σ → F) × (σ → F)) × F),\n ((PCP.Algebraic.PointLineTest.consecutivePointsEquiv\n ((PCP.Algebraic.PointLineTest.consecutivePointsEquiv s.2) s.1, s.2).2).symm\n ((PCP.Algebraic.PointLineTest.consecutivePointsEquiv s.2) s.1, s.2).1,\n ((PCP.Algebraic.PointLineTest.consecutivePointsEquiv s.2) s.1, s.2).2) =\n s", + "type_dependencies": [ + "Field", + "Prod", + "Eq", + "Prod.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.PointLineTest.consecutivePointsEquiv", + "Prod.snd", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every basis image is homogeneous of degree `c`, including the image of `1`. ", + "end_line": 138, + "is_class": false, + "kind": "theorem", + "line": 132, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial_isHomogeneous", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n (PCP.Algebraic.SetMultilinear.digitMonomial m c k).IsHomogeneous c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "MvPolynomial.IsHomogeneous", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 40, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign_sq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a : ZMod 2), PCP.Algebraic.BLR.sign a ^ 2 = 1", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "PCP.Algebraic.BLR.sign", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 214, + "is_class": false, + "kind": "theorem", + "line": 210, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.natDegree_cubic_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [Nontrivial F], PCP.Algebraic.HadamardDerivedOracle.cubic.natDegree ≤ 3", + "type_dependencies": [ + "CommRing", + "Nontrivial", + "LE.le", + "Nat", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (x : Fin (n + n) → F),\n (PCP.Algebraic.HadamardDerivedOracle.weightedCubic (PCP.Algebraic.ThreeColorVerifier.edgeValue H G x)).natDegree ≤ 3", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "constructor", + "line": 135, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One primary read and two `3c+9`-query calls. ", + "end_line": 99, + "is_class": false, + "kind": "theorem", + "line": 90, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (s : PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t),\n (PCP.Algebraic.BinaryZeroOnGridCorrection.queries ρ nodes ζ H s).length ≤ 6 * c + 19", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "PCP.Algebraic.BinaryZeroOnGridCorrection.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A homogeneous binary linear form indexed by its coefficients. ", + "end_line": 130, + "is_class": false, + "kind": "definition", + "line": 128, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.linearForm", + "provenance": "lean", + "structural_dependencies": [], + "type": "{ι : Type u_1} → [Fintype ι] → (ι → ZMod 2) → (ι → ZMod 2) →ₗ[ZMod 2] ZMod 2", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Finset.sum", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.addCommMonoid", + "Finset.univ", + "HSMul.hSMul", + "Pi.module", + "instHSMul", + "LinearMap.instSMul", + "NonUnitalNonAssocSemiring.toDistribSMul", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "ZMod.commRing", + "PCP.Algebraic.BLR.linearForm._proof_1", + "LinearMap.proj" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The endpoint prediction error supplied by mixed-plane consistency. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.endpointError", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℚ → ℕ → ℚ", + "type_dependencies": [ + "Rat", + "Nat" + ], + "value_dependencies": [ + "Rat", + "Nat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "PCP.Algebraic.PointLineConstants.agreementError" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 45, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.readCell_of_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} (s : PCP.Machine.TableauCells.Cells tm B) (k : tm.K) (j : ℕ),\n B ≤ j → PCP.Machine.TableauCells.readCell s k j = none", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.K", + "LE.le", + "instLENat", + "Eq", + "Option", + "Turing.FinTM2.Γ", + "PCP.Machine.TableauCells.readCell", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r),\n PCP.Algebraic.Hadamard.homogeneousIndex hr =\n ∑ i, (LinearMap.proj i).smulRight (PCP.Algebraic.BinaryPolynomialSpace.variableCoeff hr i)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Finset.sum", + "LinearMap.addCommMonoid", + "Finset.univ", + "Fin.fintype", + "LinearMap.smulRight", + "PCP.Algebraic.Hadamard.homogeneousIndex._proof_1", + "LinearMap.proj", + "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Generic assembly keeps the fixed verifier opaque during kernel checking. ", + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 16, + "module": "PCP.Algebraic.ThreeColorFinalAssembly", + "name": "PCP.Algebraic.ThreeColorFinalAssembly.assemble", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b q : ℕ) (targetBound : Polynomial ℕ),\n PCP.Machine.PolyTimeAlg alg →\n (∀ (f : List Bool → List Bool) (budget : ℕ → ℕ)\n (h : ∀ (x : List Bool), V.randomness (f x).length ≤ budget x.length),\n (PCP.Verifier.Reduction.verifier V f budget h).ImplementedBy fun x bits answers => alg (f x) bits answers) →\n V.queries = q →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length targetBound)) →\n (∀ (x : List Bool), (PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 → V.CompleteAt x) →\n (∀ (x : List Bool), ¬(PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 → V.SoundAt x (1 / 2)) →\n ∀ (L : PCP.Language),\n PCP.InNP PCP.Machine.PolyTimeRel L →\n ∃ V alg a b q p,\n PCP.Machine.PolyTimeAlg alg ∧\n V.ImplementedBy alg ∧\n V.queries = q ∧\n V.CanonicalRandomness a b ∧\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) ∧\n (∀ (x : List Bool), L x → V.CompleteAt x) ∧\n ∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)", + "type_dependencies": [ + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.Machine.PolyTimeAlg", + "List", + "Bool", + "LE.le", + "instLENat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.Reduction.verifier", + "Eq", + "PCP.Verifier.queries", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 144, + "is_class": false, + "kind": "theorem", + "line": 138, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.eval_formalQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (x : Fin t → ZMod 2),\n (MvPolynomial.eval x) (PCP.Algebraic.HadamardComposition.formalQuery ρ P L) =\n (PCP.Algebraic.BinaryPolynomialSpace.evaluate (ρ (Polynomial.eval (ρ.symm x) P))) L", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.HadamardComposition.formalQuery", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.evaluate", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "LinearEquiv.symm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Primary Hadamard rejection is a marginal of the actual conjunction tester. ", + "end_line": 111, + "is_class": false, + "kind": "theorem", + "line": 80, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.primary_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n PCP.Algebraic.Hadamard.averageRejectionRate hr f ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.Hadamard.averageRejectionRate", + "Pi.instFintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A physical query is answered by precisely its tagged received table. ", + "end_line": 147, + "is_class": false, + "kind": "definition", + "line": 138, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → PCP.Algebraic.ThreeColorVerifier.Query F n m c t → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Query", + "ZMod", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.read.match_1", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The row through `x`, viewed as a polynomial in the second coordinate. ", + "end_line": 216, + "is_class": false, + "kind": "definition", + "line": 214, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : Field F] → MvPolynomial (Fin 2) F → F → Polynomial F", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial", + "CommSemiring.toSemiring" + ], + "value_dependencies": [ + "Field", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.PointLineCrossing.axisRestrict", + "instDecidableEqFin", + "Matrix.vecCons", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "Matrix.vecEmpty", + "Fin.instOfNat", + "PCP.Algebraic.PointLineCrossing.rowPolynomial._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A closed, non-strict rejection threshold convenient for downstream decoding. ", + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.smallError", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 74, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.eval_edgeExtension", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)) (a b : σ → ↥H),\n (MvPolynomial.eval (Sum.elim (fun i => ↑(a i)) fun i => ↑(b i))) (PCP.Algebraic.ThreeColorGrid.edgeExtension H G) =\n if G.Adj a b then 1 else 0", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum.elim", + "Subtype.val", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "ite", + "SimpleGraph.Adj", + "Classical.propDecidable", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "For polynomial rows, the deficit in the preceding estimate is `d / |F|`.\nThe chosen column is arbitrary, rather than a fresh random column. ", + "end_line": 103, + "is_class": false, + "kind": "theorem", + "line": 93, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.polynomial_transverse_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype I]\n {d : ℕ} (R S : I → Polynomial F),\n (∀ (i : I), (R i).natDegree ≤ d) →\n (∀ (i : I), (S i).natDegree ≤ d) →\n ∀ (y : F),\n (PCP.Algebraic.relativeDistance (fun i => Polynomial.eval y (R i)) fun i => Polynomial.eval y (S i)) ≤\n (PCP.Algebraic.relativeDistance (fun p => Polynomial.eval p.2 (R p.1)) fun p => Polynomial.eval p.2 (S p.1)) +\n ↑d / ↑(Fintype.card F)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Polynomial.eval", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Prod", + "instFintypeProd", + "Prod.snd", + "Prod.fst", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (accept : Bool), (PCP.QueryTree.leaf accept).addresses = ∅", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "Finset", + "PCP.QueryTree.addresses", + "PCP.QueryTree.leaf", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.colorValue_cube", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {ω : F},\n IsPrimitiveRoot ω 3 → ∀ (i : Fin 3), PCP.Algebraic.ThreeColorAlgebra.colorValue ω i ^ 3 = 1", + "type_dependencies": [ + "Field", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Fin", + "Eq", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.ThreeColorAlgebra.colorValue", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) →\n ((color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t) →\n (validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t) →\n (properLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t) →\n motive\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines }) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.color.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n (motive : PCP.Reduction.NAEThreeColor.Vertex V C → Sort u_3) →\n (x : PCP.Reduction.NAEThreeColor.Vertex V C) →\n ((i : Fin 3) → motive (Sum.inl i)) →\n ((v : V) → (b : Bool) → motive (Sum.inr (Sum.inl (v, b)))) →\n ((e : C) → (i : Fin 3) → motive (Sum.inr (Sum.inr (e, i)))) → motive x", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An unused uniform scalar preserves the fixed-width seed encoding without changing rejection. ", + "end_line": 309, + "is_class": false, + "kind": "definition", + "line": 306, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [Field F] →\n {c : ℕ} → [Fintype F] → [DecidableEq F] → [Fintype σ] → [DecidableEq σ] → (Fin (c + 1) → F) → ((σ → F) → F) → ℚ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.FixedLagrangeConstraint.check", + "Prod.fst", + "Prod.snd", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b b_1 : Bool), (PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1) = (b = b_1)", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A point-oracle query or a query to one auxiliary encoded line. ", + "end_line": 42, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.Query", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → Type (max u_3 u_4)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateAgreement", + "name": "PCP.Algebraic.BivariateAgreement.exists_nearby_of_close_columns._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [Fintype F] [DecidableEq F] {d : ℕ},\n 0 < d →\n ∀ (a : Fin (10 * d) → F) (C : Fin (10 * d) → Polynomial F) (R : F → Polynomial F) (E N : MvPolynomial (Fin 2) F),\n ¬d + 2 * d < 10 * d → False", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "Not", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Sharp BLR soundness: rejection probability bounds distance to a linear form. ", + "end_line": 311, + "is_class": false, + "kind": "theorem", + "line": 305, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.exists_linearForm_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (H : (ι → ZMod 2) → ZMod 2),\n ∃ a, PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.BLR.linearForm a) ≤ PCP.Algebraic.BLR.rejectionProbability H", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Exists", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.linearForm", + "PCP.Algebraic.BLR.rejectionProbability", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.smallError.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.PointLineConstants.smallError = 1 / 4000000", + "type_dependencies": [ + "Eq", + "Rat", + "PCP.Algebraic.PointLineConstants.smallError", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A nonzero polynomial kernel yields a nonzero assembled locator when distinct\nnodes outnumber the numerator's degree. The argument is over the integral domain `F[Y]`. ", + "end_line": 218, + "is_class": false, + "kind": "theorem", + "line": 196, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.assembled_locator_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] {d e : ℕ} [inst_1 : Fintype I] (a : I → F),\n Function.Injective a →\n ∀ (columns : I → Polynomial F) (v : PCP.Algebraic.BerlekampWelchMatrix.Unknowns d e → Polynomial F),\n v ≠ 0 →\n (PCP.Algebraic.BerlekampWelchMatrix.matrix d e a columns).mulVec v = 0 →\n d + e < Fintype.card I → (PCP.Algebraic.BerlekampWelchCertificate.assemble fun j => v (Sum.inr j)) ≠ 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BerlekampWelchMatrix.Unknowns", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Pi.instZero", + "Polynomial.instZero", + "Eq", + "Matrix.mulVec", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "Polynomial.commRing", + "Field.toCommRing", + "instFintypeSum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "instOfNatNat", + "Fin.fintype", + "PCP.Algebraic.BerlekampWelchMatrix.matrix", + "LT.lt", + "instLTNat", + "Fintype.card", + "MvPolynomial", + "PCP.Algebraic.BerlekampWelchCertificate.assemble", + "Sum.inr", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 76, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instFintypeLiteral", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → [Fintype V] → Fintype (PCP.Reduction.NAEThreeColor.Literal V)", + "type_dependencies": [ + "Fintype", + "PCP.Reduction.NAEThreeColor.Literal" + ], + "value_dependencies": [ + "Fintype", + "Fintype.ofEquiv", + "PCP.Reduction.NAEThreeColor.Literal", + "Sum", + "Bool", + "Sigma", + "instFintypeSum", + "Bool.fintype", + "Sigma.instFintype", + "PCP.Reduction.NAEThreeColor.Literal.proxyTypeEquiv" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One time bound for all witnesses of a given input. ", + "end_line": 57, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.timePoly", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} → PCP.Machine.NPTableau.Checker R → Polynomial ℕ → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Polynomial.comp", + "Turing.TM2ComputableInPolyTime.time", + "Prod", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "PCP.Machine.NPTableau.inputPoly" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The proof oracle determined by a finite witness: address `j` holds `w[j]`, and `false` at every\naddress beyond `w`. Padding with `false` is harmless exactly because a verifier satisfying\n`Verifier.ReadsBelow x N` never looks past address `N`. ", + "end_line": 201, + "is_class": false, + "kind": "definition", + "line": 198, + "module": "PCP.Verifier.Definition", + "name": "PCP.oracleOfWitness", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool → PCP.ProofOracle", + "type_dependencies": [ + "List", + "Bool", + "PCP.ProofOracle" + ], + "value_dependencies": [ + "List", + "Bool", + "Nat", + "List.getD", + "Bool.false" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.columnPolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (P : MvPolynomial (Fin 2) F) (y : F),\n PCP.Algebraic.PointLineCrossing.columnPolynomial P y = (PCP.Algebraic.PointLineCrossing.axisRestrict ![0, y] 0) P", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.PointLineCrossing.columnPolynomial", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.PointLineCrossing.axisRestrict", + "instDecidableEqFin", + "Matrix.vecCons", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "Matrix.vecEmpty", + "Fin.instOfNat", + "PCP.Algebraic.PointLineCrossing.rowPolynomial._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The precise block condition in Definition 3.1, stronger than a total-degree bound. ", + "end_line": 190, + "is_class": false, + "kind": "theorem", + "line": 184, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_isSetMultilinear", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n PCP.Algebraic.SetMultilinear.IsSetMultilinear m c ((PCP.Algebraic.SetMultilinear.encode m c) P)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.SetMultilinear.IsSetMultilinear", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval_congr.match_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀\n (motive :\n (x : ℕ) → (x_1 : PCP.QueryTree x) → (x_2 x_3 : PCP.ProofOracle) → (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → Prop)\n (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 x_3 : PCP.ProofOracle) (x_4 : ∀ a ∈ x_1.addresses, x_2 a = x_3 a),\n (∀ (x : ℕ) (accept : Bool) (x_5 x_6 : PCP.ProofOracle)\n (x_7 : ∀ a ∈ (PCP.QueryTree.leaf accept).addresses, x_5 a = x_6 a),\n motive x (PCP.QueryTree.leaf accept) x_5 x_6 x_7) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d) (π π' : PCP.ProofOracle)\n (h : ∀ a_1 ∈ (PCP.QueryTree.query a f t).addresses, π a_1 = π' a_1),\n motive (d + 1) (PCP.QueryTree.query a f t) π π' h) →\n motive x x_1 x_2 x_3 x_4", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 53, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.eval_series", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommRing R] {k : ℕ} (v : Fin (k + 1) → R) (x : R),\n Polynomial.eval x (PCP.Algebraic.BerlekampWelchCertificate.series v) = ∑ j, v j * x ^ ↑j", + "type_dependencies": [ + "CommRing", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Polynomial.eval", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.BerlekampWelchCertificate.series", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.read.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t)\n (q : (Fin n → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n PCP.Algebraic.BinaryZeroOnGridCorrection.read p M A (Sum.inl q) = p q.1 q.2", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Prod", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.read", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.mapCoefficients.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] (ℓ : F →ₗ[ZMod 2] ZMod 2)\n (q : MvPolynomial σ F),\n PCP.Algebraic.HadamardComposition.mapCoefficients ℓ q = ∑ s ∈ q.support, (MvPolynomial.monomial s) (ℓ (q.coeff s))", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Algebra.toModule", + "Semiring.toModule", + "MvPolynomial", + "Eq", + "PCP.Algebraic.HadamardComposition.mapCoefficients", + "Finset.sum", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "AddMonoidAlgebra.instAddCommMonoid", + "MvPolynomial.support", + "DFunLike.coe", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "MvPolynomial.monomial", + "instMulZeroClassOfSemiring", + "Finsupp.instFunLike", + "AddMonoidAlgebra.coeff" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One direct bit and two independently seeded optional bits, with a shared label. ", + "end_line": 95, + "is_class": false, + "kind": "definition", + "line": 92, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck", + "provenance": "lean", + "structural_dependencies": [], + "type": "{X : Type u_1} →\n {W : Type u_2} →\n {S : Type u_3} →\n (X → W → ZMod 2) →\n (X → W → S → Option (ZMod 2)) → (X → W → S → Option (ZMod 2)) → X × W × S × S → Option (ZMod 2 × ZMod 2)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Prod" + ], + "value_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Prod", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "_private.PCP.Algebraic.BinaryLocalCorrection.0.PCP.Algebraic.BinaryLocalCorrection.read.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t : ℕ} (motive : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → Sort u_3)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl p))\n (h_2 :\n (p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inl p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_1 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.inr", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → (c : ℕ) → F → Fin (c + 1) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.LagrangeConstraint.weight", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.point_parameterShift", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (u v : σ → F) (t s : F),\n PCP.Algebraic.PolynomialLine.point (u + (t - s) • v) v s = PCP.Algebraic.PolynomialLine.point u v t", + "type_dependencies": [ + "Field", + "Eq", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The explicit graph associated to the not-all-equal instance. ", + "end_line": 113, + "is_class": false, + "kind": "definition", + "line": 111, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.graph", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n (C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) → SimpleGraph (PCP.Reduction.NAEThreeColor.Vertex V C)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph", + "PCP.Reduction.NAEThreeColor.Vertex" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.fromRel", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.direct" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Packaging the coefficient polynomials preserves the original degree bound. ", + "end_line": 115, + "is_class": false, + "kind": "theorem", + "line": 98, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.totalDegree_certificate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] [IsDomain R] (H : Finset R),\n H.Nonempty →\n ∀ (Q : σ → MvPolynomial σ R) (d : ℕ),\n (∀ (i : σ), Q i ≠ 0 → (Q i).totalDegree + H.card ≤ d) →\n (PCP.Algebraic.GridVanishing.certificate Q).totalDegree ≤ d", + "type_dependencies": [ + "CommRing", + "Fintype", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Nat", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "MvPolynomial.totalDegree", + "Finset.card", + "Sum", + "PCP.Algebraic.GridVanishing.certificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {W : Type u_3} [inst : Field F] (a : σ → F) (s : ((σ → F) × Fˣ) × W),\n (((PCP.Algebraic.affineSamplingEquiv a ↑(((PCP.Algebraic.affineSamplingEquiv a ↑s.1.2 ⋯) s.1.1, s.2), s.1.2).2 ⋯).symm\n (((PCP.Algebraic.affineSamplingEquiv a ↑s.1.2 ⋯) s.1.1, s.2), s.1.2).1.1,\n (((PCP.Algebraic.affineSamplingEquiv a ↑s.1.2 ⋯) s.1.1, s.2), s.1.2).2),\n (((PCP.Algebraic.affineSamplingEquiv a ↑s.1.2 ⋯) s.1.1, s.2), s.1.2).1.2) =\n s", + "type_dependencies": [ + "Field", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Prod.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.affineSamplingEquiv", + "Field.toDivisionRing", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Pi.Function.module", + "Ring.toSemiring", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "Units.val", + "Prod.snd", + "Prod.fst", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_1", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_3" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 125, + "is_class": false, + "kind": "definition", + "line": 125, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n {a' : PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n PCP.Algebraic.ThreeColorVerifier.Query.color a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.color a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d),\n f.addresses.card < 2 ^ d →\n t.addresses.card < 2 ^ d →\n (insert a (f.addresses ∪ t.addresses)).card ≤ 1 + (f.addresses.card + t.addresses.card) →\n ¬(insert a (f.addresses ∪ t.addresses)).card < 2 ^ (d + 1) → False", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "Insert.insert", + "Finset", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.fieldPolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F),\n PCP.Algebraic.HadamardComposition.fieldPolynomial ρ P =\n Polynomial.eval₂ MvPolynomial.C (PCP.Algebraic.HadamardComposition.coordinatePolynomial ρ) P", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "Eq", + "MvPolynomial", + "PCP.Algebraic.HadamardComposition.fieldPolynomial", + "Polynomial.eval₂", + "AddMonoidAlgebra.semiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.C", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Rowwise plurality has no more prediction error than any proposed word. ", + "end_line": 68, + "is_class": false, + "kind": "theorem", + "line": 61, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.Plurality.prediction_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {A : Type u_2} [inst : Fintype R] [inst_1 : Finite A] [inst_2 : Nonempty A] [inst_3 : DecidableEq A]\n {X : Type u_3} [inst_4 : Fintype X] (pred : X → R → A) (f : X → A),\n (PCP.Algebraic.relativeDistance (fun xr => pred xr.1 xr.2) fun xr => PCP.Algebraic.Plurality.value (pred xr.1)) ≤\n PCP.Algebraic.relativeDistance (fun xr => pred xr.1 xr.2) fun xr => f xr.1", + "type_dependencies": [ + "Fintype", + "Finite", + "Nonempty", + "DecidableEq", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Plurality.value" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encode._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b ≠ 0) = (a ≠ b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "Ne", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Cubic membership reads have the same randomized homogeneous marginal bound. ", + "end_line": 253, + "is_class": false, + "kind": "theorem", + "line": 245, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.cubic_homogeneous_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} [inst_2 : Nontrivial F] {I : Type u_2}\n [inst_3 : Fintype I] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (H : I → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) (f : I → F),\n (PCP.Algebraic.relativeDistance\n (fun s =>\n PCP.Algebraic.HadamardDerivedOracle.answer ρ PCP.Algebraic.HadamardDerivedOracle.cubic ⋯ (H s.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex ⋯) s.2.1) s.2.2)\n fun s => (PCP.Algebraic.Hadamard.linearEncode (ρ (f s.1 ^ 3 - 1))) s.2.1) ≤\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ H f", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Nontrivial", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.decidableEq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_cubic_le", + "Prod.fst", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "le_refl", + "Nat.instPreorder", + "Prod.snd", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "theorem", + "line": 126, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.proofLength_le_bound", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n PCP.Algebraic.ThreeColorBinaryVerifier.proofLength (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x) ≤\n Polynomial.eval x.length PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound", + "type_dependencies": [ + "List", + "Bool", + "LE.le", + "Nat", + "instLENat", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "Polynomial.eval", + "Nat.instSemiring", + "List.length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.input_length_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (q : Polynomial ℕ) {x w : List Bool},\n w.length ≤ Polynomial.eval x.length q → ¬x.length + w.length + 1 ≤ x.length + Polynomial.eval x.length q + 1 → False", + "type_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring", + "List", + "Bool", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Not", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The three actual queries, with no independence requirement on the answers. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 60, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {t r : ℕ} →\n 1 ≤ r → (σ → F) → (σ → F) → (Fin t → ZMod 2) → List (PCP.Algebraic.BinaryDifferenceConsistency.Query F σ t r)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "List", + "PCP.Algebraic.BinaryDifferenceConsistency.Query" + ], + "value_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "List.cons", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Sum.inr", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum", + "Prod.mk", + "Sum.elim", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Sum.inl", + "List.nil" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.PointLineEndpointConsistency.fraction_endpoint_disagreement_le._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Sort u_1} {a b : α}, (a ≠ b) = (b ≠ a)", + "type_dependencies": [ + "Eq", + "Ne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "_private.PCP.Algebraic.BinaryLocalCorrection.0.PCP.Algebraic.BinaryLocalCorrection.read.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t : ℕ} (motive : PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → Sort u_3)\n (p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl p))\n (h_2 :\n (p :\n (σ → F) ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inr p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_2 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The formal polynomial `P(a)-P(b)` on two copies of the variables. ", + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → MvPolynomial σ R → MvPolynomial (σ ⊕ σ) R", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum" + ], + "value_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "HSub.hSub", + "Sum", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "DFunLike.coe", + "AlgHom", + "AddMonoidAlgebra.semiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Sum.inl", + "Sum.inr" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (a : Fin (c + 1) → F) (f : (σ → F) → F),\n PCP.Algebraic.FixedLagrangeConstraint.rejectionRate a f =\n PCP.Algebraic.relativeDistance (fun s => PCP.Algebraic.FixedLagrangeConstraint.check a f s.1.1 s.1.2) fun x => 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.FixedLagrangeConstraint.check", + "Prod.fst", + "Prod.snd", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The relation defines `L`. ", + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L) (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length self.witnessBound ∧ self.check x w = true", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Iff", + "Exists", + "And", + "LE.le", + "Nat", + "instLENat", + "List.length", + "Polynomial.eval", + "Nat.instSemiring", + "PCP.NPCertificate.witnessBound", + "Eq", + "PCP.NPCertificate.check", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.NAE.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Fin 3 → Bool), PCP.Reduction.NAEThreeColor.NAE b = (b 0 ≠ b 1 ∨ b 1 ≠ b 2)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.NAE", + "Or", + "Ne", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Cancelling a nonzero locator evaluation forces agreement at a selected column. ", + "end_line": 169, + "is_class": false, + "kind": "theorem", + "line": 159, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.agreement_of_certificate_row", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] (a : I → F) (C : I → Polynomial F) (R : F → Polynomial F)\n (E N : MvPolynomial (Fin 2) F),\n (∀ (i : I),\n PCP.Algebraic.PointLineCrossing.rowPolynomial N (a i) =\n C i * PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i)) →\n ∀ (y : F),\n PCP.Algebraic.PointLineCrossing.columnPolynomial N y =\n R y * PCP.Algebraic.PointLineCrossing.columnPolynomial E y →\n ∀ (i : I),\n Polynomial.eval y (PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i)) ≠ 0 →\n Polynomial.eval (a i) (R y) = Polynomial.eval y (C i)", + "type_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "PCP.Algebraic.PointLineCrossing.columnPolynomial", + "Ne", + "Polynomial.eval", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.eval_zero_eq_sum._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} (P : Polynomial F), P.natDegree ≤ c → ¬P.natDegree < c + 1 → False", + "type_dependencies": [ + "Field", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Not", + "LT.lt", + "instLTNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Substitute polynomials for the second block, keeping the first block formal. ", + "end_line": 31, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n {σ : Type u_2} → [inst : CommRing R] → (σ → MvPolynomial σ R) → MvPolynomial (σ ⊕ σ) R →+* MvPolynomial σ R", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid" + ], + "value_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "MvPolynomial.eval₂Hom", + "Sum", + "AddMonoidAlgebra.commSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "MvPolynomial.C", + "Sum.elim", + "MvPolynomial.X" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.linearEncode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x : Fin t → ZMod 2), PCP.Algebraic.Hadamard.linearEncode x = ∑ i, x i • LinearMap.proj i", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.linearEncode", + "Finset.sum", + "LinearMap.addCommMonoid", + "Finset.univ", + "Fin.fintype", + "HSMul.hSMul", + "Pi.module", + "instHSMul", + "LinearMap.instSMul", + "NonUnitalNonAssocSemiring.toDistribSMul", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "ZMod.commRing", + "PCP.Algebraic.Hadamard.linearEncode._proof_1", + "LinearMap.proj" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual formal line table extracted from decoded inner polynomials. ", + "end_line": 241, + "is_class": false, + "kind": "definition", + "line": 236, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.decodedTable", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n {m c : ℕ} →\n [NeZero m] →\n (Q :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ →\n MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F) →\n (∀ (uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ), (Q uv).totalDegree ≤ c) →\n PCP.Algebraic.PointLineTest.LineTable F σ (c * m ^ c)", + "type_dependencies": [ + "Field", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.PointLineTest.LineTable", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [ + "Field", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Prod", + "Subtype.mk", + "Polynomial", + "CommSemiring.toSemiring", + "Polynomial.natDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "PCP.Algebraic.EncodedLineLowDegreeTest.decodedTable._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Branch order: color, valid certificate, difference, proper certificate,\nvalid grid, proper grid, difference consistency. ", + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 82, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → Fin 7 → Type u_2", + "type_dependencies": [ + "Monoid", + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Matrix.vecCons", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "ZMod", + "Matrix.vecEmpty" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The field construction is available at the chosen exponent for every graph size. ", + "end_line": 94, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.choice_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N ∧\n N ≤\n (PCP.Algebraic.ThreeColorParameters.grid (PCP.Algebraic.ThreeColorParameterChoice.exponent N)).card ^\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent N) ∧\n PCP.Algebraic.ThreeColorParameterChoice.volume N ≤ 4 * max 8 (Nat.clog 2 N)", + "type_dependencies": [ + "Nat", + "And", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Finset.card", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.volume", + "HMul.hMul", + "instHMul", + "instMulNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False", + "type_dependencies": [ + "GroupWithZero", + "Int", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass", + "GroupWithZero.toMonoidWithZero", + "Eq", + "HPow.hPow", + "instHPow", + "ZPow.toPow", + "DivInvMonoid.toZPow", + "GroupWithZero.toDivInvMonoid", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬PCP.Algebraic.ThreeColorParameterChoice.exponent N = PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1 + 1 →\n False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Not", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 56, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.correct_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {c t : ℕ} {ζ : F}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (Q : MvPolynomial σ F),\n Q.totalDegree ≤ c →\n ∀ (u v : σ → F) (w : Fin t → ZMod 2),\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) Q)))) u v w =\n (PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval u) Q))) w", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.Hadamard.linearEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The coloring membership cubic can be substituted without making a fixed random oracle. ", + "end_line": 212, + "is_class": false, + "kind": "theorem", + "line": 200, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.cubic_rejection_transfer", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) (f : (Fin n → F) → F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ (f x ^ 3 - 1)))) M A ≤\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ (fun x => PCP.Algebraic.HadamardDerivedOracle.cubic) ⋯ nodes ζ H p M\n A +\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ p f", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Rat.instAdd", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_cubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Length of the single binary word containing the eight physical tables. ", + "end_line": 43, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorQueryIndex.addressLength", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.size", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Nat.choose" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridCorrection.0.PCP.Algebraic.BinaryZeroOnGridCorrection.read.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (motive : PCP.Algebraic.BinaryZeroOnGridCorrection.Query F n m c t → Sort u_2)\n (q : (Fin n → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (h_1 : (q : (Fin n → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl q))\n (h_2 :\n (q :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n ×\n PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t) →\n motive (Sum.inr q)),\n (match Sum.inl q with\n | Sum.inl q => h_1 q\n | Sum.inr q => h_2 q) =\n h_1 q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Sum.inr", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ], + "value_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk", + "PCP.CostModel.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_const", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] [Nonempty α] (c : ℚ), (PCP.Algebraic.BLR.average fun x => c) = c", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3) →\n ((x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin n ⊕ Fin n)) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.Plurality.value.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {A : Type u_2} [inst : Fintype R] [inst_1 : Finite A] [inst_2 : Nonempty A] [inst_3 : DecidableEq A]\n (w w_1 : R → A), w = w_1 → PCP.Algebraic.Plurality.value w = PCP.Algebraic.Plurality.value w_1", + "type_dependencies": [ + "Fintype", + "Finite", + "Nonempty", + "DecidableEq", + "Eq", + "PCP.Algebraic.Plurality.value" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A word differs from the rowwise plurality on at most twice its prediction error. ", + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 70, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.Plurality.distance_le_twice_prediction_error", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {A : Type u_2} [inst : Fintype R] [inst_1 : Finite A] [inst_2 : Nonempty A] [inst_3 : DecidableEq A]\n {X : Type u_3} [inst_4 : Fintype X] [Nonempty R] (pred : X → R → A) (f : X → A),\n (PCP.Algebraic.relativeDistance f fun x => PCP.Algebraic.Plurality.value (pred x)) ≤\n 2 * PCP.Algebraic.relativeDistance (fun xr => f xr.1) fun xr => pred xr.1 xr.2", + "type_dependencies": [ + "Fintype", + "Finite", + "Nonempty", + "DecidableEq", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.Plurality.value", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same translation identity in the paper's Hadamard-encoding notation. ", + "end_line": 174, + "is_class": false, + "kind": "theorem", + "line": 168, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.encode_query", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (hP : P.natDegree ≤ r) (u : F),\n (PCP.Algebraic.Hadamard.encode r (ρ u)) (PCP.Algebraic.HadamardComposition.query ρ P L hP) =\n (PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval u P))) L", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.HadamardComposition.query", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Polynomial distance for an arbitrary finite variable type, by bijective renaming. ", + "end_line": 262, + "is_class": false, + "kind": "theorem", + "line": 249, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.eval_distance_ge_finite", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n {D : ℕ} [inst_4 : DecidableEq F] (P Q : MvPolynomial σ F),\n P.totalDegree ≤ D →\n Q.totalDegree ≤ D →\n P ≠ Q →\n 1 - ↑D / ↑(Fintype.card F) ≤\n PCP.Algebraic.relativeDistance (fun x => (MvPolynomial.eval x) P) fun x => (MvPolynomial.eval x) Q", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Ne", + "Rat", + "Rat.instLE", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "OfNat.ofNat", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 171, + "is_class": false, + "kind": "theorem", + "line": 169, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_base", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) {i j : Fin 3},\n i ≠ j →\n (PCP.Reduction.NAEThreeColor.graph Q).Adj (PCP.Reduction.NAEThreeColor.base i) (PCP.Reduction.NAEThreeColor.base j)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Ne", + "SimpleGraph.Adj", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "PCP.Reduction.NAEThreeColor.base" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A single decoded message table is close on both query domains. ", + "end_line": 112, + "is_class": false, + "kind": "theorem", + "line": 89, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.exists_messages_of_average_rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {t r : ℕ} [inst : Fintype ι] (hr : 1 ≤ r)\n (H : ι → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n ∃ x,\n PCP.Algebraic.relativeDistance (fun p => H p.1 p.2) (PCP.Algebraic.Hadamard.encodeFunction r x) ≤\n 28 * PCP.Algebraic.Hadamard.averageRejectionRate hr H ∧\n (PCP.Algebraic.relativeDistance (fun p => H p.1 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2)) fun p =>\n (PCP.Algebraic.Hadamard.encode r (x p.1)) ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2)) ≤\n 28 * PCP.Algebraic.Hadamard.averageRejectionRate hr H", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Exists", + "Fin", + "And", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.Hadamard.averageRejectionRate", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Assemble an actual bounded polynomial kernel into a nonzero bivariate certificate. ", + "end_line": 233, + "is_class": false, + "kind": "theorem", + "line": 220, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.certificate_of_kernel", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] {d e K : ℕ} [inst_1 : Fintype I] (a : I → F),\n Function.Injective a →\n ∀ (columns : I → Polynomial F) (v : PCP.Algebraic.BerlekampWelchMatrix.Unknowns d e → Polynomial F),\n v ≠ 0 →\n (PCP.Algebraic.BerlekampWelchMatrix.matrix d e a columns).mulVec v = 0 →\n (∀ (j : PCP.Algebraic.BerlekampWelchMatrix.Unknowns d e), (v j).natDegree ≤ K) →\n d + e < Fintype.card I →\n ∃ E N,\n E ≠ 0 ∧\n MvPolynomial.degreeOf 0 E ≤ e ∧\n MvPolynomial.degreeOf 0 N ≤ d + e ∧\n MvPolynomial.degreeOf 1 E ≤ K ∧\n MvPolynomial.degreeOf 1 N ≤ K ∧\n ∀ (i : I),\n PCP.Algebraic.PointLineCrossing.rowPolynomial N (a i) =\n columns i * PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BerlekampWelchMatrix.Unknowns", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Pi.instZero", + "Polynomial.instZero", + "Eq", + "Matrix.mulVec", + "NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocRing", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "Polynomial.commRing", + "Field.toCommRing", + "instFintypeSum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "instOfNatNat", + "Fin.fintype", + "PCP.Algebraic.BerlekampWelchMatrix.matrix", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "LT.lt", + "instLTNat", + "Fintype.card", + "Exists", + "MvPolynomial", + "And", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.degreeOf", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "HMul.hMul", + "instHMul", + "Polynomial.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Preserve an independently sampled label while reindexing a nonzero affine sample. ", + "end_line": 279, + "is_class": false, + "kind": "definition", + "line": 273, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → {W : Type u_3} → [inst : Field F] → (σ → F) → ((σ → F) × Fˣ) × W ≃ ((σ → F) × W) × Fˣ", + "type_dependencies": [ + "Field", + "Equiv", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Equiv.mk", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.affineSamplingEquiv", + "Field.toDivisionRing", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Pi.Function.module", + "Ring.toSemiring", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "Units.val", + "Prod.snd", + "Prod.fst", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_1", + "Equiv.symm", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_2", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_4", + "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_6" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Exact finite-domain to Boolean satisfiability preservation. ", + "end_line": 125, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.satisfiable_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ} (R : C → (Fin d → Fin a) → Bool) (s : C → Fin d → V),\n (∃ b,\n PCP.Reduction.FiniteBooleanConstraints.LocalHolds (PCP.Reduction.FiniteDomainConstraints.relation R)\n (PCP.Reduction.FiniteDomainConstraints.scope s) b) ↔\n ∃ x, PCP.Reduction.FiniteDomainConstraints.Holds R s x", + "type_dependencies": [ + "Nat", + "Fin", + "Bool", + "Iff", + "Exists", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteBooleanConstraints.LocalHolds", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.relation", + "PCP.Reduction.FiniteDomainConstraints.scope", + "PCP.Reduction.FiniteDomainConstraints.Holds" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.basis.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽] [inst_1 : DecidableEq 𝔽] [inst_2 : Fintype σ] (H : Finset 𝔽)\n (a : σ → ↥H),\n PCP.Algebraic.GridInterpolation.basis H a = ∏ i, (Polynomial.toMvPolynomial i) (Lagrange.basis H id ↑(a i))", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GridInterpolation.basis", + "Finset.prod", + "CommRing.toCommMonoid", + "AddMonoidAlgebra.commRing", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Field.toCommRing", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "DFunLike.coe", + "AlgHom", + "Polynomial", + "CommSemiring.toSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Polynomial.algebraOfAlgebra", + "Algebra.id", + "AddMonoidAlgebra.algebra", + "AlgHom.funLike", + "Polynomial.toMvPolynomial", + "Lagrange.basis", + "id", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{a : ℕ} → PCP.QueryTree a → ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.casesOn", + "Bool" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → PCP.Verifier → PCP.Verifier → Sort u", + "type_dependencies": [ + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.Verifier", + "PCP.Verifier.casesOn", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "SizeOf PCP.CostModel", + "type_dependencies": [ + "SizeOf", + "PCP.CostModel" + ], + "value_dependencies": [ + "SizeOf.mk", + "PCP.CostModel", + "PCP.CostModel._sizeOf_1" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.packWitness.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : ℕ} (w w_1 : List Bool) (e_w : w = w_1) (hw : w.length ≤ W),\n PCP.Machine.NPTableau.packWitness w hw = PCP.Machine.NPTableau.packWitness w_1 ⋯", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Eq", + "LE.le", + "instLENat", + "List.length", + "PCP.Machine.NPTableau.BoundedWitness", + "PCP.Machine.NPTableau.packWitness", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A valid query list for every branch of the two actual correction calls. ", + "end_line": 88, + "is_class": false, + "kind": "definition", + "line": 78, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t →\n List (PCP.Algebraic.BinaryZeroOnGridCorrection.Query F n m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "List.cons", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check._proof_1", + "Prod.snd", + "HAppend.hAppend", + "List", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inr", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t)\n (s : PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t) (b : ZMod 2),\n PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit ρ nodes ζ H M A s b =\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck (some b)\n (PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M (A (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1))\n (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1) s.2.1 s.2.2.1)\n (PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M\n (A (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)) (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)\n s.2.1 s.2.2.2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "Sum", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "Prod.fst", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Correction using nearest line polynomials satisfies the same bound against any table. ", + "end_line": 146, + "is_class": false, + "kind": "theorem", + "line": 141, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.distance_decoded_correction_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ c),\n PCP.Algebraic.relativeDistance f\n (PCP.Algebraic.PointLineTest.correction (PCP.Algebraic.PointLineTest.decodedTable c f)) ≤\n 2 * PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.PointLineTest.correction", + "PCP.Algebraic.PointLineTest.decodedTable", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.PointLineTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A label may be shared by both compared answers: affine sampling preserves\nthe complete point-and-label distance exactly. ", + "end_line": 296, + "is_class": false, + "kind": "theorem", + "line": 281, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.affine_units_label_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {W : Type u_3} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] [inst_5 : Fintype W] {K : Type u_4} [inst_6 : DecidableEq K] (a : σ → F)\n (f g : (σ → F) → W → K),\n (PCP.Algebraic.relativeDistance (fun s => f (PCP.Algebraic.PolynomialLine.point a s.1.1 ↑s.1.2) s.2) fun s =>\n g (PCP.Algebraic.PolynomialLine.point a s.1.1 ↑s.1.2) s.2) =\n PCP.Algebraic.relativeDistance (fun s => f s.1 s.2) fun s => g s.1 s.2", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.PolynomialLine.point", + "Prod.fst", + "Units.val", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A §2's `𝒫_d(m, 𝔽)`: functions represented by a polynomial of total degree at most `d`.\n\nThis predicate concerns functions, and does not assert that the representing polynomial\nis unique over a finite field.\n", + "end_line": 103, + "is_class": false, + "kind": "definition", + "line": 97, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.IsLowDegree", + "provenance": "lean", + "structural_dependencies": [], + "type": "{𝔽 : Type u_1} → [Field 𝔽] → {m : ℕ} → ℕ → ((Fin m → 𝔽) → 𝔽) → Prop", + "type_dependencies": [ + "Field", + "Nat", + "Fin" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fin", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : Fintype F]\n {inst_3 : DecidableEq F} [inst_4 : DecidableEq F] (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (Q Q_1 : (Fin n → F) → Polynomial F) (e_Q : Q = Q_1) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r)\n (nodes nodes_1 : Fin (c + 1) → F),\n nodes = nodes_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (H H_1 : Finset F),\n H = H_1 →\n ∀ (p p_1 : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n p = p_1 →\n ∀\n (M M_1 :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n M = M_1 →\n ∀ (A A_1 : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n A = A_1 →\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ Q hQ nodes ζ H p M A =\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ_1 Q_1 ⋯ nodes_1 ζ_1 H_1 p_1 M_1 A_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Exact line-to-polynomial characterization, using ordinary total degree. ", + "end_line": 151, + "is_class": false, + "kind": "theorem", + "line": 103, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.exists_polynomial_of_hasLowDegreeLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {n d : ℕ} (f : (Fin n → F) → F),\n 2 * d < Fintype.card F →\n PCP.Algebraic.PolynomialLine.HasLowDegreeLines d f →\n ∃ P, P.totalDegree ≤ d ∧ ∀ (x : Fin n → F), (MvPolynomial.eval x) P = f x", + "type_dependencies": [ + "Field", + "Fintype", + "Nat", + "Fin", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.PolynomialLine.HasLowDegreeLines", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 155, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph_colorable_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V) (eV : optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V)),\n (PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph G eV).Colorable 3 ↔ G.Colorable 3", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "optParam", + "Equiv", + "Fin", + "Fintype.card", + "Fintype.equivFin", + "Iff", + "SimpleGraph.Colorable", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Subtype", + "PCP.Algebraic.ThreeColorParameters.Field", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "OfNat.ofNat", + "Nat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A satisfying local transition represents the exact source successor. ", + "end_line": 168, + "is_class": false, + "kind": "theorem", + "line": 154, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.step_represents", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} {p p' : PCP.Machine.TableauCells.Prefix tm} {s s' : PCP.Machine.TableauCells.Cells tm B}\n {c : tm.Cfg},\n PCP.Machine.TableauCells.Represents p s c →\n PCP.Machine.TableauCells.Linked p s →\n PCP.Machine.TableauCells.Step p p' s s' →\n (∀ (k : tm.K), ((PCP.Machine.keepStep tm.step c).stk k).length ≤ B) →\n PCP.Machine.TableauCells.Represents p' s' (PCP.Machine.keepStep tm.step c)", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Represents", + "PCP.Machine.TableauCells.Linked", + "PCP.Machine.TableauCells.Step", + "Turing.FinTM2.K", + "LE.le", + "instLENat", + "List.length", + "Turing.FinTM2.Γ", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "PCP.Machine.keepStep", + "Turing.FinTM2.step" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 207, + "is_class": false, + "kind": "definition", + "line": 206, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeSampleSumFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [Fintype F] →\n [DecidableEq F] → {n m c t : ℕ} → Fintype (PCP.Algebraic.BinaryLocalCorrection.Sample F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instDecidableEqSum", + "instDecidableEqFin", + "instFintypeSum", + "Fin.fintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "ZMod.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1._proof_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Evaluate public adjacency at the original two vertex blocks. ", + "end_line": 60, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → {n : ℕ} → (H : Finset F) → SimpleGraph (Fin n → ↥H) → (Fin (n + n) → F) → F", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Function.comp", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`V` reads only proof addresses below `N` on input `x`, whatever the randomness and whatever\nthe oracle answers. This is how \"a proof of polynomial length\" is expressed. ", + "end_line": 119, + "is_class": false, + "kind": "definition", + "line": 116, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.ReadsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → ℕ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "LT.lt", + "instLTNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Encoding an ordinary finite graph gives the intended soundness statement. ", + "end_line": 68, + "is_class": false, + "kind": "theorem", + "line": 65, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.soundAt_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (G : SimpleGraph (Fin N)) [inst : DecidableRel G.Adj],\n ¬G.Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.SoundAt (PCP.Algebraic.ThreeColorEncoding.encode G) (1 / 2)", + "type_dependencies": [ + "Nat", + "SimpleGraph", + "Fin", + "DecidableRel", + "SimpleGraph.Adj", + "Not", + "SimpleGraph.Colorable", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.SoundAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "PCP.Algebraic.ThreeColorEncoding.encode", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 67, + "is_class": false, + "kind": "theorem", + "line": 66, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.queries_length", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {t r : ℕ} (hr : 1 ≤ r) (a b : σ → F) (w : Fin t → ZMod 2),\n (PCP.Algebraic.BinaryDifferenceConsistency.queries hr a b w).length = 3", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "List.length", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "PCP.Algebraic.BinaryDifferenceConsistency.queries" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.prediction.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (table : PCP.Algebraic.PointLineTest.LineTable F σ c)\n (x : σ → F) (vt : (σ → F) × F),\n PCP.Algebraic.PointLineTest.prediction table x vt = Polynomial.eval vt.2 ↑(table (x - vt.2 • vt.1, vt.1))", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.PointLineTest.LineTable", + "Prod", + "Eq", + "PCP.Algebraic.PointLineTest.prediction", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.snd", + "Subtype.val", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Prod.mk", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The precise field cardinality, starting at sixteen. ", + "end_line": 49, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_fieldFamily", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) = 16 ^ (k + 1)", + "type_dependencies": [ + "Nat", + "Eq", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Keep every coordinate fixed except one, whose value is the univariate\nparameter. This is a coordinate slice, so individual degree controls it. ", + "end_line": 168, + "is_class": false, + "kind": "definition", + "line": 163, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.axisRestrict", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [inst : Field F] → [DecidableEq σ] → (σ → F) → σ → MvPolynomial σ F →+* Polynomial F", + "type_dependencies": [ + "Field", + "DecidableEq", + "RingHom", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring" + ], + "value_dependencies": [ + "Field", + "DecidableEq", + "MvPolynomial.eval₂Hom", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial.commSemiring", + "Polynomial.C", + "ite", + "Eq", + "Polynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct._sparseCasesOn_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "{α : Type u} →\n {β : Type v} →\n {motive : α ⊕ β → Sort u_1} →\n (t : α ⊕ β) → ((val : β) → motive (Sum.inr val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t", + "type_dependencies": [ + "Sum", + "Sum.inr", + "Nat.hasNotBit", + "Sum.ctorIdx" + ], + "value_dependencies": [ + "Sum", + "Sum.inr", + "Sum.rec", + "Nat.hasNotBit", + "Sum.ctorIdx", + "Sum.inl", + "Nat.ne_of_beq_eq_false", + "Nat.land", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Nat.shiftRight", + "Eq.refl", + "Bool", + "Bool.false" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {b b_1 : Bool}, PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1 → b = b_1", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "recursor", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.CostModel → Sort u} →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n (t : PCP.CostModel) → motive t", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A finite family can be decoded simultaneously, with both normalized global\ndistances bounded by the average actual row rejection. Empty families are allowed. ", + "end_line": 176, + "is_class": false, + "kind": "theorem", + "line": 146, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.exists_polynomials_of_average_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {c t r : ℕ} {I : Type u_3} [inst_5 : Fintype I],\n 2 * c < Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (a : Fin (c + 1) → F),\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes a →\n ∀ (H : I → (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n ∃ Q,\n (∀ (i : I), (Q i).totalDegree ≤ c) ∧\n ((PCP.Algebraic.relativeDistance (fun p => H p.1 p.2.1 p.2.2) fun p =>\n (PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval p.2.1) (Q p.1)))) p.2.2) ≤\n PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c *\n Finset.univ.expect fun i => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a (H i)) ∧\n (PCP.Algebraic.relativeDistance\n (fun p => H p.1 p.2.1 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2.2)) fun p =>\n (PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval p.2.1) (Q p.1))))\n ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2.2)) ≤\n PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c *\n Finset.univ.expect fun i => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a (H i)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.Hadamard.homogeneousIndex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 40, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), NeZero (4 * (k + 1))", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.answer.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (hP : P.natDegree ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (R : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n PCP.Algebraic.HadamardDerivedOracle.answer ρ P hP H L R =\n PCP.Algebraic.Hadamard.selfCorrect H (PCP.Algebraic.HadamardComposition.query ρ P L hP) R", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardDerivedOracle.answer._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "PCP.Algebraic.Hadamard.selfCorrect", + "Pi.addCommGroup", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.HadamardComposition.query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The two cubic constraint families characterize standard graph three-colorability. ", + "end_line": 105, + "is_class": false, + "kind": "theorem", + "line": 93, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.colorable_iff_exists_satisfies", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} [inst : Field F] [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 → ∀ (G : SimpleGraph V), G.Colorable 3 ↔ ∃ f, PCP.Algebraic.ThreeColorAlgebra.Satisfies G f", + "type_dependencies": [ + "Field", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "SimpleGraph", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "PCP.Algebraic.ThreeColorAlgebra.Satisfies" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The received word on a mixed plane with one independently shifted coordinate. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.PointLineEndpointConsistency.mixedGrid", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} → [Field F] → ((σ → F) → F) → (σ → F) → PCP.Algebraic.MixedPlaneSampling.MixedSeed F σ → F × F → F", + "type_dependencies": [ + "Field", + "PCP.Algebraic.MixedPlaneSampling.MixedSeed", + "Prod" + ], + "value_dependencies": [ + "Field", + "PCP.Algebraic.MixedPlaneSampling.MixedSeed", + "Prod", + "PCP.Algebraic.MixedPlaneSampling.mixedPlanePoint", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_base._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u} (r : V → V → Prop) (v w : V), (SimpleGraph.fromRel r).Adj v w = (v ≠ w ∧ (r v w ∨ r w v))", + "type_dependencies": [ + "Eq", + "SimpleGraph.Adj", + "SimpleGraph.fromRel", + "And", + "Ne", + "Or" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 107, + "is_class": false, + "kind": "theorem", + "line": 106, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.isLowDegree_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] {m d : ℕ} (p : MvPolynomial (Fin m) 𝔽),\n p.totalDegree ≤ d → PCP.Algebraic.IsLowDegree d fun x => (MvPolynomial.eval x) p", + "type_dependencies": [ + "Field", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.IsLowDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 27, + "is_class": false, + "kind": "theorem", + "line": 27, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.boolColor_ne_two", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), PCP.Reduction.NAEThreeColor.boolColor b ≠ 2", + "type_dependencies": [ + "Bool", + "Ne", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.boolColor", + "Fin.instOfNat", + "Nat.instNeZeroSucc" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 125, + "is_class": false, + "kind": "definition", + "line": 125, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 0 →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The sharp unique-radius form of the fixed-parameter rejection bound. ", + "end_line": 148, + "is_class": false, + "kind": "theorem", + "line": 141, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.rejectionAt_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (f : (σ → F) → F) (t : F),\n 0 < 1 - ↑c / ↑(Fintype.card F) →\n PCP.Algebraic.PointLineTest.rejectionAt c f t ≤\n PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable c f) +\n 2 * PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable c f) /\n (1 - ↑c / ↑(Fintype.card F))", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "Rat", + "Rat.instLT", + "OfNat.ofNat", + "Rat.instOfNat", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.rejectionAt", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineTest.decodedTable", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The composed proof-length polynomial bounds every branch and every random seed. ", + "end_line": 87, + "is_class": false, + "kind": "theorem", + "line": 78, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.canonicalVerifier_readsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) {a b : ℕ} (hr : V.CanonicalRandomness a b) (f : List Bool → List Bool) (p q : Polynomial ℕ)\n (hp : ∀ (x : List Bool), (f x).length ≤ Polynomial.eval x.length p),\n (∀ (y : List Bool), V.ReadsBelow y (Polynomial.eval y.length q)) →\n ∀ (x : List Bool),\n (PCP.Verifier.Reduction.canonicalVerifier V hr f p hp).ReadsBelow x (Polynomial.eval x.length (q.comp p))", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "Polynomial", + "Nat.instSemiring", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "PCP.Verifier.ReadsBelow", + "PCP.Verifier.Reduction.canonicalVerifier", + "Polynomial.comp" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A formal binary polynomial for one output coordinate of the univariate evaluation. ", + "end_line": 113, + "is_class": false, + "kind": "definition", + "line": 109, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.outputCoordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : CommRing F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {t : ℕ} → (F ≃ₗ[ZMod 2] Fin t → ZMod 2) → Polynomial F → Fin t → MvPolynomial (Fin t) (ZMod 2)", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "MvPolynomial" + ], + "value_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.HadamardComposition.mapCoefficients", + "LinearMap.comp", + "Pi.module", + "PCP.Algebraic.HadamardComposition.outputCoordinate._proof_1", + "LinearMap.proj", + "LinearEquiv.toLinearMap", + "PCP.Algebraic.HadamardComposition.fieldPolynomial" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Assemble polynomial coefficients into a bivariate polynomial. ", + "end_line": 69, + "is_class": false, + "kind": "definition", + "line": 67, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.assemble", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : Field F] → {k : ℕ} → (Fin (k + 1) → Polynomial F) → MvPolynomial (Fin 2) F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Finset.sum", + "MvPolynomial", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "RingHom.instFunLike", + "PCP.Algebraic.BerlekampWelchCertificate.inY", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "MvPolynomial.X", + "Fin.instOfNat", + "PCP.Algebraic.BerlekampWelchCertificate.inY._proof_1", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 88, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.symbolicX_assemble", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {k : ℕ} (v : Fin (k + 1) → Polynomial F),\n PCP.Algebraic.BerlekampWelchCertificate.symbolicX (PCP.Algebraic.BerlekampWelchCertificate.assemble v) =\n PCP.Algebraic.BerlekampWelchCertificate.series v", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Polynomial.semiring", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "PCP.Algebraic.BerlekampWelchCertificate.symbolicX", + "PCP.Algebraic.BerlekampWelchCertificate.assemble", + "PCP.Algebraic.BerlekampWelchCertificate.series", + "Polynomial.commRing", + "Field.toCommRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Equal messages give distance zero; distinct ones give distance one half. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 98, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_encode_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ},\n 1 ≤ r →\n ∀ (x y : Fin t → ZMod 2),\n PCP.Algebraic.relativeDistance ⇑(PCP.Algebraic.Hadamard.encode r x) ⇑(PCP.Algebraic.Hadamard.encode r y) =\n if x = y then 0 else 1 / 2", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "ite", + "Fintype.decidablePiFintype", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 124, + "is_class": false, + "kind": "theorem", + "line": 115, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.degreeOf_inY_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (p : Polynomial F),\n MvPolynomial.degreeOf 0 (PCP.Algebraic.BerlekampWelchCertificate.inY p) = 0", + "type_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Nat", + "MvPolynomial.degreeOf", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.BerlekampWelchCertificate.inY" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 125, + "is_class": false, + "kind": "constructor", + "line": 125, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldCode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The weighted corrector uses a number of bit queries linear in `c`. ", + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 81, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (a b : σ → F) (z : Fˣ)\n (v : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) (w : Fin t → ZMod 2)\n (s : PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t),\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ a b z v w s).length ≤ 3 * c + 9", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Small global row and column errors provide `10*d` distinct columns, each\nwith row/column disagreement at most `1/10`. Degree bounds are unnecessary. ", + "end_line": 105, + "is_class": false, + "kind": "theorem", + "line": 92, + "module": "PCP.Algebraic.BivariateColumnSelection", + "name": "PCP.Algebraic.BivariateColumnSelection.exists_good_columns", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (f : F × F → F) (R C : F → Polynomial F)\n {ε : ℚ} {d : ℕ},\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.1 (R z.2)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.2 (C z.1)) ≤ ε →\n ε ≤ 1 / 100 →\n 20 * d ≤ Fintype.card F →\n ∃ a,\n ∀ (i : Fin (10 * d)),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x =>\n Polynomial.eval x (C (a i))) ≤\n 1 / 10", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Prod", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Rat", + "Nat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "Prod.fst", + "Prod.snd", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "instOfNatNat", + "Fintype.card", + "Exists", + "Function.Embedding", + "Fin", + "DFunLike.coe", + "Function.instFunLikeEmbedding" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPTableauGraphLang.program.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) {inst : DecidableEq h.tm.Λ}\n [inst_1 : DecidableEq h.tm.Λ] {inst_2 : DecidableEq h.tm.σ} [inst_3 : DecidableEq h.tm.σ]\n {inst_4 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)}\n [inst_5 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK eK_1 : h.tm.K ≃ Fin k),\n eK = eK_1 →\n ∀ (eA eA_1 : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n eA = eA_1 →\n PCP.Reduction.NPTableauGraphLang.program h hs eK eA = PCP.Reduction.NPTableauGraphLang.program h hs eK_1 eA_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Nat", + "Equiv", + "Fin", + "Eq", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Lang.Prog", + "PCP.Reduction.NPTableauGraphLang.program" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {V : Type u_1} →\n PCP.Reduction.NAEThreeColor.Literal V → {V' : Type u_1} → PCP.Reduction.NAEThreeColor.Literal V' → Sort u", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.casesOn", + "Bool", + "Eq", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 80, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.interpolate_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽] [inst_1 : DecidableEq 𝔽] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n (H : Finset 𝔽) (f : (σ → ↥H) → 𝔽),\n (PCP.Algebraic.GridInterpolation.interpolate H) f = ∑ a, f a • PCP.Algebraic.GridInterpolation.basis H a", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.GridInterpolation.interpolate", + "Finset.sum", + "Finset.univ", + "Pi.instFintype", + "Finset.Subtype.fintype", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "PCP.Algebraic.GridInterpolation.basis" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 97, + "is_class": false, + "kind": "theorem", + "line": 91, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.vanishesOn_of_eq_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (H : Finset R) (p : MvPolynomial σ R)\n (Q : σ → MvPolynomial σ R),\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i → PCP.Algebraic.GridVanishing.VanishesOn H p", + "type_dependencies": [ + "CommRing", + "Fintype", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate", + "PCP.Algebraic.GridVanishing.VanishesOn" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete verifier is determined by its stated physical oracle reads. ", + "end_line": 309, + "is_class": false, + "kind": "theorem", + "line": 300, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.test_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π π' : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n (∀ q ∈ PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s,\n PCP.Algebraic.ThreeColorVerifier.read π q = PCP.Algebraic.ThreeColorVerifier.read π' q) →\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s = PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π' s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorVerifier.queries", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.read", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A prediction at a varying endpoint agrees with an independent full seed\nthrough that endpoint. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 75, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.PointLineEndpointConsistency.fraction_endpoint_disagreement_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ}\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ],\n 0 < d →\n 1000 * d ^ 3 ≤ Fintype.card F →\n ∀ (f : (σ → F) → F) (u : σ → F) (t : F) {ε : ℚ},\n 0 < ε →\n ε ≤ 1 / 100 →\n 6 * ε + 2 * (↑d / ↑(Fintype.card F)) < 1 / 2 →\n (PCP.Algebraic.AffineLineSampling.fraction fun seed =>\n Polynomial.eval t ↑(PCP.Algebraic.PointLineTest.decodedTable d f (u, seed.1)) ≠\n PCP.Algebraic.PointLineTest.prediction (PCP.Algebraic.PointLineTest.decodedTable d f)\n (PCP.Algebraic.PolynomialLine.point u seed.1 t) seed.2) ≤\n 4 *\n (4 * PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable d f) +\n 1 / ↑(Fintype.card F)) /\n ε", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "Rat", + "Rat.instLT", + "Rat.instOfNat", + "Rat.instLE", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "PCP.Algebraic.AffineLineSampling.fraction", + "PCP.Algebraic.MixedPlaneSampling.MixedSeed", + "instFintypeProd", + "Prod", + "Pi.instFintype", + "Ne", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Subtype.val", + "Polynomial", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.decodedTable", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.PointLineTest.prediction", + "PCP.Algebraic.PolynomialLine.point", + "Prod.snd", + "PCP.Algebraic.PointLineTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The grid basis polynomial which is one at `a` and zero at the other grid points. ", + "end_line": 43, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.basis", + "provenance": "lean", + "structural_dependencies": [], + "type": "{𝔽 : Type u_1} →\n {σ : Type u_2} → [inst : Field 𝔽] → [DecidableEq 𝔽] → [Fintype σ] → (H : Finset 𝔽) → (σ → ↥H) → MvPolynomial σ 𝔽", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.prod", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "CommRing.toCommMonoid", + "AddMonoidAlgebra.commRing", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Field.toCommRing", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "DFunLike.coe", + "AlgHom", + "Polynomial", + "CommSemiring.toSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Polynomial.algebraOfAlgebra", + "Algebra.id", + "AddMonoidAlgebra.algebra", + "AlgHom.funLike", + "Polynomial.toMvPolynomial", + "Lagrange.basis", + "id", + "Subtype.val" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → (n m c t : ℕ) → [SizeOf F] → SizeOf (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "SizeOf.mk", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The auxiliary proof gives the honest encoded line at each possible certificate target. ", + "end_line": 137, + "is_class": false, + "kind": "definition", + "line": 134, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [NeZero m] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n MvPolynomial (Fin n ⊕ Fin n) F → PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.honestTable" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A genuine bounded-degree polynomial represents the function on every affine line. ", + "end_line": 29, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.HasLowDegreeLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → {σ : Type u_2} → ℕ → ((σ → F) → F) → Prop", + "type_dependencies": [ + "Field", + "Nat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Exists", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "Polynomial.eval", + "PCP.Algebraic.PolynomialLine.point" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ}, IsScalarTower (ZMod 2) (ZMod 2) (PCP.Algebraic.BinaryPolynomialSpace.Monomials t r → ZMod 2)", + "type_dependencies": [ + "Nat", + "IsScalarTower", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddMonoidWithOne.toAddMonoid", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "Pi.instSMul", + "SemigroupAction.toSMul", + "Monoid.toSemigroup", + "MulAction.toSemigroupAction", + "DistribMulAction.toMulAction", + "AddCommMonoid.toAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : Type u_1) →\n (motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u_2) →\n (x : PCP.Reduction.NAEThreeColor.Literal V) →\n ((a : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.const a)) →\n ((a : V) → (a_1 : Bool) → motive (PCP.Reduction.NAEThreeColor.Literal.var a a_1)) → motive x", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Bool", + "PCP.Reduction.NAEThreeColor.Literal.const", + "PCP.Reduction.NAEThreeColor.Literal.var", + "PCP.Reduction.NAEThreeColor.Literal.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), Function.Injective ⇑(PCP.Algebraic.BinaryMaterializedField.coefficientEquiv (4 * (k + 1))).symm", + "type_dependencies": [ + "Nat", + "Function.Injective", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "ZMod", + "PCP.Algebraic.BinaryMaterializedField.Element", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.BinaryMaterializedField.coefficientEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → Type (max u_3 u_4)", + "type_dependencies": [], + "value_dependencies": [ + "Prod" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (s : PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.queries ρ nodes ζ H s =\n Sum.inl\n (s.1,\n (PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.BinaryZeroOnGridCorrection.check._proof_1) s.2.1) ::\n (List.map (fun q => Sum.inr (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1, q))\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1)\n s.2.2.1.1 s.2.2.1.2.1 s.2.2.1.2.2.1 s.2.1 s.2.2.1.2.2.2) ++\n List.map (fun q => Sum.inr (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1, q))\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)\n s.2.2.2.1 s.2.2.2.2.1 s.2.2.2.2.2.1 s.2.1 s.2.2.2.2.2.2))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "Eq", + "List", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "PCP.Algebraic.BinaryZeroOnGridCorrection.queries", + "List.cons", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check._proof_1", + "Prod.snd", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inr", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Standard constant soundness for every proof oracle. ", + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 53, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.soundAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n ¬(PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.SoundAt x (1 / 2)", + "type_dependencies": [ + "List", + "Bool", + "Not", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Verifier.SoundAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 76, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord_proofOracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool)\n (w : PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x)),\n PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord x (PCP.Algebraic.ThreeColorCanonicalVerifier.proofOracle x w) = w", + "type_dependencies": [ + "List", + "Bool", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder", + "Eq", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofWord", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofOracle" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Embedding a univariate polynomial in one variable does not increase total degree. ", + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.totalDegree_toMvPolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {σ : Type u_2} (p : Polynomial F) (i : σ),\n ((Polynomial.toMvPolynomial i) p).totalDegree ≤ p.natDegree", + "type_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "AlgHom", + "MvPolynomial", + "Polynomial.semiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Polynomial.algebraOfAlgebra", + "Algebra.id", + "AddMonoidAlgebra.algebra", + "AlgHom.funLike", + "Polynomial.toMvPolynomial", + "Polynomial.natDegree" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((val : ℕ) → motive (Sum.inr val)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Two reads replace exactly one primary read, with no changes to the certificate calls. ", + "end_line": 93, + "is_class": false, + "kind": "theorem", + "line": 85, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries_length_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n (PCP.Algebraic.DerivedZeroOnGrid.queries ρ Q hQ nodes ζ H s).length =\n (PCP.Algebraic.BinaryZeroOnGridCorrection.queries ρ nodes ζ H (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)).length +\n 1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Eq", + "List.length", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "PCP.Algebraic.BinaryZeroOnGridCorrection.queries", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Fintype F] [inst_1 : Fintype σ] {inst_2 : DecidableEq σ}\n [inst_3 : DecidableEq σ] {t r : ℕ} (hr : 1 ≤ r)\n (f f_1 : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n f = f_1 →\n ∀ (g g_1 : (σ ⊕ σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n g = g_1 →\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr f g =\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate hr f_1 g_1", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Eq", + "Sum", + "Rat", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Degree-zero table entries have the same value at every parameter. ", + "end_line": 140, + "is_class": false, + "kind": "theorem", + "line": 134, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.eval_degree_zero_table", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (table : PCP.Algebraic.PointLineTest.LineTable F σ 0)\n (uv : (σ → F) × (σ → F)) (t : F), Polynomial.eval t ↑(table uv) = (↑(table uv)).coeff 0", + "type_dependencies": [ + "Field", + "PCP.Algebraic.PointLineTest.LineTable", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Prod", + "Eq", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Subtype.val", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "DFunLike.coe", + "Finsupp", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Finsupp.instFunLike", + "Polynomial.coeff" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 146, + "is_class": false, + "kind": "theorem", + "line": 140, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_isHomogeneous", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n ((PCP.Algebraic.SetMultilinear.encode m c) P).IsHomogeneous c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "MvPolynomial.IsHomogeneous", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The verifier's binary linear coordinates read the stored array coefficients. ", + "end_line": 60, + "is_class": false, + "kind": "definition", + "line": 57, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.coordinates", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → PCP.Algebraic.ThreeColorFields.FieldFamily k ≃ₗ[ZMod 2] Fin (4 * (k + 1)) → ZMod 2", + "type_dependencies": [ + "Nat", + "LinearEquiv", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instField", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instModuleZModOfNatNatElement", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryMaterializedField.coordinates", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 172, + "is_class": false, + "kind": "definition", + "line": 172, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A fixed parameter costs at most rejection plus the Markov bound for lines\noutside any supplied unique-decoding radius. Equality at the radius is allowed. ", + "end_line": 139, + "is_class": false, + "kind": "theorem", + "line": 97, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.rejectionAt_le_add_div", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (f : (σ → F) → F) (t : F) {r : ℚ},\n 0 < r →\n 2 * r ≤ 1 - ↑c / ↑(Fintype.card F) →\n PCP.Algebraic.PointLineTest.rejectionAt c f t ≤\n PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable c f) +\n PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable c f) / r", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Rat", + "LT.lt", + "Rat.instLT", + "OfNat.ofNat", + "Rat.instOfNat", + "LE.le", + "Rat.instLE", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.PointLineTest.rejectionAt", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineTest.decodedTable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex_injective._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", + "type_dependencies": [ + "Fintype", + "Eq", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.univ", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 149, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.character_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] (a : ι → ZMod 2), PCP.Algebraic.BLR.character a 0 = 1", + "type_dependencies": [ + "Fintype", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.character", + "Zero.toOfNat0", + "Pi.instZero", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLowDegreeTest.test.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {c t r : ℕ} (hr : 1 ≤ r)\n (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (a a_1 : Fin (c + 1) → F),\n a = a_1 →\n ∀ (H H_1 : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n H = H_1 →\n ∀ (s s_1 : PCP.Algebraic.BinaryLowDegreeTest.TestRandomness F σ t r),\n s = s_1 →\n PCP.Algebraic.BinaryLowDegreeTest.test hr ρ a H s =\n PCP.Algebraic.BinaryLowDegreeTest.test hr ρ_1 a_1 H_1 s_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLowDegreeTest.TestRandomness", + "Bool", + "PCP.Algebraic.BinaryLowDegreeTest.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Once all columns are recovered, the fraction of differing formal rows is at most\nthe average number of column errors divided by the polynomial separation `n-d`. ", + "end_line": 153, + "is_class": false, + "kind": "theorem", + "line": 125, + "module": "PCP.Algebraic.BivariateAgreementFromRectangle", + "name": "PCP.Algebraic.BivariateAgreementFromRectangle.rowDistance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype I]\n {d : ℕ} (a : I → F),\n Function.Injective a →\n ∀ (C : I → Polynomial F) (R : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n ∀ (P : MvPolynomial (Fin 2) F),\n (∀ (j : Fin 2), MvPolynomial.degreeOf j P ≤ d) →\n (∀ (i : I), PCP.Algebraic.PointLineCrossing.rowPolynomial P (a i) = C i) →\n d < Fintype.card I →\n ∀ {ε : ℚ},\n (∀ (i : I),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x =>\n Polynomial.eval x (C i)) ≤\n ε) →\n PCP.Algebraic.relativeDistance R (PCP.Algebraic.PointLineCrossing.columnPolynomial P) ≤\n ↑(Fintype.card I) * ε / (↑(Fintype.card I) - ↑d)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial.degreeOf", + "Eq", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "LT.lt", + "instLTNat", + "Fintype.card", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Polynomial.eval", + "Polynomial.instDecidableEq", + "PCP.Algebraic.PointLineCrossing.columnPolynomial", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "HSub.hSub", + "instHSub", + "Rat.instSub" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 65, + "is_class": false, + "kind": "theorem", + "line": 65, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.inY_X", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F], PCP.Algebraic.BerlekampWelchCertificate.inY Polynomial.X = MvPolynomial.X 1", + "type_dependencies": [ + "Field", + "Eq", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "DFunLike.coe", + "RingHom", + "Polynomial", + "CommSemiring.toSemiring", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.BerlekampWelchCertificate.inY", + "Polynomial.X", + "MvPolynomial.X", + "Fin.instOfNat", + "Nat.instNeZeroSucc" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Read an indexed query from the two received oracles. ", + "end_line": 95, + "is_class": false, + "kind": "definition", + "line": 91, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t : ℕ} →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n PCP.Algebraic.BinaryLocalCorrection.Query F σ m c t → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.BinaryLocalCorrection.read.match_1", + "Prod", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.inversion._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),\n ∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a", + "type_dependencies": [ + "DivisionSemiring", + "Finset", + "Eq", + "Finset.sum", + "Semiring.toAddCommMonoid", + "DivisionSemiring.toSemiring", + "HDiv.hDiv", + "instHDiv", + "DivInvMonoid.toDiv", + "GroupWithZero.toDivInvMonoid", + "DivisionSemiring.toGroupWithZero" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instFintypeSym.match_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool ⊕ Unit → Sort u_1) →\n (x : Bool ⊕ Unit) → ((a : Bool) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Unit", + "Sum.inl", + "Sum.inr", + "PUnit.unit" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Unit", + "Sum.inl", + "Sum.inr", + "PUnit.unit", + "Sum.casesOn", + "PUnit.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest cubic derived reads produce the requested affine encoding bit. ", + "end_line": 233, + "is_class": false, + "kind": "theorem", + "line": 229, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.answer_cubic_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} [inst_2 : Nontrivial F]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (u : F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (R : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n PCP.Algebraic.HadamardDerivedOracle.answer ρ PCP.Algebraic.HadamardDerivedOracle.cubic ⋯\n (⇑(PCP.Algebraic.Hadamard.encode 3 (ρ u))) L R =\n (PCP.Algebraic.Hadamard.encode 1 (ρ (u ^ 3 - 1))) L", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Nontrivial", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_cubic_le", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The two actual query locations, counted with multiplicity even when they coincide. ", + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : CommRing F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (P : Polynomial F) →\n P.natDegree ≤ r →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r →\n List (PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r)", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "List" + ], + "value_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardDerivedOracle.answer._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "List.cons", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Distrib.toAdd", + "instDistribOfSemiring", + "PCP.Algebraic.HadamardComposition.query", + "List.nil" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "With a homogeneous output label, binary origin error is bounded by binary\nline-comparison error plus half the polynomial root-bound loss. ", + "end_line": 352, + "is_class": false, + "kind": "theorem", + "line": 335, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.binary_origin_error_le_binary_comparison", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : DecidableEq F] {t : ℕ} {σ : Type u_3} [inst_1 : Field F] [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] {D : ℕ} (ρ : F → Fin t → ZMod 2),\n Function.Injective ρ →\n ∀ (T : (σ → F) → Polynomial F),\n (∀ (b : σ → F), (T b).natDegree ≤ D) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n ∀ (a : σ → F),\n (PCP.Algebraic.relativeDistance\n (fun s => (PCP.Algebraic.Hadamard.linearEncode (ρ (Polynomial.eval 0 (T s.1)))) s.2) fun s =>\n (PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2) ≤\n (PCP.Algebraic.relativeDistance\n (fun s => (PCP.Algebraic.Hadamard.linearEncode (ρ (Polynomial.eval (↑s.1.2) (T s.1.1)))) s.2)\n fun s =>\n (PCP.Algebraic.Hadamard.linearEncode\n (ρ ((MvPolynomial.eval (PCP.Algebraic.PolynomialLine.point a s.1.1 ↑s.1.2)) P)))\n s.2) +\n ↑D / ↑(Fintype.card F - 1) / 2", + "type_dependencies": [ + "DecidableEq", + "Nat", + "Field", + "Fintype", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Polynomial.eval", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Prod.fst", + "Prod.snd", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Units", + "Semiring.toMonoid", + "instFintypeUnitsOfDecidableEq", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.fraction_exists_mem_le._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (E : α → Prop) [inst_1 : DecidablePred E],\n (Finset.univ.expect fun x => if E x then 1 else 0) = PCP.Algebraic.AffineLineSampling.fraction E", + "type_dependencies": [ + "Fintype", + "DecidablePred", + "Eq", + "Rat", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "ite", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.AffineLineSampling.fraction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → PCP.Algebraic.ThreeColorVerifier.Query F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.satisfies_iff._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The local corrector uses the same valid-certificate line table as its outer test. ", + "end_line": 75, + "is_class": false, + "kind": "definition", + "line": 73, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validAuxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "Prod.mk", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p_2 m₀_2 mZ_2 : ZMod 2),\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck (some p_2) (some m₀_2) (some mZ_2) =\n some (PCP.Algebraic.BinaryZeroOnGrid.checkBits p_2 m₀_2 mZ_2)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "PCP.Algebraic.BinaryZeroOnGrid.checkBits" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "All finite choices, including the homogeneous label whose answer is requested. ", + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.Sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_3) → Type u_4 → [Monoid F] → ℕ → ℕ → ℕ → Type (max (max u_3 u_4) u_3)", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A degree-sensitive form of Lemma 2.9, retaining the bound before subtraction. ", + "end_line": 131, + "is_class": false, + "kind": "theorem", + "line": 99, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.exists_decomposition", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] [inst_3 : Fintype σ] (H : Finset R)\n (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p →\n ∃ Q,\n (∀ (i : σ), Q i ≠ 0 → (Q i).totalDegree + H.card ≤ p.totalDegree) ∧\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Fintype", + "Finset", + "MvPolynomial", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Exists", + "And", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "MvPolynomial.totalDegree", + "Finset.card", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "PCP.Algebraic.GridVanishing.coordinate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_1.else_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {motive : Bool → Sort u} (t : Bool) (true : motive true) («else» : Nat.hasNotBit 2 t.ctorIdx → motive t)\n (h : Nat.hasNotBit 2 t.ctorIdx), PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_1 t true «else» = «else» h", + "type_dependencies": [ + "Bool", + "Bool.true", + "Nat.hasNotBit", + "Bool.ctorIdx", + "Eq", + "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One explicit cubic field-size constant satisfies the algebraic and counting bounds. ", + "end_line": 50, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.BivariateAgreement", + "name": "PCP.Algebraic.BivariateAgreement.fieldSize_bounds", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d q : ℕ},\n 0 < d →\n 1000 * d ^ 3 ≤ q →\n 2 * ((5 * d + 2) * d) < q ∧ 2 * d < q ∧ (5 * d + 1) * d < q ∧ 10 * (d + 1) * ((5 * d + 1) * d) ≤ q ∧ 20 * d ≤ q", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "And", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 24, + "is_class": false, + "kind": "theorem", + "line": 24, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.GoodNodes.ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ → c + 1 ≠ 0 → ζ ≠ 0", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Ne", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.queries_length", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (u v : σ → F),\n (PCP.Algebraic.StandardLocalCorrection.queries c ζ u v).length = c + 1", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "List.length", + "PCP.Algebraic.StandardLocalCorrection.queries", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Acceptance probability is exactly `1` precisely when *every* random string accepts. This is\nthe bridge between the probabilistic statement of perfect completeness and the finite, decidable\ncondition used by the NP witness checker below. ", + "end_line": 188, + "is_class": false, + "kind": "theorem", + "line": 169, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_eq_one_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = 1 ↔ ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval π = true", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Iff", + "Eq", + "Rat", + "PCP.Verifier.accProb", + "OfNat.ofNat", + "Rat.instOfNat", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "theorem", + "line": 92, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.pair_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] [inst_4 : DecidableEq F] [inst_5 : Fintype V] (a w : I → F),\n (∀ (i : I), a i ≠ 0) →\n ∀ (f : V → F) (x : V),\n (PCP.Algebraic.relativeDistance (fun s => PCP.Algebraic.WeightedConstraint.predict a w f x s.1) fun s =>\n PCP.Algebraic.WeightedConstraint.predict a w f x s.2) ≤\n 2 * ↑(Fintype.card I) * PCP.Algebraic.WeightedConstraint.rejectionRate a w f", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "PCP.Algebraic.WeightedConstraint.predict", + "Prod.fst", + "Prod.snd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.WeightedConstraint.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.correct.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (T : (σ → F) → Polynomial F) (f : (σ → F) → F) (a b : σ → F) (z : Fˣ),\n PCP.Algebraic.LineTableLocalCorrection.correct T f a b z =\n if Polynomial.eval (↑z) (T b) = f (PCP.Algebraic.PolynomialLine.point a b ↑z) then some (Polynomial.eval 0 (T b))\n else none", + "type_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Units", + "Semiring.toMonoid", + "Eq", + "Option", + "PCP.Algebraic.LineTableLocalCorrection.correct", + "ite", + "Polynomial.eval", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "Classical.propDecidable", + "Option.some", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.coeff_series", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommRing R] {k : ℕ} (v : Fin (k + 1) → R) (j : Fin (k + 1)),\n (PCP.Algebraic.BerlekampWelchCertificate.series v).coeff ↑j = v j", + "type_dependencies": [ + "CommRing", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "DFunLike.coe", + "Finsupp", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finsupp.instFunLike", + "Polynomial.coeff", + "PCP.Algebraic.BerlekampWelchCertificate.series", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One-hot truth tables use only bounded quantification over finite types. ", + "end_line": 65, + "is_class": false, + "kind": "definition", + "line": 60, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.relation", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {a d : ℕ} →\n (C → (Fin d → Fin a) → Bool) →\n PCP.Reduction.FiniteDomainConstraints.Constraint V C →\n PCP.Reduction.FiniteBooleanConstraints.Pattern (PCP.Reduction.FiniteDomainConstraints.arity a d) → Bool", + "type_dependencies": [ + "Nat", + "Fin", + "Bool", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "PCP.Reduction.FiniteDomainConstraints.arity" + ], + "value_dependencies": [ + "Nat", + "Fin", + "Bool", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteBooleanConstraints.Pattern", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.relation.match_1", + "Decidable.decide", + "Exists", + "And", + "Eq", + "Bool.true", + "PCP.Reduction.FiniteDomainConstraints.inputSlot", + "instDecidableEqFin", + "Fintype.decidableExistsFintype", + "instDecidableAnd", + "instDecidableEqBool", + "Nat.decidableForallFin", + "Pi.instFintype", + "Fin.fintype", + "PCP.Reduction.FiniteDomainConstraints.firstSlot", + "Nat.decidableExistsFin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The vertex constraint applied to the coloring polynomial. ", + "end_line": 29, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [inst : Field F] → MvPolynomial σ F → MvPolynomial σ F", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "AddMonoidAlgebra.semiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidAlgebra.zero", + "Finsupp.instZero" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False", + "type_dependencies": [ + "MonoidWithZero", + "IsReduced", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass", + "NPow.toPow", + "Monoid.toNPow", + "MonoidWithZero.toMonoid", + "Nat", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Eq", + "HPow.hPow", + "instHPow", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.test_of_not_valid", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (s : PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t),\n ¬PCP.Algebraic.ThreeColorFullFieldSampling.Valid s →\n PCP.Algebraic.ThreeColorFullFieldSampling.test ρ nodes ζ H G π s = true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "Not", + "PCP.Algebraic.ThreeColorFullFieldSampling.Valid", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorFullFieldSampling.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The nearby function is represented by an actual formal polynomial of total degree zero. ", + "end_line": 164, + "is_class": false, + "kind": "theorem", + "line": 159, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.exists_close_degree_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ 0),\n ∃ P,\n P.totalDegree ≤ 0 ∧\n (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤\n 2 * PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.PointLineTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {t t' : PCP.Verifier} → t = t' → PCP.Verifier.noConfusionType P t t'", + "type_dependencies": [ + "PCP.Verifier", + "Eq", + "PCP.Verifier.noConfusionType" + ], + "value_dependencies": [ + "PCP.Verifier", + "Eq", + "Eq.ndrec", + "PCP.Verifier.noConfusionType", + "PCP.Verifier.casesOn", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "HEq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Number of actual finite-alphabet variables, including the fixed-size prefix variable. ", + "end_line": 309, + "is_class": false, + "kind": "definition", + "line": 307, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.variableCount", + "provenance": "lean", + "structural_dependencies": [], + "type": "Turing.FinTM2 → ℕ → ℕ → ℕ", + "type_dependencies": [ + "Turing.FinTM2", + "Nat" + ], + "value_dependencies": [ + "Turing.FinTM2", + "Nat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Turing.FinTM2.K", + "Turing.FinTM2.kFin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The deterministic crossing argument. `GR` and `GC` are the row and column\npolynomials of one comparison grid; their compatibility is explicit. Both actual\napproximants at the crossing are nearest to the received slices. ", + "end_line": 155, + "is_class": false, + "kind": "theorem", + "line": 127, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.crossing_eq_of_nearby_rows", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (f : F × F → F)\n (R C GR GC : F → Polynomial F),\n (∀ (x : F), (R x).natDegree ≤ d) →\n (∀ (y : F), (C y).natDegree ≤ d) →\n (∀ (x : F), (GR x).natDegree ≤ d) →\n (∀ (y : F), (GC y).natDegree ≤ d) →\n (∀ (x y : F), Polynomial.eval y (GR x) = Polynomial.eval x (GC y)) →\n ∀ (x₀ y₀ : F) {η ε : ℚ},\n (PCP.Algebraic.relativeDistance (fun z => Polynomial.eval z.2 (R z.1)) fun z =>\n Polynomial.eval z.2 (GR z.1)) ≤\n η →\n (PCP.Algebraic.relativeDistance (fun z => Polynomial.eval z.2 (C z.1)) fun z =>\n Polynomial.eval z.2 (GC z.1)) ≤\n η →\n (PCP.Algebraic.relativeDistance (fun y => f (x₀, y)) fun y => Polynomial.eval x₀ (C y)) ≤ ε →\n (PCP.Algebraic.relativeDistance (fun x => f (x, y₀)) fun x => Polynomial.eval y₀ (R x)) ≤ ε →\n ((PCP.Algebraic.relativeDistance (fun y => f (x₀, y)) fun x => Polynomial.eval x (R x₀)) ≤\n PCP.Algebraic.relativeDistance (fun y => f (x₀, y)) fun x => Polynomial.eval x (GR x₀)) →\n ((PCP.Algebraic.relativeDistance (fun x => f (x, y₀)) fun x => Polynomial.eval x (C y₀)) ≤\n PCP.Algebraic.relativeDistance (fun x => f (x, y₀)) fun x => Polynomial.eval x (GC y₀)) →\n 2 * (ε + η + ↑d / ↑(Fintype.card F)) < 1 - ↑d / ↑(Fintype.card F) →\n Polynomial.eval y₀ (R x₀) = Polynomial.eval x₀ (C y₀)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Prod", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "Polynomial.eval", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.snd", + "Prod.fst", + "Prod.mk", + "LT.lt", + "Rat.instLT", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "HSub.hSub", + "instHSub", + "Rat.instSub" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same canonical verifier repeated a fixed number of times on the same proof. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier", + "type_dependencies": [ + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.Verifier.repeat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The fixed verifier's machine certificate suffices for the unchanged final PCP statement. ", + "end_line": 69, + "is_class": false, + "kind": "theorem", + "line": 53, + "module": "PCP.Algebraic.ThreeColorFinalAssembly", + "name": "PCP.Algebraic.ThreeColorFinalAssembly.of_runtime", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.PolyTimeAlg PCP.Algebraic.ComputableThreeColorAmplifiedQueryAlgorithm.algorithm →\n ∀ (L : PCP.Language),\n PCP.InNP PCP.Machine.PolyTimeRel L →\n ∃ V alg a b q p,\n PCP.Machine.PolyTimeAlg alg ∧\n V.ImplementedBy alg ∧\n V.queries = q ∧\n V.CanonicalRandomness a b ∧\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) ∧\n (∀ (x : List Bool), L x → V.CompleteAt x) ∧ ∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)", + "type_dependencies": [ + "PCP.Machine.PolyTimeAlg", + "PCP.Algebraic.ComputableThreeColorAmplifiedQueryAlgorithm.algorithm", + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "And", + "PCP.Verifier.ImplementedBy", + "Eq", + "PCP.Verifier.queries", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 94, + "is_class": false, + "kind": "definition", + "line": 92, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.literalVertex", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → {C : Type u_2} → PCP.Reduction.NAEThreeColor.Literal V → PCP.Reduction.NAEThreeColor.Vertex V C", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Vertex" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_5", + "PCP.Reduction.NAEThreeColor.Vertex", + "Bool", + "PCP.Reduction.NAEThreeColor.base", + "PCP.Reduction.NAEThreeColor.boolColor", + "PCP.Reduction.NAEThreeColor.variableVertex" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (c k k_1 : ℕ),\n k = k_1 → PCP.Algebraic.SetMultilinear.digitExponents m c k = PCP.Algebraic.SetMultilinear.digitExponents m c k_1", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitExponents" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (accept accept_1 : Bool), (PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1) = (accept = accept_1)", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "PCP.QueryTree", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ),\n PCP.Algebraic.GridVanishing.coordinate H i = ∏ a ∈ H, (MvPolynomial.X i - MvPolynomial.C a)", + "type_dependencies": [ + "CommRing", + "Finset", + "Eq", + "MvPolynomial", + "CommRing.toCommSemiring", + "PCP.Algebraic.GridVanishing.coordinate", + "Finset.prod", + "CommRing.toCommMonoid", + "AddMonoidAlgebra.commRing", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.rowErrors.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] {inst_1 : DecidableEq F} [inst_2 : DecidableEq F] [inst_3 : Fintype I]\n (a a_1 : I → F),\n a = a_1 →\n ∀ (C C_1 : I → Polynomial F),\n C = C_1 →\n ∀ (R R_1 : F → Polynomial F),\n R = R_1 →\n ∀ (y y_1 : F),\n y = y_1 →\n PCP.Algebraic.BivariateCleanRectangle.rowErrors a C R y =\n PCP.Algebraic.BivariateCleanRectangle.rowErrors a_1 C_1 R_1 y_1", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Nat", + "PCP.Algebraic.BivariateCleanRectangle.rowErrors" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instNonemptyTestRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ}, Nonempty (PCP.Algebraic.Hadamard.TestRandomness t r)", + "type_dependencies": [ + "Nat", + "Nonempty", + "PCP.Algebraic.Hadamard.TestRandomness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Both directions of the affine-line characterization for arbitrary finite coordinates. ", + "end_line": 190, + "is_class": false, + "kind": "theorem", + "line": 183, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.hasLowDegreeLines_iff_exists_polynomial_finite", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {σ : Type u_2} [Finite σ] {d : ℕ} (f : (σ → F) → F),\n 2 * d < Fintype.card F →\n (PCP.Algebraic.PolynomialLine.HasLowDegreeLines d f ↔\n ∃ P, P.totalDegree ≤ d ∧ ∀ (x : σ → F), (MvPolynomial.eval x) P = f x)", + "type_dependencies": [ + "Field", + "Fintype", + "Finite", + "Nat", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Iff", + "PCP.Algebraic.PolynomialLine.HasLowDegreeLines", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 71, + "is_class": false, + "kind": "theorem", + "line": 66, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.totalDegree_coordinatePolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n (PCP.Algebraic.HadamardComposition.coordinatePolynomial ρ).totalDegree ≤ 1", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Reduction.NAEThreeColor.triangleWitness true true false = ![0, 2, 1]", + "type_dependencies": [ + "Eq", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.triangleWitness", + "Bool.true", + "Bool.false", + "Matrix.vecCons", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.totalDegree_properPolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (E Q : MvPolynomial σ F),\n (PCP.Algebraic.ThreeColorGrid.properPolynomial E Q).totalDegree ≤ E.totalDegree + 3 * Q.totalDegree", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangle_iff._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q)", + "type_dependencies": [ + "Eq", + "Not", + "Or", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 83, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_zero_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (Q : σ → MvPolynomial σ R),\n (PCP.Algebraic.GridVanishing.substitute fun x => 0) (PCP.Algebraic.GridVanishing.certificate Q) = 0", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "PCP.Algebraic.GridVanishing.certificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 83, + "is_class": false, + "kind": "theorem", + "line": 73, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.test_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π π' : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (s : PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t),\n (∀ q ∈ PCP.Algebraic.ThreeColorFullFieldSampling.queries ρ nodes ζ H G s,\n PCP.Algebraic.ThreeColorVerifier.read π q = PCP.Algebraic.ThreeColorVerifier.read π' q) →\n PCP.Algebraic.ThreeColorFullFieldSampling.test ρ nodes ζ H G π s =\n PCP.Algebraic.ThreeColorFullFieldSampling.test ρ nodes ζ H G π' s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorFullFieldSampling.queries", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.read", + "Bool", + "PCP.Algebraic.ThreeColorFullFieldSampling.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (x : Fin n → F), PCP.Algebraic.HadamardDerivedOracle.cubic.natDegree ≤ 3", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 83, + "is_class": false, + "kind": "theorem", + "line": 80, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.averageRejectionRate_le_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {t r : ℕ} [inst : Fintype ι] (hr : 1 ≤ r)\n (H : ι → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.averageRejectionRate hr H ≤ 1", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Rat", + "Rat.instLE", + "PCP.Algebraic.Hadamard.averageRejectionRate", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.test._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V],\n NeZero\n (4 *\n (PCP.Algebraic.ThreeColorParameters.fieldIndex\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)) +\n 1))", + "type_dependencies": [ + "Fintype", + "NeZero", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorParameters.fieldIndex", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t)\n (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H p M A s =\n PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit ρ nodes ζ H M A (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)\n (PCP.Algebraic.HadamardDerivedOracle.answer ρ (Q s.1) ⋯ (p s.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.DerivedZeroOnGrid.check._proof_2) s.2.1.1) s.2.2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "Field.toCommRing", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 74, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_prod", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α × β → ℚ),\n (PCP.Algebraic.BLR.average fun x => PCP.Algebraic.BLR.average fun y => f (x, y)) = PCP.Algebraic.BLR.average f", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "Prod.mk", + "instFintypeProd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.correct.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (c : ℕ) (ζ : F)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (H : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (u v : σ → F) (w : Fin t → ZMod 2),\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ H u v w =\n ∑ i,\n H (PCP.Algebraic.PolynomialLine.point u v (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i))\n ((PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_2)\n ((PCP.Algebraic.HadamardWeights.scaleLabel ρ (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i)) w))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Eq", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "Finset.sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset.univ", + "Fin.fintype", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_2", + "PCP.Algebraic.HadamardWeights.scaleLabel", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (4 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 213, + "is_class": false, + "kind": "theorem", + "line": 210, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_colorQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.colorQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.color π.colorLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.colorQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep._unsafe_rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree.ofStep.match_3", + "PCP.QueryTree", + "PCP.QueryTree.ofStep.match_1", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.leaf", + "Bool.false", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.QueryTree.query", + "PCP.QueryTree.ofStep._unsafe_rec", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "List.nil", + "Bool.true" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 222, + "is_class": false, + "kind": "theorem", + "line": 221, + "module": "PCP.Verifier.Definition", + "name": "PCP.length_witness_of_oracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (π : PCP.ProofOracle) (N : ℕ), (List.map π (List.range N)).length = N", + "type_dependencies": [ + "PCP.ProofOracle", + "Nat", + "Eq", + "List.length", + "Bool", + "List.map", + "List.range" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 34, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.PointLineEndpointConsistency.crossing_errors_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ} (f : (σ → F) → F)\n (u : σ → F) (seed : PCP.Algebraic.MixedPlaneSampling.MixedSeed F σ) (t : F),\n PCP.Algebraic.ProbabilisticCrossing.errors d (PCP.Algebraic.PointLineEndpointConsistency.mixedGrid f u seed) t\n seed.2.2 =\n ![PCP.Algebraic.MixedPlaneSampling.mixedRowError f (PCP.Algebraic.PointLineTest.decodedTable d f) u seed,\n PCP.Algebraic.MixedPlaneSampling.mixedColumnError f (PCP.Algebraic.PointLineTest.decodedTable d f) u seed,\n PCP.Algebraic.MixedPlaneSampling.mixedLocalRowError f (PCP.Algebraic.PointLineTest.decodedTable d f) u t seed,\n PCP.Algebraic.MixedPlaneSampling.mixedLocalColumnError f (PCP.Algebraic.PointLineTest.decodedTable d f) u seed]", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.MixedPlaneSampling.MixedSeed", + "Eq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Rat", + "PCP.Algebraic.ProbabilisticCrossing.errors", + "PCP.Algebraic.PointLineEndpointConsistency.mixedGrid", + "Prod.snd", + "Prod", + "Matrix.vecCons", + "Nat.succ", + "PCP.Algebraic.MixedPlaneSampling.mixedRowError", + "PCP.Algebraic.PointLineTest.decodedTable", + "PCP.Algebraic.MixedPlaneSampling.mixedColumnError", + "PCP.Algebraic.MixedPlaneSampling.mixedLocalRowError", + "PCP.Algebraic.MixedPlaneSampling.mixedLocalColumnError", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {t t' : PCP.CostModel} → t = t' → PCP.CostModel.noConfusionType P t t'", + "type_dependencies": [ + "PCP.CostModel", + "Eq", + "PCP.CostModel.noConfusionType" + ], + "value_dependencies": [ + "PCP.CostModel", + "Eq", + "Eq.ndrec", + "PCP.CostModel.noConfusionType", + "PCP.CostModel.casesOn", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 119, + "is_class": false, + "kind": "theorem", + "line": 111, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.retention_ge_sixteenth", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {q : ℕ}, 2 ≤ q → 1 / 16 ≤ PCP.Algebraic.ThreeColorFullFieldSampling.retention q", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Rat", + "Rat.instLE", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorFullFieldSampling.retention" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness.eq_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x x_1 x_2 : Bool),\n (x = false → x_1 = true → False) →\n (x = false → x_1 = false → x_2 = true → False) →\n (x = true → x_1 = true → x_2 = false → False) → PCP.Reduction.NAEThreeColor.triangleWitness x x_1 x_2 = ![0, 1, 2]", + "type_dependencies": [ + "Bool", + "Eq", + "Bool.false", + "Bool.true", + "False", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.triangleWitness", + "Matrix.vecCons", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (i j : Fin 3),\n PCP.Reduction.NAEThreeColor.direct Q (Sum.inl i) (Sum.inl j) = (i ≠ j)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Eq", + "PCP.Reduction.NAEThreeColor.direct", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Ne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Encoded input length for a witness of maximum permitted length. ", + "end_line": 54, + "is_class": false, + "kind": "definition", + "line": 53, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.inputPoly", + "provenance": "lean", + "structural_dependencies": [], + "type": "Polynomial ℕ → Polynomial ℕ", + "type_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "Polynomial", + "Nat", + "Nat.instSemiring", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "Polynomial.X", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 31, + "is_class": false, + "kind": "theorem", + "line": 29, + "module": "PCP.Algebraic.HadamardCorrection", + "name": "PCP.Algebraic.Hadamard.selfCorrect_addHom", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {W : Type u_2} [inst : AddCommGroup V] [inst_1 : AddCommGroup W] (E : V →+ W) (P R : V),\n PCP.Algebraic.Hadamard.selfCorrect (⇑E) P R = E P", + "type_dependencies": [ + "AddCommGroup", + "AddMonoidHom", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "Eq", + "PCP.Algebraic.Hadamard.selfCorrect", + "DFunLike.coe", + "AddMonoidHom.instFunLike" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (i i_1 : Fin t),\n i = i_1 →\n ∀ (a a_1 : PCP.Algebraic.BinaryPolynomialSpace.Monomials t r),\n a = a_1 →\n PCP.Algebraic.BinaryPolynomialSpace.variableCoeff hr i a =\n PCP.Algebraic.BinaryPolynomialSpace.variableCoeff hr i_1 a_1", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "Eq", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "PCP.Algebraic.BinaryPolynomialSpace.variableCoeff" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (2 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The formerly open point-versus-line proposition, now proved in every dimension. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 79, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.pointLineSoundness_largeField", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (m c : ℕ),\n PCP.Algebraic.PointLineConstants.fieldFactor * c ^ 3 ≤ Fintype.card F →\n PCP.Algebraic.PointLineSoundness F m c PCP.Algebraic.PointLineConstants.smallError", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", "PCP.Algebraic.PointLineSoundness", - "PCP.Algebraic.PolynomialDistance", - "PCP.Algebraic.PolynomialLineCharacterization", - "PCP.Algebraic.RuledSurfaceRigidity", - "PCP.Algebraic.SetMultilinear", - "PCP.Algebraic.StandardLocalCorrection", - "PCP.Algebraic.ThreeColorAlgebra", - "PCP.Algebraic.ThreeColorAmplifiedVerifier", - "PCP.Algebraic.ThreeColorBinaryVerifier", - "PCP.Algebraic.ThreeColorCanonicalVerifier", - "PCP.Algebraic.ThreeColorFields", - "PCP.Algebraic.ThreeColorFinalAssembly", - "PCP.Algebraic.ThreeColorFullFieldSampling", - "PCP.Algebraic.ThreeColorGrid", - "PCP.Algebraic.ThreeColorParameterChoice", - "PCP.Algebraic.ThreeColorVerifier", - "PCP.Algebraic.ThreeColorVerifierCompleteness", - "PCP.Algebraic.ThreeColorVerifierSoundness", - "PCP.Algebraic.VanishingCertificate", - "PCP.Algebraic.WeightedConstraintSoundness", - "PCP.Complexity.CostModel", - "PCP.Complexity.Machine", - "PCP.Complexity.NP", - "PCP.Complexity.NPTableau", - "PCP.Complexity.ReferenceNPConverse", - "PCP.Complexity.TableauCells", - "PCP.Complexity.ThreeColorRuntime", - "PCP.Reduction.FiniteDomainConstraints", - "PCP.Reduction.NAEThreeColor", - "PCP.Reduction.NPThreeColorRuntime", - "PCP.ReverseConcrete", - "PCP.Theorem", - "PCP.Verifier.Definition", - "PCP.Verifier.ReductionResources" - ], - "lean_version": "4.35.0-rc2", - "provenance": { - "kind": "source-read", - "text": "The reading-guide interface retains extracted records from matching pinned source. The forward theorem retains statement compilation. Other selected declarations are source excerpts. Proof dependencies and axiom reports depend on the record's provenance." - }, - "declarations": [ - { - "axioms": [], - "doc": null, - "end_line": 33, - "is_class": false, - "kind": "theorem", - "line": 25, - "module": "PCP.Theorem", - "name": "PCP.np_subset_pcp", - "provenance": "statement-compiled", - "structural_dependencies": [], - "type": "theorem np_subset_pcp (L : Language) (hL : InNP Machine.PolyTimeRel L) :\n ∃ (V : Verifier) (alg : VerifierAlg) (a b q : ℕ) (p : Polynomial ℕ),\n Machine.PolyTimeAlg alg ∧\n V.ImplementedBy alg ∧\n V.queries = q ∧\n V.CanonicalRandomness a b ∧\n (∀ x : List Bool, V.ReadsBelow x (p.eval x.length)) ∧\n (∀ x : List Bool, L x → V.CompleteAt x) ∧\n (∀ x : List Bool, ¬ L x → V.SoundAt x (1 / 2))", - "type_dependencies": [ - "And", - "Bool", - "Eq", - "Exists", - "HDiv.hDiv", - "List", - "List.length", - "Nat", - "Nat.instSemiring", - "Not", - "OfNat.ofNat", - "PCP.InNP", - "PCP.Language", - "PCP.Machine.PolyTimeAlg", - "PCP.Machine.PolyTimeRel", - "PCP.Verifier", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.CompleteAt", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.ReadsBelow", - "PCP.Verifier.SoundAt", - "PCP.Verifier.queries", - "PCP.VerifierAlg", - "Polynomial", - "Polynomial.eval", - "Rat", - "Rat.instDiv", - "Rat.instOfNat", - "instHDiv" - ], - "value_dependencies": [] - }, - { - "name": "PCP.Algebraic.ThreeColorFinalAssembly.of_runtime", - "module": "PCP.Algebraic.ThreeColorFinalAssembly", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem of_runtime\n (hruntime : Machine.PolyTimeAlg ComputableThreeColorAmplifiedQueryAlgorithm.algorithm)\n (L : Language) (hL : InNP Machine.PolyTimeRel L) :\n ∃ (V : Verifier) (alg : VerifierAlg) (a b q : ℕ) (p : Polynomial ℕ),\n Machine.PolyTimeAlg alg ∧\n V.ImplementedBy alg ∧\n V.queries = q ∧\n V.CanonicalRandomness a b ∧\n (∀ x : List Bool, V.ReadsBelow x (p.eval x.length)) ∧\n (∀ x : List Bool, L x → V.CompleteAt x) ∧\n (∀ x : List Bool, ¬ L x → V.SoundAt x (1 / 2))\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 54, - "end_line": 69, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.eval_distance_ge", - "module": "PCP.Algebraic.PolynomialDistance", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem eval_distance_ge (p q : MvPolynomial (Fin m) 𝔽)\n (hp : p.totalDegree ≤ d) (hq : q.totalDegree ≤ d) (hne : p ≠ q) :\n 1 - (d : ℚ) / Fintype.card 𝔽 ≤\n relativeDistance (fun x => eval x p) (fun x => eval x q)", - "line": 49, - "end_line": 55, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GridInterpolation.existsUnique_extension", - "module": "PCP.Algebraic.GridInterpolation", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem existsUnique_extension {m : ℕ} (H : Finset 𝔽) (hH : H.Nonempty)\n (f : (Fin m → H) → 𝔽) :\n ∃! p : MvPolynomial (Fin m) 𝔽, (∀ i, p.degreeOf i ≤ H.card - 1) ∧\n ∀ a : Fin m → H, eval (fun i => (a i : 𝔽)) p = f a", - "line": 170, - "end_line": 183, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_decomposition", - "module": "PCP.Algebraic.GridVanishing", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem vanishesOn_iff_exists_decomposition (H : Finset R)\n (p : MvPolynomial σ R) :\n VanishesOn H p ↔ ∃ Q : σ → MvPolynomial σ R,\n (∀ i, (Q i).totalDegree ≤ p.totalDegree - H.card) ∧\n p = ∑ i, Q i * coordinate H i\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {R σ : Type*} [CommRing R]\nvariable [IsDomain R]\nvariable [Finite σ]\nvariable [Fintype σ]", - "line": 134, - "end_line": 148, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_close", - "module": "PCP.Algebraic.GeneratorLowDegreeTest", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_close (hq : 2 * c < Fintype.card F)\n (hζ : IsPrimitiveRoot ζ (Fintype.card F - 1)) (f : (σ → F) → F)\n {δ : ℚ} (hrej : rejectionRate c ζ f ≤ δ) (hδ : δ < 1 / (2 * (c + 2 : ℚ) ^ 2)) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ c ∧\n relativeDistance f (fun x => MvPolynomial.eval x P) ≤ 2 * δ\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] {c : ℕ}\nvariable [Fintype F] {ζ : F}\nvariable [Fintype F] {ζ : F}\nvariable [DecidableEq F] [Fintype σ] [DecidableEq σ]", - "line": 274, - "end_line": 292, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.StandardLocalCorrection.failure_le", - "module": "PCP.Algebraic.StandardLocalCorrection", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem failure_le (hζ : GoodNodes c ζ)\n (P : MvPolynomial σ F) (hP : P.totalDegree ≤ c) (f : (σ → F) → F) (u : σ → F) :\n relativeDistance (correct c ζ f u) (fun _ => MvPolynomial.eval u P) ≤\n (c + 1 : ℕ) * relativeDistance f (fun x => MvPolynomial.eval x P)", - "line": 63, - "end_line": 87, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.LineTableLocalCorrection.correct_wrong_le", - "module": "PCP.Algebraic.LineTableLocalCorrection", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem correct_wrong_le (T : (σ → F) → Polynomial F)\n (hT : ∀ b, (T b).natDegree ≤ D) (P : MvPolynomial σ F) (hP : P.totalDegree ≤ D)\n (a : σ → F) (f : (σ → F) → F) :\n fraction (fun s : (σ → F) × Fˣ => correct T f a s.1 s.2 ≠ none ∧\n correct T f a s.1 s.2 ≠ some (MvPolynomial.eval a P)) ≤\n relativeDistance f (fun x => MvPolynomial.eval x P) +\n (D : ℚ) / (Fintype.card F - 1 : ℕ)", - "line": 249, - "end_line": 265, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BivariateAgreement.exists_polynomial_of_row_column_agreement", - "module": "PCP.Algebraic.BivariateAgreement", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_polynomial_of_row_column_agreement (hd : 0 < d)\n (hq : 1000 * d ^ 3 ≤ Fintype.card F)\n (f : F × F → F) (R C : F → Polynomial F)\n (hR : ∀ y, (R y).natDegree ≤ d) (hC : ∀ x, (C x).natDegree ≤ d)\n {ε : ℚ} (hrows : relativeDistance f (fun z => (R z.2).eval z.1) ≤ ε)\n (hcols : relativeDistance f (fun z => (C z.1).eval z.2) ≤ ε)\n (hε : ε ≤ 1 / 100) :\n ∃ P : MvPolynomial (Fin 2) F, (∀ j, P.degreeOf j ≤ d) ∧\n relativeDistance f (fun z => MvPolynomial.eval ![z.1, z.2] P) ≤ 4 * ε\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F : Type*} [Field F] [Fintype F] [DecidableEq F] {d : ℕ}", - "line": 141, - "end_line": 165, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.PointLineTest.exists_close_of_small_rejection", - "module": "PCP.Algebraic.PointLineSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_close_of_small_rejection\n (hq : fieldFactor * d ^ 3 ≤ Fintype.card F) (f : (σ → F) → F)\n (table : LineTable F σ d) (hδ : rejectionRate f table ≤ smallError) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ d ∧\n relativeDistance f (fun x => MvPolynomial.eval x P) ≤ 2 * rejectionRate f table\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Fintype F] [DecidableEq F]\nvariable [Fintype σ] [DecidableEq σ] {d : ℕ}", - "line": 58, - "end_line": 69, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.SetMultilinear.eval_encode", - "module": "PCP.Algebraic.SetMultilinear", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem eval_encode (P : Polynomial R) (hP : P.natDegree < m ^ c) (x : R) :\n MvPolynomial.eval (evaluationPoint m c x) (encode m c P) = P.eval x\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {R : Type*} [CommSemiring R]\nvariable (m : ℕ) [NeZero m] (c : ℕ)", - "line": 101, - "end_line": 107, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.Hadamard.relativeDistance_encodeFunction_map", - "module": "PCP.Algebraic.Hadamard", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem relativeDistance_encodeFunction_map {ι α : Type*} [Fintype ι] [DecidableEq α]\n (ρ : α → Fin t → ZMod 2) (hρ : Function.Injective ρ) (hr : 1 ≤ r) (f g : ι → α) :\n relativeDistance (encodeFunction r (fun i => ρ (f i)))\n (encodeFunction r (fun i => ρ (g i))) = (1 : ℚ) / 2 * relativeDistance f g", - "line": 119, - "end_line": 123, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.HadamardComposition.encode_query", - "module": "PCP.Algebraic.HadamardComposition", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem encode_query\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2)) (P : Polynomial F)\n (L : Coefficients t 1) (hP : P.natDegree ≤ r) (u : F) :\n Hadamard.encode r (ρ u) (query ρ P L hP) =\n Hadamard.encode 1 (ρ (P.eval u)) L", - "line": 169, - "end_line": 174, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BLR.exists_linearMap_distance_le_of_rejection_le", - "module": "PCP.Algebraic.BLR", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_linearMap_distance_le_of_rejection_le (H : (ι → ZMod 2) → ZMod 2)\n {ε : ℚ} (hε : rejectionProbability H ≤ ε) :\n ∃ L : (ι → ZMod 2) →ₗ[ZMod 2] ZMod 2, relativeDistance H L ≤ ε\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {ι : Type*} [Fintype ι]\nvariable [DecidableEq ι]", - "line": 321, - "end_line": 325, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.Hadamard.test_soundness", - "module": "PCP.Algebraic.HadamardSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem test_soundness (hr : 1 ≤ r) (H : Coefficients t r → ZMod 2)\n {δ : ℚ} (hδ : δ < (1 : ℚ) / 28) (hH : testRejectionRate hr H ≤ δ) :\n ∃ x : Fin t → ZMod 2,\n relativeDistance H (encode r x) ≤ δ ∧\n relativeDistance (fun p : Coefficients t 1 => H (embed hr p)) (encode 1 x) ≤\n 3 * δ\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {t r : ℕ}", - "line": 29, - "end_line": 61, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryLocalRowDecoding.exists_polynomial_distance_le", - "module": "PCP.Algebraic.BinaryLocalRowDecoding", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_polynomial_distance_le\n (hq : 2 * c < Fintype.card F)\n (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (a : Fin (c + 1) → F) (ha : GeneratorLowDegreeTest.IsGeneratorNodes a)\n (H : (σ → F) → Coefficients t r → ZMod 2) :\n ∃ Q : MvPolynomial σ F, Q.totalDegree ≤ c ∧\n relativeDistance (fun p : (σ → F) × Coefficients t r => H p.1 p.2)\n (encodeFunction r (fun x => ρ (MvPolynomial.eval x Q))) ≤\n decodingConstant c * rejectionRate hr ρ a H ∧\n BinaryLagrangeConstraint.homogeneousDistance hr H\n (fun x => encode r (ρ (MvPolynomial.eval x Q))) ≤\n decodingConstant c * rejectionRate hr ρ a H\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Algebra (ZMod 2) F]\nvariable [Fintype F] [Fintype σ] [DecidableEq σ] {c t r : ℕ}", - "line": 108, - "end_line": 144, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.EncodedLineLowDegreeTest.exists_close", - "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_close\n (hq : PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F)\n (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ)\n (f : (σ → F) → Coefficients t r → ZMod 2) (H : Auxiliary F σ m c t)\n (hsmall : lineErrorConstant c * rejectionRate hr ρ nodes ζ f H ≤\n PointLineConstants.smallError) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ c * m ^ c ∧\n relativeDistance (fun p : (σ → F) × Coefficients t r => f p.1 p.2)\n (encodeFunction r (fun x => ρ (MvPolynomial.eval x P))) ≤\n soundnessConstant c * rejectionRate hr ρ nodes ζ f H ∧\n BinaryLagrangeConstraint.homogeneousDistance hr f\n (fun x => encode r (ρ (MvPolynomial.eval x P))) ≤\n soundnessConstant c * rejectionRate hr ρ nodes ζ f H\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Algebra (ZMod 2) F] {m c t r : ℕ}\nvariable [Fintype F] [DecidableEq F] [Fintype σ] [DecidableEq σ]\nvariable [CharP F 2]\nvariable [NeZero m]", - "line": 325, - "end_line": 359, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le", - "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem failure_le\n (hq : 2 * c < Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ)\n {D : ℕ} (P : MvPolynomial σ F) (hP : P.totalDegree ≤ D)\n (hdecode : c * m ^ c ≤ D)\n (f : (σ → F) → Coefficients t 1 → ZMod 2)\n (H : (σ → F) → RowOracle F m c t) {δ : ℚ}\n (hnear : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) f\n (fun x => encode 1 (ρ (MvPolynomial.eval x P))) ≤ δ) (a : σ → F) :\n relativeDistance (sample ρ nodes ζ f H a)\n (fun s : Sample F σ m c t => some (linearEncode (ρ (MvPolynomial.eval a P)) s.2.2.1.2)) ≤\n soundnessConstant c * rejectionRate ρ nodes ζ f H a + δ +\n (D : ℚ) / (2 * (Fintype.card F - 1 : ℕ))\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Algebra (ZMod 2) F] {m c t : ℕ}\nvariable [Fintype F] [DecidableEq F] [Fintype σ] [DecidableEq σ]\nvariable [CharP F 2]\nvariable [NeZero m]", - "line": 222, - "end_line": 313, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_certificate", - "module": "PCP.Algebraic.VanishingCertificate", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem vanishesOn_iff_exists_certificate [Finite σ] (H : Finset R) (hH : H.Nonempty)\n (p : MvPolynomial σ R) :\n VanishesOn H p ↔ ∃ M : MvPolynomial (σ ⊕ σ) R,\n M.totalDegree ≤ p.totalDegree ∧ IsCertificate H p M\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {R σ : Type*} [CommRing R]\nvariable [Fintype σ]\nvariable [IsDomain R]", - "line": 119, - "end_line": 132, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_ge", - "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem rejectionRate_ge\n (hq : 2 * c < Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) (H : Finset F) (hH : H.Nonempty)\n (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F)\n (hP : P.totalDegree ≤ D) (hM : M.totalDegree ≤ D)\n (hdecode : c * m ^ c ≤ D) (hnot : ¬ GridVanishing.VanishesOn H P)\n (p' : (Fin n → F) → Coefficients t 1 → ZMod 2)\n (M' : CertificatePoint F n → Coefficients t 1 → ZMod 2)\n (A : Auxiliary F n m c t) {δP δM : ℚ}\n (hp : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) p'\n (fun x => encode 1 (ρ (eval x P))) ≤ δP)\n (hm : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) M'\n (fun x => encode 1 (ρ (eval x M))) ≤ δM) :\n ((1 - ((D * H.card : ℕ) : ℚ) / Fintype.card F) / 2 - δP - 2 * δM -\n (D : ℚ) / (Fintype.card F - 1 : ℕ)) /\n (1 + 2 * BinaryLocalCorrection.soundnessConstant c) ≤\n rejectionRate ρ nodes ζ H p' M' A\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {X W S A : Type*} [Fintype X] [Fintype W] [Fintype S] [Nonempty S]\nvariable [DecidableEq A]\nvariable {X W S : Type*} [Fintype X] [Nonempty X] [Fintype W]\nvariable [Fintype S] [Nonempty S]\nvariable {F : Type*} [Field F] [Algebra (ZMod 2) F] [Fintype F] [DecidableEq F]\nvariable [CharP F 2] {n m c t D : ℕ} [NeZero m]", - "line": 301, - "end_line": 325, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.HadamardDerivedOracle.rejection_transfer", - "module": "PCP.Algebraic.HadamardDerivedOracle", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem rejection_transfer {A B : Type*} [Fintype A] [DecidableEq B]\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (P : I → Polynomial F) (hP : ∀ i, (P i).natDegree ≤ r)\n (H : I → Coefficients t r → ZMod 2) (f : I → F)\n (L : I → A → Coefficients t 1) (decision : I → A → ZMod 2 → B)\n (accept : I → A → B) :\n relativeDistance\n (fun s : I × A => decision s.1 s.2 (encode 1 (ρ ((P s.1).eval (f s.1))) (L s.1 s.2)))\n (fun s => accept s.1 s.2) ≤\n relativeDistance\n (fun s : I × (A × Coefficients t r) =>\n decision s.1 s.2.1 (answer ρ (P s.1) (hP s.1) (H s.1) (L s.1 s.2.1) s.2.2))\n (fun s => accept s.1 s.2.1) + 2 * fullDistance ρ H f\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F : Type*} [CommRing F] [Algebra (ZMod 2) F] {t r : ℕ}\nvariable {I : Type*} [Fintype I]", - "line": 166, - "end_line": 195, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorAlgebra.sub_cube_eq_one_iff_ne", - "module": "PCP.Algebraic.ThreeColorAlgebra", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem sub_cube_eq_one_iff_ne {a b : F} (ha : a ^ 3 = 1) (hb : b ^ 3 = 1) :\n (a - b) ^ 3 = 1 ↔ a ≠ b\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F V : Type*} [Field F]\nvariable [CharP F 2]", - "line": 60, - "end_line": 70, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorGrid.constraints_iff_satisfies", - "module": "PCP.Algebraic.ThreeColorGrid", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem constraints_iff_satisfies (H : Finset F)\n (G : SimpleGraph (σ → H)) (P : MvPolynomial σ F) :\n (VanishesOn H (validPolynomial P) ∧\n VanishesOn H (properPolynomial (edgeExtension H G) (differencePolynomial P))) ↔\n Satisfies G (fun a => eval (fun i => (a i : F)) P)\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F]\nvariable [Fintype σ] [DecidableEq σ] [DecidableEq F]", - "line": 91, - "end_line": 114, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate_ge_of_not_colorable", - "module": "PCP.Algebraic.ThreeColorVerifierSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem rejectionRate_ge_of_not_colorable\n (hc : 1 ≤ c)\n (hq : PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) {ω : F} (hω : IsPrimitiveRoot ω 3)\n (H : Finset F) (hH : H.Nonempty)\n (hgrid : 100 * (c * m ^ c) * H.card ≤ Fintype.card F)\n (hdegree : (H.card - 1) * n ≤ c * m ^ c)\n (G : SimpleGraph (Fin n → H)) (hG : ¬ G.Colorable 3) (π : Proof F n m c t) :\n ThreeColorSoundnessBudget.gap c ≤ rejectionRate ρ nodes ζ H G π\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F : Type*} [Field F] [Algebra (ZMod 2) F] [Fintype F]\nvariable {n m c t : ℕ} [NeZero m] [CharP F 2]", - "line": 117, - "end_line": 130, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.DerivedZeroOnGrid.rejection_transfer", - "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem rejection_transfer (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ x, (Q x).natDegree ≤ r)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (p : (Fin n → F) → Coefficients t r → ZMod 2) (f : (Fin n → F) → F)\n (M : CertificatePoint F n → Coefficients t 1 → ZMod 2) (A : Auxiliary F n m c t) :\n BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H\n (fun x => encode 1 (ρ ((Q x).eval (f x)))) M A ≤\n rejectionRate ρ Q hQ nodes ζ H p M A + 2 * HadamardDerivedOracle.fullDistance ρ p f\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F : Type*} [Field F] [Algebra (ZMod 2) F] {n m c t r : ℕ}\nvariable [NeZero m] [CharP F 2]\nvariable [Fintype F] [DecidableEq F]", - "line": 187, - "end_line": 198, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorVerifier.queries_length_le", - "module": "PCP.Algebraic.ThreeColorVerifier", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem queries_length_le (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → H))\n (s : Sample F n m c t) : (queries ρ nodes ζ H G s).length ≤ 20 * c + 107", - "line": 362, - "end_line": 389, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_rejectionRate_eq_zero", - "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_proof_rejectionRate_eq_zero (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : Function.Injective nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) {ω : F} (hω : IsPrimitiveRoot ω 3)\n (H : Finset F) (hH : H.Nonempty) (G : SimpleGraph (Fin n → H)) (hG : G.Colorable 3)\n (hdegree : 5 * ((H.card - 1) * n) < m ^ c) :\n ∃ π : Proof F n m c t, rejectionRate ρ nodes ζ H G π = 0\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F : Type*} [Field F] [Algebra (ZMod 2) F] {n m c t : ℕ}\nvariable [NeZero m]\nvariable [CharP F 2]\nvariable [Fintype F]", - "line": 130, - "end_line": 141, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorFields.chosen_parameters", - "module": "PCP.Algebraic.ThreeColorFields", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem chosen_parameters (M : ℕ) :\n M ≤ Fintype.card (Chosen M) ∧ Fintype.card (Chosen M) ≤ 16 * max 1 M ∧\n Function.Injective (nodes (index M)) ∧\n StandardLocalCorrection.GoodNodes 4 (generator (index M)) ∧\n IsPrimitiveRoot (cubeRoot (index M)) 3\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 171, - "end_line": 177, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.verification_guarantees", - "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem verification_guarantees :\n verifier.queries = 187 ∧ verifier.CanonicalRandomness 32000000 32000000 ∧\n (∀ x, verifier.ReadsBelow x (proofBound.eval x.length)) ∧\n (∀ x, (ThreeColorEncoding.graph x).Colorable 3 → verifier.CompleteAt x) ∧\n (∀ x, ¬ (ThreeColorEncoding.graph x).Colorable 3 →\n verifier.SoundAt x (1 - ThreeColorBinaryVerifier.gap))\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 168, - "end_line": 174, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verification_guarantees", - "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem verification_guarantees :\n 0 < repetitions ∧ verifier.queries = repetitions * 187 ∧\n verifier.CanonicalRandomness (repetitions * 32000000) (repetitions * 32000000) ∧\n (∀ x, verifier.ReadsBelow x (ThreeColorCanonicalVerifier.proofBound.eval x.length)) ∧\n (∀ x, (ThreeColorEncoding.graph x).Colorable 3 → verifier.CompleteAt x) ∧\n (∀ x, ¬ (ThreeColorEncoding.graph x).Colorable 3 → verifier.SoundAt x (1 / 2))\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 72, - "end_line": 78, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Lang.ThreeColorRuntime.polyTimeAlg", - "module": "PCP.Complexity.ThreeColorRuntime", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem polyTimeAlg :\n Machine.PolyTimeAlg ComputableThreeColorAmplifiedQueryAlgorithm.algorithm\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 11, - "end_line": 15, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Reduction.NPThreeColorRuntime.of_inNP_program", - "module": "PCP.Reduction.NPThreeColorRuntime", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem of_inNP_program {L : PCP.Language} (hL : PCP.InNP PolyTimeRel L) :\n ∃ (f : List Bool → List Bool) (p : Polynomial ℕ) (P : Prog) (C d : ℕ),\n ∀ x : List Bool,\n P.run (x.map Bool.toNat) = (f x).map Bool.toNat ∧\n P.cost (x.map Bool.toNat) ≤ C * (x.length + 1) ^ d ∧\n ((Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧\n (f x).length ≤ p.eval x.length\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {R : List Bool → List Bool → Bool} (h : Checker R) (q : Polynomial ℕ)\nvariable [DecidableEq h.tm.Λ] [DecidableEq h.tm.σ]\nvariable [DecidableEq h.tm.Λ] [DecidableEq h.tm.σ]", - "line": 257, - "end_line": 265, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.pcp_subset_np_concrete", - "module": "PCP.ReverseConcrete", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem pcp_subset_np_concrete (L : Language) (V : Verifier) (alg : VerifierAlg) (a b : ℕ)\n (p : Polynomial ℕ) (halg : Machine.PolyTimeAlg alg) (himpl : V.ImplementedBy alg)\n (hrand : V.CanonicalRandomness a b)\n (hlen : ∀ x : List Bool, V.ReadsBelow x (p.eval x.length))\n (hcomplete : ∀ x : List Bool, L x → V.CompleteAt x)\n (hsound : ∀ x : List Bool, ¬ L x → V.SoundAt x (1 / 2)) :\n InNP Machine.PolyTimeRel L\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 33, - "end_line": 43, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "axioms": [ - "propext" - ], - "doc": "Reading the first `N` bits of an oracle back out reproduces it below `N`. ", - "end_line": 219, - "is_class": false, - "kind": "theorem", - "line": 216, - "module": "PCP.Verifier.Definition", - "name": "PCP.oracleOfWitness_prefix", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (π : PCP.ProofOracle) (N : ℕ) {j : ℕ}, j < N → PCP.oracleOfWitness (List.map π (List.range N)) j = π j", - "type_dependencies": [ - "PCP.ProofOracle", - "Nat", - "LT.lt", - "instLTNat", - "Eq", - "Bool", - "PCP.oracleOfWitness", - "List.map", - "List.range" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk", - "PCP.Verifier.rec" - ] - }, - { - "axioms": [], - "doc": "A proof oracle is an infinite Boolean string; `π a` is the bit at address `a`. ", - "end_line": 28, - "is_class": false, - "kind": "definition", - "line": 27, - "module": "PCP.Verifier.Definition", - "name": "PCP.ProofOracle", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "Nat", - "Bool" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodePair.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (p : List Bool × List Bool),\n PCP.Machine.encodePair p = PCP.Machine.ofBits p.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits p.2", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.encodePair", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "Logarithmic randomness as an upper bound: at most `a * ⌈log₂ (n + 2)⌉ + b` fair bits on\ninputs of length `n`.\n\n**This is too weak to be an efficiency hypothesis on its own.** An upper bound does not make\n`randomness` computable, and `Verifier.randomness` is an unrestricted function `ℕ → ℕ`. Take\n`randomness n = if f n then 1 else 0` for arbitrary `f`: the\nbound `LogRandomness 0 1` holds, yet the budget smuggles in an arbitrary Boolean function of the\ninput length, which an algorithm recovers just by measuring the length of the random string it is\nhanded. Use `CanonicalRandomness` wherever efficiency is at stake. ", - "end_line": 146, - "is_class": false, - "kind": "definition", - "line": 136, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.LogRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ → ℕ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "LE.le", - "instLENat", - "PCP.Verifier.randomness", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "HMul.hMul", - "instHMul", - "instMulNat", - "Nat.clog", - "OfNat.ofNat", - "instOfNatNat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.ofBits.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : List Bool), PCP.Machine.ofBits x = List.map PCP.Machine.Sym.bit x", - "type_dependencies": [ - "List", - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.ofBits", - "List.map", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.acceptingRandomness.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.acceptingRandomness x π = {r | (V.run x r).eval π = true}", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Eq", - "Finset", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.Verifier.acceptingRandomness", - "Finset.filter", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "Bool.true", - "instDecidableEqBool", - "Finset.univ", - "Fin.fintype" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "Eq", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 79, - "is_class": false, - "kind": "constructor", - "line": 79, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk", - "provenance": "lean", - "structural_dependencies": [ - "PCP.CostModel" - ], - "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.finiteWitnessCheck.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w =\n decide (∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true)", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Eq", - "PCP.finiteWitnessCheck", - "Decidable.decide", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "PCP.oracleOfWitness", - "Bool.true", - "Nat.decidableForallFin", - "instDecidableEqBool" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b : Bool), sizeOf (PCP.Machine.Sym.bit b) = 1 + sizeOf b", - "type_dependencies": [ - "Bool", - "Eq", - "Nat", - "SizeOf.sizeOf", - "PCP.Machine.Sym", - "PCP.Machine.Sym._sizeOf_inst", - "PCP.Machine.Sym.bit", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "Bool._sizeOf_inst" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk", - "PCP.NPCertificate.rec" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A verifier algorithm is polynomial-time when some `FinTM2` machine computes its step function\nwithin a polynomial number of steps in the encoded input length. ", - "end_line": 73, - "is_class": false, - "kind": "definition", - "line": 69, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.PolyTimeAlg", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.VerifierAlg → Prop", - "type_dependencies": [ - "PCP.VerifierAlg" - ], - "value_dependencies": [ - "PCP.VerifierAlg", - "Nonempty", - "Turing.TM2ComputableInPolyTime", - "Prod", - "List", - "Bool", - "Sum", - "Nat", - "PCP.Machine.Sym", - "PCP.Machine.encodeTriple", - "PCP.Machine.encodeAnswer", - "Prod.fst", - "Prod.snd" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A uniform cost model: what \"polynomial time\" means for witness-checking relations and for\nverifier algorithms, together with the coherence and closure properties any genuine model has.\n\nThe field docstrings explain why each field is present. **The machine model is no longer a choice**:\n`PCP/Complexity/Machine.lean` fixes it as `Turing.TM2ComputableInPolyTime`. Showing those concrete\npredicates satisfy this interface was obligation NP-1, now discharged: the two coherence fields in\n`PCP/Complexity/Bridge.lean`, the closure field below in `PCP/Complexity/StandardModel.lean`.\nNote the known cost of that choice: *some* certified composition or subroutine result is needed for\nthe closure field, and mathlib's `comp` is an open `proof_wanted` at the pinned revision. That\nupstream theorem is one route; a specialised call-and-return construction for these fixed encodings\nis another, and is the one that was built. ", - "end_line": 108, - "is_class": false, - "kind": "inductive", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel", - "provenance": "lean", - "structural_dependencies": [ - "PCP.CostModel.mk", - "PCP.CostModel" - ], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] → [(a : List Bool) → SizeOf (L a)] → PCP.NPCertificate P L → ℕ", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "PCP.NPCertificate", - "Nat" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "PCP.NPCertificate", - "PCP.NPCertificate.rec", - "Nat", - "Polynomial", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "SizeOf.sizeOf", - "Polynomial._sizeOf_inst", - "instSizeOfNat" - ] - }, - { - "axioms": [], - "doc": "The depth-`d` decision tree generated by unfolding a step function, starting from the answers\n`as` received so far.\n\nIf the step function has not halted within its `d`-query budget the tree rejects: an algorithm\nclaiming a `q`-query verifier must halt within `q` queries, and `ImplementedBy` below is what\nforces that to match the verifier's actual behaviour. ", - "end_line": 47, - "is_class": false, - "kind": "definition", - "line": 35, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Nat.brecOn", - "PCP.QueryTree", - "PCP.QueryTree.ofStep._f" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "If the oracles agree on every address the tree can reach, the tree cannot tell them apart. ", - "end_line": 77, - "is_class": false, - "kind": "theorem", - "line": 67, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval_congr", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (T : PCP.QueryTree d) {π π' : PCP.ProofOracle}, (∀ a ∈ T.addresses, π a = π' a) → T.eval π = T.eval π'", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.eval" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.brecOn.go", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t ×' PCP.QueryTree.below t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PProd" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.QueryTree.rec", - "PProd", - "Bool", - "PProd.mk", - "PCP.QueryTree.leaf", - "PUnit", - "PUnit.unit", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 36, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 1 →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Polynomial bound on witness length. ", - "end_line": 32, - "is_class": false, - "kind": "definition", - "line": 32, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.witnessBound", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → Polynomial ℕ", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ] - }, - { - "axioms": [], - "doc": "A language over the binary alphabet: inputs are bit strings. ", - "end_line": 15, - "is_class": false, - "kind": "definition", - "line": 14, - "module": "PCP.Complexity.NP", - "name": "PCP.Language", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "List", - "Bool" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Every address the tree could query, along any branch. ", - "end_line": 49, - "is_class": false, - "kind": "definition", - "line": 46, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.brecOn", - "Finset", - "PCP.QueryTree.addresses._f" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (d : ℕ) (f t : PCP.QueryTree d),\n (f.addresses ∪ t.addresses).card ≤ f.addresses.card + t.addresses.card →\n ¬(f.addresses ∪ t.addresses).card + 1 ≤ 1 + (f.addresses.card + t.addresses.card) → False", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "LE.le", - "instLENat", - "Finset.card", - "Union.union", - "Finset", - "Finset.instUnion", - "instDecidableEqNat", - "PCP.QueryTree.addresses", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Not", - "Preorder.toLE", - "Nat.instPreorder", - "OfNat.ofNat", - "instOfNatNat", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (f : PCP.QueryTree.below x_1), x_1.addresses.card < 2 ^ x", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", - "Bool", - "PCP.QueryTree.leaf", - "of_eq_true", - "Preorder.toLT", - "PartialOrder.toPreorder", - "Nat.instPartialOrder", - "Zero.toOfNat0", - "MulZeroClass.toZero", - "MulZeroOneClass.toMulZeroClass", - "MonoidWithZero.toMulZeroOneClass", - "Nat.instMonoidWithZero", - "MonoidWithZero.toMonoid", - "pow_pos._simp_1", - "LinearOrderedCommMonoidWithZero.toPosMulStrictMono", - "Nat.instLinearOrderedCommMonoidWithZero", - "Nat.instZeroLEOneClass", - "SemilatticeInf.toPartialOrder", - "Lattice.toSemilatticeInf", - "DistribLattice.toLattice", - "instDistribLatticeOfLinearOrder", - "Nat.instLinearOrder", - "instOfNatAtLeastTwo", - "AddMonoidWithOne.toNatCast", - "Nat.instAddMonoidWithOne", - "Nat.instAtLeastTwoHAddOfNat", - "Nat.instNeZeroSucc", - "Eq.trans", - "LE.le", - "Preorder.toLE", - "One.toOfNat1", - "AddMonoidWithOne.toOne", - "True", - "Order.lt_two_iff._simp_1", - "Nat.instSuccAddOrder", - "Nat.instNoMaxOrder", - "zero_le._simp_1", - "LinearOrderedCommMonoidWithZero.toIsBotZeroClass", - "Nat.succ", - "PCP.QueryTree.query", - "PProd", - "instLENat", - "Insert.insert", - "Finset", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "LE.le.trans", - "Nat.instPreorder", - "Finset.card_insert_le", - "Finset.card_union_le", - "Decidable.byContradiction", - "Nat.decLe", - "Not", - "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", - "id", - "Eq", - "Mathlib.Tactic.Ring.of_eq", - "Distrib.toAdd", - "instDistribOfSemiring", - "CommSemiring.toSemiring", - "Nat.instCommSemiring", - "HMul.hMul", - "instHMul", - "Distrib.toMul", - "Semiring.toMonoid", - "Nat.rawCast", - "AddCommMonoidWithOne.toAddMonoidWithOne", - "NonAssocSemiring.toAddCommMonoidWithOne", - "Semiring.toNonAssocSemiring", - "instMulZeroClassOfSemiring", - "instMulNat", - "Mathlib.Tactic.Ring.Common.pow_congr", - "Mathlib.Tactic.Ring.cast_pos", - "Mathlib.Meta.NormNum.isNat_ofNat", - "Eq.refl", - "Mathlib.Tactic.Ring.Common.add_congr", - "Mathlib.Tactic.Ring.Common.atom_pf", - "rfl", - "Eq.mpr", - "congrArg", - "Eq.symm", - "Mathlib.Tactic.Ring.Common.add_pf_add_gt", - "Mathlib.Tactic.Ring.Common.add_pf_add_zero", - "Mathlib.Tactic.Ring.Common.pow_add", - "Mathlib.Tactic.Ring.Common.pow_one_cast_of_isNat", - "Mathlib.Meta.NormNum.IsNat.mk", - "Mathlib.Tactic.Ring.Common.single_pow", - "Mathlib.Tactic.Ring.Common.pow_prod_atom", - "Mathlib.Tactic.Ring.Common.pow_zero", - "Mathlib.Tactic.Ring.Common.add_mul", - "Mathlib.Tactic.Ring.Common.mul_add", - "Mathlib.Tactic.Ring.Common.mul_pf_left", - "Mathlib.Meta.NormNum.IsNat.to_raw_eq", - "Mathlib.Meta.NormNum.isNat_mul", - "Mathlib.Meta.NormNum.IsNat.of_raw", - "Mathlib.Tactic.Ring.Common.mul_zero", - "Mathlib.Tactic.Ring.Common.zero_mul", - "Mathlib.Tactic.Ring.Common.mul_pf_right", - "Mathlib.Tactic.Ring.Common.add_pf_add_overlap", - "Mathlib.Tactic.Ring.Common.add_overlap_pf", - "Mathlib.Meta.NormNum.isNat_add", - "Mathlib.Tactic.Ring.Common.add_pf_zero_add", - "Nat.decLt", - "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instReprSym.repr", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym → ℕ → Format", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "Std.Format" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "PCP.Machine.instFintypeSym.match_5", - "Std.Format", - "Bool", - "Repr.addAppParen", - "Std.Format.group", - "Std.Format.nest", - "ite", - "Int", - "GE.ge", - "instLENat", - "OfNat.ofNat", - "instOfNatNat", - "Nat.decLe", - "instOfNat", - "HAppend.hAppend", - "instHAppendOfAppend", - "Std.Format.instAppend", - "Std.Format.text", - "Std.Format.line", - "reprArg", - "instReprBool", - "Std.Format.FlattenBehavior.allOrNone", - "Unit" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : PCP.Machine.Sym → PCP.Machine.Sym → Sort u_1) →\n (x x_1 : PCP.Machine.Sym) →\n ((a b : Bool) → motive (PCP.Machine.Sym.bit a) (PCP.Machine.Sym.bit b)) →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b) PCP.Machine.Sym.sep) →\n ((b : Bool) → motive PCP.Machine.Sym.sep (PCP.Machine.Sym.bit b)) →\n (Unit → motive PCP.Machine.Sym.sep PCP.Machine.Sym.sep) → motive x x_1", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "Unit" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "Unit", - "PCP.Machine.Sym.casesOn", - "Unit.unit" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A certificate that `L` is in NP relative to a notion `P` of polynomial-time checkability: a\npolynomial witness bound and a witness-checking relation that `P` accepts.\n\n`P` is a plain parameter here, and that is safe *because nothing is proved by quantifying over it*.\n`InNP` is a definition, not a theorem. The two consumers each pin it down:\n\n* `pcp_subset_np` instantiates `P := M.PolyTimeRel` for a `CostModel` `M`, whose closure field is\n what makes the conclusion non-vacuous;\n* `np_subset_pcp` instantiates `P := PCP.Machine.PolyTimeRel`, the concrete machine definition.\n\nNeither quantifies over an arbitrary `P`. The distinction matters:\na *theorem* over an unconstrained interface is refutable by choosing a degenerate instance; a\n*definition* parameterised by one is just a definition. ", - "end_line": 39, - "is_class": false, - "kind": "inductive", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate", - "provenance": "lean", - "structural_dependencies": [ - "PCP.NPCertificate.mk", - "PCP.NPCertificate" - ], - "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Type", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → ℕ", - "type_dependencies": [ - "PCP.CostModel", - "Nat" - ], - "value_dependencies": [ - "PCP.CostModel", - "PCP.CostModel.rec", - "Nat", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "OfNat.ofNat", - "instOfNatNat" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Verifier algorithms running in polynomial time. ", - "end_line": 83, - "is_class": false, - "kind": "definition", - "line": 83, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.PolyTimeAlg", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → PCP.VerifierAlg → Prop", - "type_dependencies": [ - "PCP.CostModel", - "PCP.VerifierAlg" - ], - "value_dependencies": [ - "PCP.CostModel" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk", - "PCP.NPCertificate.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval._sunfold", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "PCP.QueryTree.eval.match_1", - "Bool", - "ite", - "Eq", - "Bool.true", - "instDecidableEqBool", - "PCP.QueryTree.eval" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "The `k`-bit binary expansion of a random string index, least significant bit first. ", - "end_line": 28, - "is_class": false, - "kind": "definition", - "line": 26, - "module": "PCP.Complexity.CostModel", - "name": "PCP.bitsOfFin", - "provenance": "lean", - "structural_dependencies": [], - "type": "(k : ℕ) → Fin (2 ^ k) → List Bool", - "type_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List", - "Bool" - ], - "value_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.map", - "Bool", - "Nat.testBit", - "Fin.val", - "List.range" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R}\n {polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)}\n {PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg_1 : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R}\n {polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)},\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 } →\n PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d), (PCP.QueryTree.query a f t).addresses = insert a (f.addresses ∪ t.addresses)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "Finset", - "PCP.QueryTree.addresses", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": 56, - "is_class": false, - "kind": "theorem", - "line": 54, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodeTriple", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (t : List Bool × List Bool × List Bool),\n (PCP.Machine.encodeTriple t).length = t.1.length + t.2.1.length + t.2.2.length + 2", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "Nat", - "List.length", - "PCP.Machine.Sym", - "PCP.Machine.encodeTriple", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "(P : (List Bool → List Bool → Bool) → Prop) →\n (L : PCP.Language) →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] →\n [(a : List Bool) → SizeOf (L a)] → SizeOf (PCP.NPCertificate P L)", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "SizeOf.mk", - "PCP.NPCertificate", - "PCP.NPCertificate._sizeOf_1" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": "A canonical budget *is* the closed-form function of the two constants.\n\nNamed for what it says. It is an equality of functions, not a proposition of type\n`Computable V.randomness`. None is needed downstream: the closed form is evidently computable, and\nthe verifier's efficiency is certified separately through `Verifier.ImplementedBy` and the machine\npredicates of `PCP/Complexity/Machine.lean`. ", - "end_line": 167, - "is_class": false, - "kind": "theorem", - "line": 160, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CanonicalRandomness.eq_closedForm", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.randomness = fun n => a * Nat.clog 2 (n + 2) + b", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "PCP.Verifier.CanonicalRandomness", - "Eq", - "PCP.Verifier.randomness", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "HMul.hMul", - "instHMul", - "instMulNat", - "Nat.clog", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Acceptance probability, as an exact rational: the fraction of the `2 ^ randomness` equally\nlikely random strings on which `V` accepts. ", - "end_line": 104, - "is_class": false, - "kind": "definition", - "line": 101, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → PCP.ProofOracle → ℚ", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Rat" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "HDiv.hDiv", - "Rat", - "instHDiv", - "Rat.instDiv", - "Nat.cast", - "Rat.instNatCast", - "Finset.card", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.Verifier.acceptingRandomness", - "Rat.instPowNat", - "Rat.instOfNat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.ctorElimType", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} → ℕ → Sort (max 1 u)", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "cond", - "Nat.ble", - "PULift", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 158, - "is_class": false, - "kind": "theorem", - "line": 157, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CanonicalRandomness.logRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.LogRandomness a b", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.LogRandomness" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d addr : ℕ} {onFalse onTrue : PCP.QueryTree d} {addr_1 : ℕ} {onFalse_1 onTrue_1 : PCP.QueryTree d},\n PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1 →\n addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Perfect completeness at `x`: some proof is accepted with probability 1. ", - "end_line": 131, - "is_class": false, - "kind": "definition", - "line": 130, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CompleteAt", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → Prop", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Exists", - "PCP.ProofOracle", - "Eq", - "Rat", - "PCP.Verifier.accProb", - "OfNat.ofNat", - "Rat.instOfNat" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)),\n sizeOf\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n 1", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "SizeOf.sizeOf", - "PCP.CostModel", - "PCP.CostModel._sizeOf_inst", - "PCP.CostModel.mk", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.brecOn.eq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {motive : (a : ℕ) → PCP.QueryTree a → Sort u} {a : ℕ} (t : PCP.QueryTree a)\n (F_1 : (a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t),\n PCP.QueryTree.brecOn t F_1 = F_1 a t (PCP.QueryTree.brecOn.go t F_1).2", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "Eq", - "PCP.QueryTree.brecOn", - "PProd", - "PCP.QueryTree.brecOn.go" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "The randomness budget is **exactly** `a * ⌈log₂ (n + 2)⌉ + b`.\n\nTwo constants determine the whole budget, so it is computable by construction and carries no\ninformation of its own. This is the \"canonical computable budget\" repair: it closes the hole that\n`LogRandomness` leaves open, and it is without loss of generality because a verifier that wants\nfewer bits can ignore the surplus. ", - "end_line": 155, - "is_class": false, - "kind": "definition", - "line": 148, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CanonicalRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ → ℕ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "Eq", - "PCP.Verifier.randomness", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "HMul.hMul", - "instHMul", - "instMulNat", - "Nat.clog", - "OfNat.ofNat", - "instOfNatNat" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {randomness : ℕ → ℕ} {queries : ℕ} {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries}\n {randomness_1 : ℕ → ℕ} {queries_1 : ℕ}\n {run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1},\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 } →\n randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "And", - "HEq" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.rec" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "The NP checking relation induced by a verifier: accept `(x, w)` when the finite witness `w`,\nread as a proof, makes `V` accept on *every* random string.\n\nThis is decidable because the random space `Fin (2 ^ randomness)` is finite, which is the whole\npoint: perfect completeness turns into a finite check. Whether it is *polynomial-time* decidable\nis a separate question, answered by `CostModel.polyTimeRel_finiteWitnessCheck`. ", - "end_line": 210, - "is_class": false, - "kind": "definition", - "line": 203, - "module": "PCP.Verifier.Definition", - "name": "PCP.finiteWitnessCheck", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → List Bool → Bool", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Decidable.decide", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Eq", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "PCP.oracleOfWitness", - "Bool.true", - "Nat.decidableForallFin", - "instDecidableEqBool" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A binary relation on bit strings is polynomial-time when some `FinTM2` machine computes it\nwithin a polynomial number of steps in the encoded input length. ", - "end_line": 67, - "is_class": false, - "kind": "definition", - "line": 64, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.PolyTimeRel", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → List Bool → Bool) → Prop", - "type_dependencies": [ - "List", - "Bool" - ], - "value_dependencies": [ - "List", - "Bool", - "Nonempty", - "Turing.TM2ComputableInPolyTime", - "Prod", - "PCP.Machine.Sym", - "PCP.Machine.encodePair", - "PCP.Machine.encodeBool", - "Prod.fst", - "Prod.snd" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.eq_def", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 : PCP.ProofOracle),\n x_1.eval x_2 =\n match x, x_1, x_2 with\n | x, PCP.QueryTree.leaf b, x_3 => b\n | .(d + 1), PCP.QueryTree.query a f t, π => if π a = true then t.eval π else f.eval π", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Eq", - "Bool", - "PCP.QueryTree.eval", - "PCP.QueryTree.eval.match_1", - "ite", - "Bool.true", - "instDecidableEqBool" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The tree reads at most `d` bits along any branch: its address set has at most `2 ^ d - 1`\nelements, and along a single run at most `d` queries are made. ", - "end_line": 65, - "is_class": false, - "kind": "theorem", - "line": 51, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (T : PCP.QueryTree d), T.addresses.card < 2 ^ d", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeAnswer.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((a : ℕ) → motive (Sum.inr a)) → motive x", - "type_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr", - "Sum.casesOn" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language}\n [inst : (a : List Bool → List Bool → Bool) → SizeOf (P a)] [inst_1 : (a : List Bool) → SizeOf (L a)]\n (witnessBound : Polynomial ℕ) (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true),\n sizeOf { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n 1 + sizeOf witnessBound + sizeOf check_polyTime", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "SizeOf.sizeOf", - "PCP.NPCertificate", - "PCP.NPCertificate._sizeOf_inst", - "PCP.NPCertificate.mk", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "Polynomial._sizeOf_inst", - "instSizeOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": "Stop and accept (`true`) or reject (`false`). ", - "end_line": 35, - "is_class": false, - "kind": "constructor", - "line": 34, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf", - "provenance": "lean", - "structural_dependencies": [ - "PCP.QueryTree" - ], - "type": "{d : ℕ} → Bool → PCP.QueryTree d", - "type_dependencies": [ - "Nat", - "Bool", - "PCP.QueryTree" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Only the first `N` proof bits matter when `V.ReadsBelow x N`. ", - "end_line": 128, - "is_class": false, - "kind": "theorem", - "line": 121, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_congr_of_readsBelow", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) {N : ℕ},\n V.ReadsBelow x N → ∀ {π π' : PCP.ProofOracle}, (∀ a < N, π a = π' a) → V.accProb x π = V.accProb x π'", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Nat", - "PCP.Verifier.ReadsBelow", - "PCP.ProofOracle", - "LT.lt", - "instLTNat", - "Eq", - "Rat", - "PCP.Verifier.accProb" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match d + 1, PCP.QueryTree.query a f t with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_2 d a f t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.addresses.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "recursor", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → (t : PCP.Machine.Sym) → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": 52, - "is_class": false, - "kind": "theorem", - "line": 50, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodePair", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (p : List Bool × List Bool), (PCP.Machine.encodePair p).length = p.1.length + p.2.length + 1", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "Nat", - "List.length", - "PCP.Machine.Sym", - "PCP.Machine.encodePair", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 24, - "is_class": false, - "kind": "constructor", - "line": 24, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.sep", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Machine.Sym" - ], - "type": "PCP.Machine.Sym", - "type_dependencies": [ - "PCP.Machine.Sym" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u →\n {P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n PCP.NPCertificate P L →\n {P' : (List Bool → List Bool → Bool) → Prop} → {L' : PCP.Language} → PCP.NPCertificate P' L' → Sort u", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "PCP.NPCertificate.casesOn", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym → ℕ", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.Sym.casesOn", - "Nat", - "Bool" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (a b : Bool), ¬a = b → PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit b → False", - "type_dependencies": [ - "Bool", - "Not", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (a : Bool), PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit a", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk._flat_ctor", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.eq_def", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x),\n x_1.addresses =\n match x, x_1 with\n | x, PCP.QueryTree.leaf accept => ∅\n | .(d + 1), PCP.QueryTree.query a f t => insert a (f.addresses ∪ t.addresses)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "Finset", - "PCP.QueryTree.addresses", - "PCP.QueryTree.addresses.match_1", - "Bool", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk._flat_ctor", - "provenance": "lean", - "structural_dependencies": [], - "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "(a : ℕ) → SizeOf (PCP.QueryTree a)", - "type_dependencies": [ - "Nat", - "SizeOf", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "SizeOf.mk", - "PCP.QueryTree", - "PCP.QueryTree._sizeOf_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.ctorElim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (ctorIdx : ℕ) → (t : PCP.Machine.Sym) → ctorIdx = t.ctorIdx → PCP.Machine.Sym.ctorElimType ctorIdx → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "Eq", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.ctorElimType" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "Eq", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.ctorElimType", - "PCP.Machine.Sym.casesOn", - "Bool", - "PULift.down", - "PCP.Machine.Sym.bit", - "Eq.ndrec", - "PCP.Machine.Sym.sep" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The witness-checking relation. ", - "end_line": 34, - "is_class": false, - "kind": "definition", - "line": 34, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.check", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → List Bool → List Bool → Bool", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 23, - "is_class": false, - "kind": "definition", - "line": 23, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → t.ctorIdx = 0 → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "Bool", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (x : ℕ) (accept : Bool)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match x, PCP.QueryTree.leaf accept with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_1 x accept", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.addresses.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 85, - "is_class": false, - "kind": "definition", - "line": 85, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {randomness : ℕ → ℕ} →\n {queries : ℕ} →\n {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries} →\n {randomness' : ℕ → ℕ} →\n {queries' : ℕ} →\n {run' : (x : List Bool) → Fin (2 ^ randomness' x.length) → PCP.QueryTree queries'} →\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness', queries := queries', run := run' } →\n (randomness = randomness' → queries = queries' → run ≍ run' → P) → P", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "HEq" - ], - "value_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "HEq", - "id", - "PCP.Verifier.noConfusion" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": "Encoding of a verifier algorithm's answer. A halt decision is one bit; a query is the\nseparator followed by the address in binary. ", - "end_line": 45, - "is_class": false, - "kind": "definition", - "line": 41, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeAnswer", - "provenance": "lean", - "structural_dependencies": [], - "type": "Bool ⊕ ℕ → List PCP.Machine.Sym", - "type_dependencies": [ - "Sum", - "Bool", - "Nat", - "List", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Nat", - "PCP.Machine.encodeAnswer.match_1", - "List", - "PCP.Machine.Sym", - "List.cons", - "PCP.Machine.Sym.bit", - "List.nil", - "PCP.Machine.Sym.sep", - "PCP.Machine.ofBits", - "Nat.bits" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instFintypeSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "Fintype PCP.Machine.Sym", - "type_dependencies": [ - "Fintype", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Fintype.ofEquiv", - "PCP.Machine.Sym", - "Sum", - "Bool", - "Unit", - "instFintypeSum", - "Bool.fintype", - "PUnit.fintype", - "PCP.Machine.Sym.proxyTypeEquiv" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 79, - "is_class": false, - "kind": "definition", - "line": 79, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R} →\n {polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)} →\n {PolyTimeRel' : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg' : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable' : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel' R → Computable₂ R} →\n {polyTimeAlg_computable' :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg' alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck' :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg' alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel' (PCP.finiteWitnessCheck V)} →\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel', PolyTimeAlg := PolyTimeAlg',\n polyTimeRel_computable := polyTimeRel_computable',\n polyTimeAlg_computable := polyTimeAlg_computable',\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck' } →\n (PolyTimeRel = PolyTimeRel' → PolyTimeAlg = PolyTimeAlg' → P) → P", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk", - "id", - "PCP.CostModel.noConfusion" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "SizeOf PCP.Verifier", - "type_dependencies": [ - "SizeOf", - "PCP.Verifier" - ], - "value_dependencies": [ - "SizeOf.mk", - "PCP.Verifier", - "PCP.Verifier._sizeOf_1" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 107, - "is_class": false, - "kind": "theorem", - "line": 106, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_nonneg", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), 0 ≤ V.accProb x π", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "LE.le", - "Rat", - "Rat.instLE", - "OfNat.ofNat", - "Rat.instOfNat", - "PCP.Verifier.accProb" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → ℕ", - "type_dependencies": [ - "PCP.CostModel", - "Nat" - ], - "value_dependencies": [ - "PCP.CostModel" - ] - }, - { - "axioms": [], - "doc": "A bit string as tape symbols. ", - "end_line": 28, - "is_class": false, - "kind": "definition", - "line": 27, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.ofBits", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "List", - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "List", - "Bool", - "List.map", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ] - }, - { - "axioms": [], - "doc": "Run the decision tree against a proof oracle. ", - "end_line": 44, - "is_class": false, - "kind": "definition", - "line": 41, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "PCP.QueryTree.brecOn", - "Bool", - "PCP.QueryTree.eval._f" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "`V` is efficiently implementable in the model `M`. ", - "end_line": 115, - "is_class": false, - "kind": "definition", - "line": 114, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.Efficient", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → PCP.Verifier → Prop", - "type_dependencies": [ - "PCP.CostModel", - "PCP.Verifier" - ], - "value_dependencies": [ - "PCP.CostModel", - "PCP.Verifier", - "Exists", - "PCP.VerifierAlg", - "And", - "PCP.CostModel.PolyTimeAlg", - "PCP.Verifier.ImplementedBy" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "Bound on the number of proof **bits** read (bits, not larger proof symbols). ", - "end_line": 89, - "is_class": false, - "kind": "definition", - "line": 89, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.queries", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Prop) (x : ℕ) (x_1 : PCP.QueryTree x),\n (∀ (x : ℕ) (accept : Bool), motive x (PCP.QueryTree.leaf accept)) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d), motive d.succ (PCP.QueryTree.query a f t)) → motive x x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "Nat.succ", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "Nat.succ", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "Eq", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → PCP.CostModel → PCP.CostModel → Sort u", - "type_dependencies": [ - "PCP.CostModel" - ], - "value_dependencies": [ - "PCP.CostModel", - "PCP.CostModel.casesOn", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 50, - "is_class": false, - "kind": "theorem", - "line": 49, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep_zero", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (f : List Bool → Bool ⊕ ℕ) (as : List Bool),\n PCP.QueryTree.ofStep f 0 as =\n match f as with\n | Sum.inl b => PCP.QueryTree.leaf b\n | Sum.inr val => PCP.QueryTree.leaf false", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Eq", - "PCP.QueryTree", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.ofStep", - "PCP.QueryTree.ofStep.match_1", - "PCP.QueryTree.leaf", - "Bool.false" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Soundness: a polynomial-time relation is computable. ", - "end_line": 85, - "is_class": false, - "kind": "theorem", - "line": 85, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.polyTimeRel_computable", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (self : PCP.CostModel) (R : List Bool → List Bool → Bool), self.PolyTimeRel R → Computable₂ R", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.CostModel.PolyTimeRel", - "Computable₂", - "Primcodable.list", - "Primcodable.bool" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "Fair random bits used on inputs of length `n`. ", - "end_line": 87, - "is_class": false, - "kind": "definition", - "line": 87, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.randomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Closure: an efficiently implemented verifier with logarithmic randomness and a polynomial\nproof-length bound induces a polynomial-time NP checking relation.\n\nThis is the bridge between verifier efficiency and NP-checker efficiency.\nDischarging it means showing the model is closed under: enumerating `2 ^ O(log n)` random\nstrings, unfolding a constant-depth query tree, and indexing a polynomially long witness.\n\nThe budget hypothesis is `CanonicalRandomness`, **not** `LogRandomness`. With only an upper\nbound this field is not justifiable for any standard model: an arbitrary `f : ℕ → Bool` can be\nhidden in the budget (see `Verifier.LogRandomness`) and recovered by an elementary\nlength-measuring algorithm, so the field would assert that every unary language has a computable\nchecking relation. A canonical budget is determined by `a` and `b` and carries no such\ninformation. ", - "end_line": 104, - "is_class": false, - "kind": "theorem", - "line": 104, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.polyTimeRel_finiteWitnessCheck", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (self : PCP.CostModel) (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n self.PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → self.PolyTimeRel (PCP.finiteWitnessCheck V)", - "type_dependencies": [ - "PCP.CostModel", - "PCP.Verifier", - "PCP.VerifierAlg", - "Nat", - "Polynomial", - "Nat.instSemiring", - "PCP.CostModel.PolyTimeAlg", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "List", - "Bool", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.CostModel.PolyTimeRel", - "PCP.finiteWitnessCheck" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) →\n (x : ℕ) → Nat.below (motive := fun x => List Bool → PCP.QueryTree x) x → List Bool → PCP.QueryTree x", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Nat.below", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Nat.below", - "PCP.QueryTree", - "PCP.QueryTree.ofStep.match_3", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.ofStep.match_1", - "PCP.QueryTree.leaf", - "Bool.false", - "Nat.succ", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "PCP.QueryTree.query", - "PProd", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "List.cons", - "List.nil", - "Bool.true" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk", - "PCP.Verifier.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep._sunfold", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree.ofStep.match_3", - "PCP.QueryTree", - "PCP.QueryTree.ofStep.match_1", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.leaf", - "Bool.false", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "PCP.QueryTree.query", - "PCP.QueryTree.ofStep", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "List.cons", - "List.nil", - "Bool.true" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "`L` is in NP relative to the polynomial-time-checkability notion `P`. ", - "end_line": 43, - "is_class": false, - "kind": "definition", - "line": 41, - "module": "PCP.Complexity.NP", - "name": "PCP.InNP", - "provenance": "lean", - "structural_dependencies": [], - "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Prop", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Nonempty", - "PCP.NPCertificate" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 30, - "is_class": false, - "kind": "constructor", - "line": 30, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk", - "provenance": "lean", - "structural_dependencies": [ - "PCP.NPCertificate" - ], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", - "type_dependencies": [ - "Fintype", - "Eq", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "Finset.univ", - "True" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "SizeOf PCP.Machine.Sym", - "type_dependencies": [ - "SizeOf", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "SizeOf.mk", - "PCP.Machine.Sym", - "PCP.Machine.Sym._sizeOf_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 24, - "is_class": false, - "kind": "definition", - "line": 24, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.sep.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} → (t : PCP.Machine.Sym) → t.ctorIdx = 1 → motive PCP.Machine.Sym.sep → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 85, - "is_class": false, - "kind": "constructor", - "line": 85, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Verifier" - ], - "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "definition", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ], - "value_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk", - "PCP.CostModel.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.ProofOracle) (b : Bool), (PCP.QueryTree.leaf b).eval x_1 = b", - "type_dependencies": [ - "Nat", - "PCP.ProofOracle", - "Bool", - "Eq", - "PCP.QueryTree.eval", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval._unsafe_rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "PCP.QueryTree.eval.match_1", - "Bool", - "ite", - "Eq", - "Bool.true", - "instDecidableEqBool", - "PCP.QueryTree.eval._unsafe_rec" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (accept : Bool), (PCP.QueryTree.leaf accept).addresses = ∅", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "Finset", - "PCP.QueryTree.addresses", - "PCP.QueryTree.leaf", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (π : PCP.ProofOracle) (h_1 : (x : ℕ) → (b : Bool) → (x_1 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_1)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match d + 1, PCP.QueryTree.query a f t, π with\n | x, PCP.QueryTree.leaf b, x_1 => h_1 x b x_1\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_2 d a f t π", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.eval.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : PCP.ProofOracle) (d a : ℕ) (f t : PCP.QueryTree d),\n (PCP.QueryTree.query a f t).eval x = if x a = true then t.eval x else f.eval x", - "type_dependencies": [ - "PCP.ProofOracle", - "Nat", - "PCP.QueryTree", - "Eq", - "Bool", - "PCP.QueryTree.eval", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "ite", - "Bool.true", - "instDecidableEqBool" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b b_1 : Bool), (PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1) = (b = b_1)", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "The proof oracle determined by a finite witness: address `j` holds `w[j]`, and `false` at every\naddress beyond `w`. Padding with `false` is harmless exactly because a verifier satisfying\n`Verifier.ReadsBelow x N` never looks past address `N`. ", - "end_line": 201, - "is_class": false, - "kind": "definition", - "line": 198, - "module": "PCP.Verifier.Definition", - "name": "PCP.oracleOfWitness", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool → PCP.ProofOracle", - "type_dependencies": [ - "List", - "Bool", - "PCP.ProofOracle" - ], - "value_dependencies": [ - "List", - "Bool", - "Nat", - "List.getD", - "Bool.false" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "{a : ℕ} → PCP.QueryTree a → ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.rec", - "Bool", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "SizeOf.sizeOf", - "instSizeOfNat", - "Bool._sizeOf_inst" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval_congr.match_1_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀\n (motive :\n (x : ℕ) → (x_1 : PCP.QueryTree x) → (x_2 x_3 : PCP.ProofOracle) → (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → Prop)\n (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 x_3 : PCP.ProofOracle) (x_4 : ∀ a ∈ x_1.addresses, x_2 a = x_3 a),\n (∀ (x : ℕ) (accept : Bool) (x_5 x_6 : PCP.ProofOracle)\n (x_7 : ∀ a ∈ (PCP.QueryTree.leaf accept).addresses, x_5 a = x_6 a),\n motive x (PCP.QueryTree.leaf accept) x_5 x_6 x_7) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d) (π π' : PCP.ProofOracle)\n (h : ∀ a_1 ∈ (PCP.QueryTree.query a f t).addresses, π a_1 = π' a_1),\n motive (d + 1) (PCP.QueryTree.query a f t) π π' h) →\n motive x x_1 x_2 x_3 x_4", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "`alg` implements `V`: unfolding the algorithm reproduces `V`'s decision tree on every input and\nevery random string.\n\nThis ties the certificate to *this* verifier — its random-bit handling (`bitsOfFin`), its query\naddresses, and its decision rule all have to match. Proving some unrelated verifier efficient\nwould not discharge it. ", - "end_line": 64, - "is_class": false, - "kind": "definition", - "line": 56, - "module": "PCP.Complexity.CostModel", - "name": "PCP.Verifier.ImplementedBy", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → PCP.VerifierAlg → Prop", - "type_dependencies": [ - "PCP.Verifier", - "PCP.VerifierAlg" - ], - "value_dependencies": [ - "PCP.Verifier", - "PCP.VerifierAlg", - "List", - "Bool", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Eq", - "PCP.QueryTree", - "PCP.Verifier.queries", - "PCP.QueryTree.ofStep", - "PCP.bitsOfFin", - "List.nil", - "PCP.Verifier.run" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.below", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → {a : ℕ} → PCP.QueryTree a → Sort (max 1 u)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.rec", - "Bool", - "PUnit", - "PProd" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d),\n f.addresses.card < 2 ^ d →\n t.addresses.card < 2 ^ d →\n (insert a (f.addresses ∪ t.addresses)).card ≤ 1 + (f.addresses.card + t.addresses.card) →\n ¬(insert a (f.addresses ∪ t.addresses)).card < 2 ^ (d + 1) → False", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "LE.le", - "instLENat", - "Insert.insert", - "Finset", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Not", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses._unsafe_rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.addresses.match_1", - "Finset", - "Bool", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "PCP.QueryTree.addresses._unsafe_rec" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries),\n sizeOf { randomness := randomness, queries := queries, run := run } = 1 + sizeOf queries", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "SizeOf.sizeOf", - "PCP.Verifier", - "PCP.Verifier._sizeOf_inst", - "PCP.Verifier.mk", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "instSizeOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The relation defines `L`. ", - "end_line": 38, - "is_class": false, - "kind": "theorem", - "line": 38, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L) (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length self.witnessBound ∧ self.check x w = true", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Iff", - "Exists", - "And", - "LE.le", - "Nat", - "instLENat", - "List.length", - "Polynomial.eval", - "Nat.instSemiring", - "PCP.NPCertificate.witnessBound", - "Eq", - "PCP.NPCertificate.check", - "Bool.true" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "definition", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ], - "value_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk", - "PCP.CostModel.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "{a : ℕ} → PCP.QueryTree a → ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.casesOn", - "Bool" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "PCP.Verifier.rec", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "SizeOf.sizeOf", - "instSizeOfNat" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → PCP.Verifier → PCP.Verifier → Sort u", - "type_dependencies": [ - "PCP.Verifier" - ], - "value_dependencies": [ - "PCP.Verifier", - "PCP.Verifier.casesOn", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "HEq" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "SizeOf PCP.CostModel", - "type_dependencies": [ - "SizeOf", - "PCP.CostModel" - ], - "value_dependencies": [ - "SizeOf.mk", - "PCP.CostModel", - "PCP.CostModel._sizeOf_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → PCP.Machine.Sym → PCP.Machine.Sym → Sort u", - "type_dependencies": [ - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.Sym.casesOn", - "Bool", - "Eq" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym → ℕ", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.Sym.rec", - "Nat", - "Bool", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "SizeOf.sizeOf", - "Bool._sizeOf_inst" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "`V` reads only proof addresses below `N` on input `x`, whatever the randomness and whatever\nthe oracle answers. This is how \"a proof of polynomial length\" is expressed. ", - "end_line": 119, - "is_class": false, - "kind": "definition", - "line": 116, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.ReadsBelow", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → ℕ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "LT.lt", - "instLTNat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {b b_1 : Bool}, PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1 → b = b_1", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "recursor", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.CostModel → Sort u} →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n (t : PCP.CostModel) → motive t", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (witnessBound : Polynomial ℕ)\n (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true)\n (witnessBound_1 : Polynomial ℕ) (check_1 : List Bool → List Bool → Bool) (check_polyTime_1 : P check_1)\n (spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true),\n ({ witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 }) =\n (witnessBound = witnessBound_1 ∧ check = check_1)", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d) (addr_1 : ℕ) (onFalse_1 onTrue_1 : PCP.QueryTree d),\n (PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1) =\n (addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses._sunfold", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.addresses.match_1", - "Finset", - "Bool", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "PCP.QueryTree.addresses" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeTriple.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (t : List Bool × List Bool × List Bool),\n PCP.Machine.encodeTriple t =\n PCP.Machine.ofBits t.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.1 ++\n PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.2", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.encodeTriple", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.splitter", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "PCP.QueryTree.eval.match_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((val : ℕ) → motive (Sum.inr val)) → motive x", - "type_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr", - "Sum.casesOn" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (x : ℕ) (b : Bool) (x_1 : PCP.ProofOracle)\n (h_1 : (x : ℕ) → (b : Bool) → (x_2 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_2)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match x, PCP.QueryTree.leaf b, x_1 with\n | x, PCP.QueryTree.leaf b, x_2 => h_1 x b x_2\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_1 x b x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.eval.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instFintypeSym.match_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : Bool ⊕ Unit → Sort u_1) →\n (x : Bool ⊕ Unit) → ((a : Bool) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x", - "type_dependencies": [ - "Sum", - "Bool", - "Unit", - "Sum.inl", - "Sum.inr", - "PUnit.unit" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Unit", - "Sum.inl", - "Sum.inr", - "PUnit.unit", - "Sum.casesOn", - "PUnit.casesOn", - "Unit.unit" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = ↑(V.acceptingRandomness x π).card / 2 ^ V.randomness x.length", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Eq", - "Rat", - "PCP.Verifier.accProb", - "HDiv.hDiv", - "instHDiv", - "Rat.instDiv", - "Nat.cast", - "Rat.instNatCast", - "Finset.card", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.Verifier.acceptingRandomness", - "Rat.instPowNat", - "Rat.instOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 35, - "is_class": false, - "kind": "definition", - "line": 34, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 0 → ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "Bool", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "Bool", - "PCP.QueryTree.leaf", - "PCP.QueryTree.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} {witnessBound : Polynomial ℕ}\n {check : List Bool → List Bool → Bool} {check_polyTime : P check}\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true}\n {witnessBound_1 : Polynomial ℕ} {check_1 : List Bool → List Bool → Bool} {check_polyTime_1 : P check_1}\n {spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true},\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 } →\n witnessBound = witnessBound_1 ∧ check = check_1", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Acceptance probability is exactly `1` precisely when *every* random string accepts. This is\nthe bridge between the probabilistic statement of perfect completeness and the finite, decidable\ncondition used by the NP witness checker below. ", - "end_line": 188, - "is_class": false, - "kind": "theorem", - "line": 169, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_eq_one_iff", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = 1 ↔ ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval π = true", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Iff", - "Eq", - "Rat", - "PCP.Verifier.accProb", - "OfNat.ofNat", - "Rat.instOfNat", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "Bool.true" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 23, - "is_class": false, - "kind": "definition", - "line": 23, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {b b' : Bool} → PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b' → (b = b' → P) → P", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "id", - "PCP.Machine.Sym.noConfusion" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {t t' : PCP.Verifier} → t = t' → PCP.Verifier.noConfusionType P t t'", - "type_dependencies": [ - "PCP.Verifier", - "Eq", - "PCP.Verifier.noConfusionType" - ], - "value_dependencies": [ - "PCP.Verifier", - "Eq", - "Eq.ndrec", - "PCP.Verifier.noConfusionType", - "PCP.Verifier.casesOn", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "HEq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 31, - "is_class": false, - "kind": "theorem", - "line": 30, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_ofBits", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : List Bool), (PCP.Machine.ofBits x).length = x.length", - "type_dependencies": [ - "List", - "Bool", - "Eq", - "Nat", - "List.length", - "PCP.Machine.Sym", - "PCP.Machine.ofBits" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.rec" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (accept accept_1 : Bool), (PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1) = (accept = accept_1)", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "PCP.QueryTree", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "An oracle verifier.\n\nOn an input `x` of length `n` it draws `randomness n` fair bits and then runs the decision tree\nselected by that random string, making at most `queries` *bit* queries into the proof. ", - "end_line": 91, - "is_class": false, - "kind": "inductive", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Verifier.mk", - "PCP.Verifier" - ], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instInhabitedSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "Inhabited PCP.Machine.Sym", - "type_dependencies": [ - "Inhabited", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Inhabited.mk", - "PCP.Machine.Sym", - "PCP.Machine.instInhabitedSym.default" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep._unsafe_rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree.ofStep.match_3", - "PCP.QueryTree", - "PCP.QueryTree.ofStep.match_1", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.leaf", - "Bool.false", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "PCP.QueryTree.query", - "PCP.QueryTree.ofStep._unsafe_rec", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "List.cons", - "List.nil", - "Bool.true" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 222, - "is_class": false, - "kind": "theorem", - "line": 221, - "module": "PCP.Verifier.Definition", - "name": "PCP.length_witness_of_oracle", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (π : PCP.ProofOracle) (N : ℕ), (List.map π (List.range N)).length = N", - "type_dependencies": [ - "PCP.ProofOracle", - "Nat", - "Eq", - "List.length", - "Bool", - "List.map", - "List.range" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "recursor", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Verifier → Sort u} →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n (t : PCP.Verifier) → motive t", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "definition", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {t t' : PCP.CostModel} → t = t' → PCP.CostModel.noConfusionType P t t'", - "type_dependencies": [ - "PCP.CostModel", - "Eq", - "PCP.CostModel.noConfusionType" - ], - "value_dependencies": [ - "PCP.CostModel", - "Eq", - "Eq.ndrec", - "PCP.CostModel.noConfusionType", - "PCP.CostModel.casesOn", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq.refl" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "recursor", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n (t : PCP.NPCertificate P L) → motive t", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 214, - "is_class": false, - "kind": "theorem", - "line": 212, - "module": "PCP.Verifier.Definition", - "name": "PCP.finiteWitnessCheck_eq_true_iff", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w = true ↔\n ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Iff", - "Eq", - "PCP.finiteWitnessCheck", - "Bool.true", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "PCP.oracleOfWitness" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "DecidableEq PCP.Machine.Sym", - "type_dependencies": [ - "DecidableEq", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "PCP.Machine.instDecidableEqSym.decEq" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk._flat_ctor", - "provenance": "lean", - "structural_dependencies": [], - "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier" - ], - "value_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Binary relations on bit strings decidable in polynomial time. ", - "end_line": 81, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.PolyTimeRel", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → (List Bool → List Bool → Bool) → Prop", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool" - ], - "value_dependencies": [ - "PCP.CostModel" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a)", - "type_dependencies": [ - "DecidablePred", - "Finset", - "Eq", - "Membership.mem", - "SetLike.instMembership", - "Finset.instSetLike", - "Finset.filter", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 23, - "is_class": false, - "kind": "constructor", - "line": 23, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Machine.Sym" - ], - "type": "Bool → PCP.Machine.Sym", - "type_dependencies": [ - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.bitsOfFin.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), PCP.bitsOfFin k r = List.map (fun j => (↑r).testBit j) (List.range k)", - "type_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "Eq", - "List", - "Bool", - "PCP.bitsOfFin", - "List.map", - "Nat.testBit", - "Fin.val", - "List.range" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": "Encoding of an argument pair: `x`, separator, `w`. ", - "end_line": 35, - "is_class": false, - "kind": "definition", - "line": 33, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodePair", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool × List Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Prod", - "List", - "Bool", - "HAppend.hAppend", - "PCP.Machine.Sym", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b : Bool), PCP.Machine.Sym.bit b = PCP.Machine.Sym.sep → False", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_4", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b : Bool), PCP.Machine.Sym.sep = PCP.Machine.Sym.bit b → False", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.bit", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.ctorElim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n (ctorIdx : ℕ) →\n {a : ℕ} → (t : PCP.QueryTree a) → ctorIdx = t.ctorIdx → PCP.QueryTree.ctorElimType ctorIdx → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "PCP.QueryTree.ctorElimType" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "PCP.QueryTree.ctorElimType", - "PCP.QueryTree.casesOn", - "Bool", - "PULift.down", - "PCP.QueryTree.leaf", - "Eq.ndrec", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.splitter", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "PCP.QueryTree.addresses.match_1" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The relation is polynomial-time checkable. ", - "end_line": 36, - "is_class": false, - "kind": "theorem", - "line": 36, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.check_polyTime", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L), P self.check", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "PCP.NPCertificate.check" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 35, - "is_class": false, - "kind": "definition", - "line": 34, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {d : ℕ} →\n {accept : Bool} →\n {d' : ℕ} →\n {accept' : Bool} →\n d = d' → PCP.QueryTree.leaf accept ≍ PCP.QueryTree.leaf accept' → (d = d' → accept = accept' → P) → P", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "HEq", - "PCP.QueryTree", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [ - "Nat", - "Bool", - "Eq", - "HEq", - "PCP.QueryTree", - "PCP.QueryTree.leaf", - "id", - "PCP.QueryTree.noConfusion" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 36, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {d addr : ℕ} →\n {onFalse onTrue : PCP.QueryTree d} →\n {d' addr' : ℕ} →\n {onFalse' onTrue' : PCP.QueryTree d'} →\n d + 1 = d' + 1 →\n PCP.QueryTree.query addr onFalse onTrue ≍ PCP.QueryTree.query addr' onFalse' onTrue' →\n (d = d' → addr = addr' → onFalse ≍ onFalse' → onTrue ≍ onTrue' → P) → P", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "HEq", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "HEq", - "PCP.QueryTree.query", - "id", - "PCP.QueryTree.noConfusion" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V))\n (PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg_1 : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R)\n (polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)),\n ({ PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 }) =\n (PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1)", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 114, - "is_class": false, - "kind": "theorem", - "line": 109, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_le_one", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.accProb x π ≤ 1", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "LE.le", - "Rat", - "Rat.instLE", - "PCP.Verifier.accProb", - "OfNat.ofNat", - "Rat.instOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.rec" - ] - }, - { - "axioms": [], - "doc": "Encoding of an argument triple: input, random string, answers so far. ", - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 37, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeTriple", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool × List Bool × List Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Prod", - "List", - "Bool", - "HAppend.hAppend", - "PCP.Machine.Sym", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodeTriple._proof_1_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (t : List Bool × List Bool × List Bool),\n ¬t.1.length + (t.2.1.length + (t.2.2.length + 1) + 1) = t.1.length + t.2.1.length + t.2.2.length + 2 → False", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Not", - "Eq", - "Nat", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "List.length", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {t t' : PCP.Machine.Sym} → t = t' → PCP.Machine.Sym.noConfusionType P t t'", - "type_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "PCP.Machine.Sym.noConfusionType" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Eq.ndrec", - "PCP.Machine.Sym.noConfusionType", - "PCP.Machine.Sym.casesOn", - "Bool", - "Eq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.oracleOfWitness.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (w : List Bool) (j : ℕ), PCP.oracleOfWitness w j = w.getD j false", - "type_dependencies": [ - "List", - "Bool", - "Nat", - "Eq", - "PCP.oracleOfWitness", - "List.getD", - "Bool.false" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instFintypeSym.match_5", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : PCP.Machine.Sym → Sort u_1) →\n (x : PCP.Machine.Sym) → ((a : Bool) → motive (PCP.Machine.Sym.bit a)) → (Unit → motive PCP.Machine.Sym.sep) → motive x", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "Unit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "Unit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.casesOn", - "Unit.unit" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 31, - "is_class": false, - "kind": "theorem", - "line": 30, - "module": "PCP.Complexity.CostModel", - "name": "PCP.length_bitsOfFin", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), (PCP.bitsOfFin k r).length = k", - "type_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "Eq", - "List.length", - "Bool", - "PCP.bitsOfFin" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Soundness at `x` with error `s`: every proof is accepted with probability at most `s`. ", - "end_line": 134, - "is_class": false, - "kind": "definition", - "line": 133, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.SoundAt", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → ℚ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Rat" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Rat", - "PCP.ProofOracle", - "LE.le", - "Rat.instLE", - "PCP.Verifier.accProb" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "recursor", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n {a : ℕ} → (t : PCP.QueryTree a) → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} {accept accept_1 : Bool}, PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1 → accept = accept_1", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "PCP.QueryTree", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → ℕ", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Nat" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instReprSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "Repr PCP.Machine.Sym", - "type_dependencies": [ - "Repr", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Repr.mk", - "PCP.Machine.Sym", - "PCP.Machine.instReprSym.repr" - ] - }, - { - "axioms": [], - "doc": "A \"proxy type\" equivalent to `PCP.Machine.Sym` that is constructed from `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum`. See `PCP.Machine.Sym.proxyTypeEquiv` for the equivalence. (Generated by the `proxy_equiv%` elaborator.)", - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.proxyType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "Sum", - "Bool", - "Unit" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodePair._proof_1_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (p : List Bool × List Bool), ¬p.1.length + (p.2.length + 1) = p.1.length + p.2.length + 1 → False", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Not", - "Eq", - "Nat", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "List.length", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.ctorElimType", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → ℕ → Sort (max 1 u)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "cond", - "Nat.ble", - "PULift", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ] - }, - { - "axioms": [], - "doc": "One step of an adaptive verifier algorithm.\n\n`alg x r as` is given the input `x`, the random string `r` as a bit list, and the answer bits\nreceived so far (oldest first). It returns either `.inl b`, halting with decision `b`, or\n`.inr a`, naming the next proof address to query.\n\nThis is the algorithmic counterpart of `QueryTree`: a decision tree is what the algorithm *does*,\nthis is the algorithm itself, and a cost model measures the latter. ", - "end_line": 24, - "is_class": false, - "kind": "definition", - "line": 16, - "module": "PCP.Complexity.CostModel", - "name": "PCP.VerifierAlg", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (accept : Bool), sizeOf (PCP.QueryTree.leaf accept) = 1 + sizeOf d + sizeOf accept", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "SizeOf.sizeOf", - "PCP.QueryTree", - "PCP.QueryTree._sizeOf_inst", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "instSizeOfNat", - "Bool._sizeOf_inst" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {P_1 : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {t : PCP.NPCertificate P_1 L} →\n {P' : (List Bool → List Bool → Bool) → Prop} →\n {L' : PCP.Language} →\n {t' : PCP.NPCertificate P' L'} → P_1 = P' → L = L' → t ≍ t' → PCP.NPCertificate.noConfusionType P t t'", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Eq", - "HEq", - "PCP.NPCertificate.noConfusionType" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Eq", - "HEq", - "Eq.ndrec", - "PCP.NPCertificate.noConfusionType", - "PCP.NPCertificate.casesOn", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Bool.true", - "Eq.refl", - "eq_of_heq" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The random strings on which `V` accepts `x` given proof `π`. ", - "end_line": 99, - "is_class": false, - "kind": "definition", - "line": 97, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.acceptingRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "(V : PCP.Verifier) → (x : List Bool) → PCP.ProofOracle → Finset (Fin (2 ^ V.randomness x.length))", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Finset", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Finset.filter", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Eq", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "Bool.true", - "instDecidableEqBool", - "Finset.univ", - "Fin.fintype" - ] - }, - { - "axioms": [], - "doc": "Query proof address `addr`, then continue in `onFalse` or `onTrue`. ", - "end_line": 37, - "is_class": false, - "kind": "constructor", - "line": 36, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query", - "provenance": "lean", - "structural_dependencies": [ - "PCP.QueryTree" - ], - "type": "{d : ℕ} → ℕ → PCP.QueryTree d → PCP.QueryTree d → PCP.QueryTree (d + 1)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.rec" - ] - }, - { - "axioms": [], - "doc": "An equivalence between the \"proxy type\" `PCP.Machine.Sym.proxyType` and `PCP.Machine.Sym`. The proxy type is a reducible definition that represents the inductive type using `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum` (and whatever other inductive types appear within the inductive type), and the intended use is to define typeclass instances uses pre-existing instances on these. (Generated by the `proxy_equiv%` elaborator.)", - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.proxyTypeEquiv", - "provenance": "lean", - "structural_dependencies": [], - "type": "Bool ⊕ Unit ≃ PCP.Machine.Sym", - "type_dependencies": [ - "Equiv", - "Sum", - "Bool", - "Unit", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Equiv.mk", - "Sum", - "Bool", - "Unit", - "PCP.Machine.Sym", - "PCP.Machine.instFintypeSym.match_3", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.instFintypeSym.match_5", - "Sum.inl", - "Sum.inr", - "Unit.unit", - "Sum.casesOn", - "Eq", - "Eq.ndrec", - "Eq.refl", - "Eq.symm", - "PCP.Machine.Sym.casesOn" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.sep.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "sizeOf PCP.Machine.Sym.sep = 1", - "type_dependencies": [ - "Eq", - "Nat", - "SizeOf.sizeOf", - "PCP.Machine.Sym", - "PCP.Machine.Sym._sizeOf_inst", - "PCP.Machine.Sym.sep", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instInhabitedSym.default", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym", - "type_dependencies": [ - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "PCP.Machine.Sym.bit", - "Inhabited.default", - "Bool", - "instInhabitedBool" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "(x x_1 : PCP.Machine.Sym) → Decidable (x = x_1)", - "type_dependencies": [ - "PCP.Machine.Sym", - "Decidable", - "Eq" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.instDecidableEqSym.decEq.match_1", - "Decidable", - "Eq", - "Bool", - "dite", - "PCP.Machine.Sym.bit", - "instDecidableEqBool", - "Eq.ndrec", - "Decidable.isTrue", - "PCP.Machine.instDecidableEqSym.decEq._proof_1", - "Not", - "Decidable.isFalse", - "PCP.Machine.instDecidableEqSym.decEq._proof_2", - "PCP.Machine.Sym.sep", - "PCP.Machine.instDecidableEqSym.decEq._proof_3", - "PCP.Machine.instDecidableEqSym.decEq._proof_4", - "Unit", - "rfl" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d),\n sizeOf (PCP.QueryTree.query addr onFalse onTrue) = 1 + sizeOf d + sizeOf addr + sizeOf onFalse + sizeOf onTrue", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "SizeOf.sizeOf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree._sizeOf_inst", - "PCP.QueryTree.query", - "instSizeOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 30, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {P_1 : Sort u} →\n {witnessBound : Polynomial ℕ} →\n {check : List Bool → List Bool → Bool} →\n {check_polyTime : P check} →\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true} →\n {witnessBound' : Polynomial ℕ} →\n {check' : List Bool → List Bool → Bool} →\n {check_polyTime' : P check'} →\n {spec' :\n ∀ (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound' ∧ check' x w = true} →\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound', check := check', check_polyTime := check_polyTime',\n spec := spec' } →\n (witnessBound = witnessBound' → check = check' → P_1) → P_1", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk", - "id", - "PCP.NPCertificate.noConfusion", - "Eq.refl", - "heq_of_eq" - ] - }, - { - "axioms": [], - "doc": "A decision tree over a Boolean proof oracle, of depth at most `d`.\n\n`leaf` may occur at any depth, so `QueryTree d` is \"at most `d` queries\", not \"exactly `d`\". ", - "end_line": 37, - "is_class": false, - "kind": "inductive", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree", - "provenance": "lean", - "structural_dependencies": [ - "PCP.QueryTree.leaf", - "PCP.QueryTree.query", - "PCP.QueryTree" - ], - "type": "ℕ → Type", - "type_dependencies": [ - "Nat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "(x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n PCP.QueryTree.below (motive := fun x x_2 => PCP.ProofOracle → Bool) x_1 → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.eval.match_1", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "ite", - "Eq", - "Bool.true", - "instDecidableEqBool", - "PProd" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Soundness: a polynomial-time verifier algorithm is computable. This rules out a degenerate\nmodel that counts an arbitrary, even noncomputable, step function as efficient; such a model\nwould let a \"verifier\" decide the language outright. ", - "end_line": 89, - "is_class": false, - "kind": "theorem", - "line": 89, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.polyTimeAlg_computable", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (self : PCP.CostModel) (alg : PCP.VerifierAlg), self.PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2", - "type_dependencies": [ - "PCP.CostModel", - "PCP.VerifierAlg", - "PCP.CostModel.PolyTimeAlg", - "Computable", - "Prod", - "List", - "Bool", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.list", - "Primcodable.bool", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "Eq", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "The decision tree used on input `x` and random string `r`. ", - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 91, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.run", - "provenance": "lean", - "structural_dependencies": [], - "type": "(self : PCP.Verifier) → (x : List Bool) → Fin (2 ^ self.randomness x.length) → PCP.QueryTree self.queries", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.queries" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries)\n (randomness_1 : ℕ → ℕ) (queries_1 : ℕ)\n (run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1),\n ({ randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 }) =\n (randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1)", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "And", - "HEq" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.brecOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} → (t : PCP.QueryTree a) → ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PProd", - "PCP.QueryTree.brecOn.go" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → {a : ℕ} → PCP.QueryTree a → {a' : ℕ} → PCP.QueryTree a' → Sort u", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.casesOn", - "Bool", - "Eq", - "HEq" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval_congr._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x)\n (f :\n PCP.QueryTree.below (motive := fun x x_2 =>\n ∀ (x_3 x_4 : PCP.ProofOracle), (∀ a ∈ x_2.addresses, x_3 a = x_4 a) → x_2.eval x_3 = x_2.eval x_4) x_1)\n (x_2 x_3 : PCP.ProofOracle), (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → x_1.eval x_2 = x_1.eval x_3", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.eval" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.eval", - "PCP.QueryTree.eval_congr.match_1_1", - "PCP.QueryTree.leaf", - "rfl", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "of_eq_true", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "Eq.trans", - "Or", - "True", - "Finset.mem_insert._simp_1", - "congr", - "congrArg", - "eq_self", - "Finset.mem_union._simp_1", - "true_or", - "PProd", - "Eq.mpr", - "id", - "Iff.mpr", - "Not", - "Classical.or_iff_not_imp_left", - "False.elim", - "ite", - "Bool.true", - "instDecidableEqBool", - "congrFun'", - "ite_congr" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep.match_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : ℕ → List Bool → Sort u_1) →\n (x : ℕ) →\n (x_1 : List Bool) →\n ((as : List Bool) → motive 0 as) → ((n : ℕ) → (as : List Bool) → motive n.succ as) → motive x x_1", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "OfNat.ofNat", - "instOfNatNat", - "Nat.succ" - ], - "value_dependencies": [ - "Nat", - "List", - "Bool", - "OfNat.ofNat", - "instOfNatNat", - "Nat.succ", - "Nat.casesOn" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "(x : ℕ) → (x_1 : PCP.QueryTree x) → PCP.QueryTree.below x_1 → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "Finset", - "PCP.QueryTree.addresses.match_1", - "Bool", - "PCP.QueryTree.leaf", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "PProd" - ] - }, - { - "axioms": [], - "doc": "Encoding of a Boolean result. ", - "end_line": 48, - "is_class": false, - "kind": "definition", - "line": 47, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeBool", - "provenance": "lean", - "structural_dependencies": [], - "type": "Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "Bool", - "List", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Bool", - "List.cons", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "List.nil" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {a : ℕ} →\n {t : PCP.QueryTree a} → {a' : ℕ} → {t' : PCP.QueryTree a'} → a = a' → t ≍ t' → PCP.QueryTree.noConfusionType P t t'", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HEq", - "PCP.QueryTree.noConfusionType" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HEq", - "Eq.ndrec", - "PCP.QueryTree.noConfusionType", - "PCP.QueryTree.casesOn", - "Bool", - "Eq.refl", - "HEq.refl", - "eq_of_heq" - ] - }, - { - "axioms": [], - "doc": "The tape alphabet: a bit, or a separator between arguments.\n\nA separator is needed because the machine takes one input list, while our relations and algorithms\ntake two or three bit strings. Self-delimiting encodings would avoid it at the cost of a length\nprefix; a separator symbol is the simpler convention and is fixed here once. ", - "end_line": 25, - "is_class": false, - "kind": "inductive", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym" - ], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "name": "PCP.Algebraic.PolynomialLine.exists_polynomial_of_hasLowDegreeLines_finite", - "module": "PCP.Algebraic.PolynomialLineCharacterization", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_polynomial_of_hasLowDegreeLines_finite {σ : Type*} [Finite σ] {d : ℕ}\n (f : (σ → F) → F) (hcard : 2 * d < Fintype.card F)\n (hf : HasLowDegreeLines d f) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ d ∧ ∀ x, eval x P = f x", - "line": 163, - "end_line": 181, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.Hadamard.exists_field_function_of_average_rejectionRate", - "module": "PCP.Algebraic.HadamardRowDecoding", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_field_function_of_average_rejectionRate (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (H : (σ → F) → Coefficients t r → ZMod 2) :\n ∃ f : (σ → F) → F,\n relativeDistance (fun p : (σ → F) × Coefficients t r => H p.1 p.2)\n (encodeFunction r (fun x => ρ (f x))) ≤ 28 * averageRejectionRate hr H ∧\n BinaryLagrangeConstraint.homogeneousDistance hr H (fun x => encode r (ρ (f x))) ≤\n 28 * averageRejectionRate hr H", - "line": 123, - "end_line": 135, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryStandardLocalCorrection.failure_le", - "module": "PCP.Algebraic.BinaryStandardLocalCorrection", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem failure_le (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (hζ : StandardLocalCorrection.GoodNodes c ζ)\n (Q : MvPolynomial σ F) (hQ : Q.totalDegree ≤ c)\n (H : (σ → F) → Coefficients t 1 → ZMod 2) (u : σ → F) :\n relativeDistance\n (fun vw : (σ → F) × (Fin t → ZMod 2) => correct c ζ ρ H u vw.1 vw.2)\n (fun vw => linearEncode (ρ (MvPolynomial.eval u Q)) vw.2) ≤\n (c + 1 : ℕ) * BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) H\n (fun x => encode 1 (ρ (MvPolynomial.eval x Q)))", - "line": 89, - "end_line": 99, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.Hadamard.selfCorrect_failure_le", - "module": "PCP.Algebraic.HadamardCorrection", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem selfCorrect_failure_le [Fintype V] [DecidableEq W] (E : V →+ W)\n (w : V → W) (P : V) :\n relativeDistance (selfCorrect w P) (fun _ => E P) ≤ 2 * relativeDistance w E\nSECTION VARIABLE DECLARATIONS:\nvariable {V W : Type*} [AddCommGroup V] [AddCommGroup W]", - "line": 34, - "end_line": 43, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries_length_le", - "module": "PCP.Algebraic.EncodedLineLowDegreeTest", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem queries_length_le (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (nodes : Fin (c + 1) → F) (ζ : F) (s : Sample F σ m c t r) :\n (queries hr ρ nodes ζ s).length ≤ 2 * r + 2 * c + 12", - "line": 72, - "end_line": 78, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.queries_length_le", - "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem queries_length_le (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (s : TestSample F n m c t) :\n (queries ρ nodes ζ H s).length ≤ 6 * c + 19", - "line": 91, - "end_line": 99, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eq_interpolation", - "module": "PCP.Algebraic.GeneratorLowDegreeTest", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem check_eq_interpolation (ζ : F) (f : (σ → F) → F) (u v : σ → F) :\n check c ζ f u v = LagrangeConstraint.check (nodes c ζ) f u v 0", - "line": 55, - "end_line": 58, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.WeightedConstraint.correction_satisfies", - "module": "PCP.Algebraic.WeightedConstraintSoundness", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem correction_satisfies (a w : I → F) (ha : ∀ i, a i ≠ 0)\n (f : V → F)\n (hsmall : (2 * (Fintype.card I : ℚ) + 3) * Fintype.card I *\n rejectionRate a w f < 1) (x v : V) :\n correction a w f x = predict a w (correction a w f) x v", - "line": 136, - "end_line": 176, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BivariateColumnSelection.exists_good_columns", - "module": "PCP.Algebraic.BivariateColumnSelection", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_good_columns (f : F × F → F) (R C : F → Polynomial F) {ε : ℚ} {d : ℕ}\n (hR : relativeDistance f (fun z => (R z.2).eval z.1) ≤ ε)\n (hC : relativeDistance f (fun z => (C z.1).eval z.2) ≤ ε)\n (hε : ε ≤ 1 / 100) (hcard : 20 * d ≤ Fintype.card F) :\n ∃ a : Fin (10 * d) ↪ F,\n ∀ i, relativeDistance (fun y => (R y).eval (a i)) (C (a i)).eval ≤ 1 / 10", - "line": 94, - "end_line": 105, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BerlekampWelchCertificate.exists_certificate_of_good_specializations", - "module": "PCP.Algebraic.BerlekampWelchCertificate", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_certificate_of_good_specializations\n (a : I → F) (ha : Function.Injective a) (columns : I → Polynomial F)\n (hcolumns : ∀ i, (columns i).natDegree ≤ D)\n (S : Finset F) (hcard : (d + 2 * e + 2) * D < S.card)\n (hgood : ∀ y ∈ S, ∃ s : Polynomial F, s.natDegree ≤ d ∧\n (BerlekampWelch.errors a (fun i => (columns i).eval y) s).card ≤ e)\n (hnodes : d + e < Fintype.card I) :\n ∃ E N : MvPolynomial (Fin 2) F, E ≠ 0 ∧ E.degreeOf 0 ≤ e ∧\n N.degreeOf 0 ≤ d + e ∧ E.degreeOf 1 ≤ (d + 2 * e + 1) * D ∧\n N.degreeOf 1 ≤ (d + 2 * e + 1) * D ∧\n ∀ i, rowPolynomial N (a i) = columns i * rowPolynomial E (a i)", - "line": 237, - "end_line": 257, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BivariateCleanRectangle.exists_nonzero_columns", - "module": "PCP.Algebraic.BivariateCleanRectangle", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_nonzero_columns (a : I → F) (ha : Function.Injective a)\n (E : MvPolynomial (Fin 2) F) (hne : E ≠ 0) (hx : E.degreeOf 0 ≤ e)\n (hsize : ∀ j, E.degreeOf j < Fintype.card F)\n (hcard : d + e < Fintype.card I) :\n ∃ b : Fin (d + 1) ↪ I, ∀ i, rowPolynomial E (a (b i)) ≠ 0", - "line": 241, - "end_line": 261, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BivariateAgreementFromRectangle.exists_nearby_polynomial", - "module": "PCP.Algebraic.BivariateAgreementFromRectangle", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_nearby_polynomial (a : I → F) (ha : Function.Injective a)\n (C : I → Polynomial F) (hC : ∀ i, (C i).natDegree ≤ d)\n (R : F → Polynomial F) (hR : ∀ y, (R y).natDegree ≤ d)\n (b : Fin (d + 1) → I) (hb : Function.Injective b) (B : Finset F)\n (hclean : ∀ y ∈ B, ∀ j, (R y).eval (a (b j)) = (C (b j)).eval y)\n {ε : ℚ} (hcol : ∀ i, relativeDistance (fun y => (R y).eval (a i)) (C i).eval ≤ ε)\n (hB : ε * Fintype.card F + d < B.card) :\n ∃ P : MvPolynomial (Fin 2) F, (∀ j, P.degreeOf j ≤ d) ∧\n (∀ i, rowPolynomial P (a i) = C i) ∧\n relativeDistance R (columnPolynomial P) ≤\n Fintype.card I * ε / ((Fintype.card I : ℚ) - d) ∧\n relativeDistance (fun z : F × F => (R z.2).eval z.1)\n (fun z => MvPolynomial.eval ![z.1, z.2] P) ≤\n Fintype.card I * ε / ((Fintype.card I : ℚ) - d)", - "line": 174, - "end_line": 198, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BivariateAgreementBoost.distance_le_four_mul", - "module": "PCP.Algebraic.BivariateAgreementBoost", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem distance_le_four_mul (f : F × F → F) (R C : F → Polynomial F)\n (hR : ∀ y, (R y).natDegree ≤ d) (hC : ∀ x, (C x).natDegree ≤ d)\n (P : MvPolynomial (Fin 2) F) (hP : ∀ j, P.degreeOf j ≤ d) {ε ρ : ℚ}\n (hrows : relativeDistance f (fun z => (R z.2).eval z.1) ≤ ε)\n (hcols : relativeDistance f (fun z => (C z.1).eval z.2) ≤ ε)\n (hnear : relativeDistance f (fun z => MvPolynomial.eval ![z.1, z.2] P) ≤ ρ)\n (hsmall : ρ + ε + 2 * ((d : ℚ) / Fintype.card F) ≤ 1 / 3) :\n relativeDistance f (fun z => MvPolynomial.eval ![z.1, z.2] P) ≤ 4 * ε", - "line": 105, - "end_line": 117, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.PointLineTest.distance_decoded_correction_le", - "module": "PCP.Algebraic.PointLineCorrection", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem distance_decoded_correction_le (f : (σ → F) → F)\n (table : LineTable F σ c) :\n relativeDistance f (correction (decodedTable c f)) ≤ 2 * rejectionRate f table", - "line": 142, - "end_line": 146, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.PointLineTest.rejectionAt_le_four_mul", - "module": "PCP.Algebraic.PointLineParameterError", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem rejectionAt_le_four_mul (c : ℕ) (f : (σ → F) → F) (t : F)\n (hcard : 3 * c ≤ Fintype.card F) :\n rejectionAt c f t ≤ 4 * rejectionRate f (decodedTable c f)", - "line": 151, - "end_line": 161, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BivariateCrossingSoundness.crossing_bestApproximation_eq", - "module": "PCP.Algebraic.BivariateCrossingSoundness", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem crossing_bestApproximation_eq (hd : 0 < d)\n (hq : 1000 * d ^ 3 ≤ Fintype.card F) (f : F × F → F)\n (x₀ y₀ : F) {ε ε' : ℚ} (hε : ε ≤ 1 / 100)\n (hrows : relativeDistance f (fun z =>\n (bestApproximation d (fun y => f (z.1, y))).val.eval z.2) ≤ ε)\n (hcols : relativeDistance f (fun z =>\n (bestApproximation d (fun x => f (x, z.2))).val.eval z.1) ≤ ε)\n (hlrow : relativeDistance (fun y => f (x₀, y)) (fun y =>\n (bestApproximation d (fun x => f (x, y))).val.eval x₀) ≤ ε')\n (hlcol : relativeDistance (fun x => f (x, y₀)) (fun x =>\n (bestApproximation d (fun y => f (x, y))).val.eval y₀) ≤ ε')\n (hsmall : 5 * ε + ε' + 2 * ((d : ℚ) / Fintype.card F) < 1 / 2) :\n (bestApproximation d (fun y => f (x₀, y))).val.eval y₀ =\n (bestApproximation d (fun x => f (x, y₀))).val.eval x₀", - "line": 32, - "end_line": 54, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.PointLineEndpointConsistency.endpoint_error_le", - "module": "PCP.Algebraic.PointLineEndpointConsistency", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem endpoint_error_le (hd : 0 < d)\n (hq : 1000 * d ^ 3 ≤ Fintype.card F) (f : (σ → F) → F) (u : σ → F) (t : F)\n {ε : ℚ} (hε : 0 < ε) (hεsmall : ε ≤ 1 / 100)\n (hsmall : 6 * ε + 2 * ((d : ℚ) / Fintype.card F) < 1 / 2) :\n relativeDistance (fun v => (decodedTable d f (u, v)).val.eval t)\n (fun v => correction (decodedTable d f) (point u v t)) ≤\n 8 * (4 * rejectionRate f (decodedTable d f) + 1 / Fintype.card F) / ε", - "line": 108, - "end_line": 126, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.RuledSurface.hasLowDegreeLines_of_endpoint_bounds", - "module": "PCP.Algebraic.RuledSurfaceRigidity", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem hasLowDegreeLines_of_endpoint_bounds\n (hd : 0 < d) (hq : 1000 * d ^ 3 ≤ Fintype.card F)\n (f g : (σ → F) → F) (T : LineTable F σ d) {η γ δ ℓ ε : ℚ}\n (hnear : relativeDistance f g ≤ η)\n (hendpoint : ∀ u t, fraction (fun v =>\n (T (u, v)).val.eval t ≠ g (point u v t)) ≤ γ)\n (hwhole : rejectionRate f T ≤ δ)\n (hfixed : ∀ t, relativeDistance (fun uv : Seed F σ => f (point uv.1 uv.2 t))\n (fun uv => (T uv).val.eval t) ≤ ℓ)\n (hεpos : 0 < ε) (hε : ε ≤ 1 / 100)\n (hsmall : 6 * ε + 2 * ((d : ℚ) / Fintype.card F) < 1 / 2)\n (hbudget : (2 * (γ + η) + δ + ℓ + γ + 2 / Fintype.card F) / ε + γ < 1) :\n HasLowDegreeLines d g", - "line": 74, - "end_line": 91, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.PointLineConstants.field_bounds", - "module": "PCP.Algebraic.PointLineConstants", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem field_bounds {d q : ℕ} (hd : 0 < d) (hq : fieldFactor * d ^ 3 ≤ q) :\n 1000 * d ^ 3 ≤ q ∧ 3 * d ≤ q ∧ 2 * d < q ∧ 1000000 ≤ q ∧\n 6 * agreementError + 2 * ((d : ℚ) / q) < 1 / 2", - "line": 32, - "end_line": 50, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.PointLineTest.exists_close_degree_zero", - "module": "PCP.Algebraic.PointLineConstant", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_close_degree_zero (f : (σ → F) → F) (table : LineTable F σ 0) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ 0 ∧\n relativeDistance f (fun x => MvPolynomial.eval x P) ≤ 2 * rejectionRate f table", - "line": 160, - "end_line": 164, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.eval_zero_agreement_le", - "module": "PCP.Algebraic.PolynomialDistance", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem eval_zero_agreement_le (p : MvPolynomial (Fin m) 𝔽) (hp : p ≠ 0) :\n relativeAgreement (fun x => eval x p) 0 ≤ (p.totalDegree : ℚ) / Fintype.card 𝔽", - "line": 29, - "end_line": 32, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate_le_add_errors", - "module": "PCP.Algebraic.BinaryDifferenceConsistency", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem rejectionRate_le_add_errors (hr : 1 ≤ r)\n (f f' : (σ → F) → Coefficients t r → ZMod 2)\n (g g' : ((σ ⊕ σ) → F) → Coefficients t r → ZMod 2) :\n rejectionRate hr f' g' ≤ rejectionRate hr f g +\n 2 * BinaryLagrangeConstraint.homogeneousDistance hr f f' +\n BinaryLagrangeConstraint.homogeneousDistance hr g g'\nActive section variables: {F σ : Type*} [Field F] [Fintype F] [Fintype σ] [DecidableEq σ] {t r D : ℕ}.", - "line": 204, - "end_line": 233, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate_lower_bound", - "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem rejectionRate_lower_bound\n (hq : 2 * c < Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ x, (Q x).natDegree ≤ r)\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) (H : Finset F) (hH : H.Nonempty)\n (f : (Fin n → F) → F) (P : MvPolynomial (Fin n) F)\n (hvalue : ∀ x, (Q x).eval (f x) = eval x P)\n (M : MvPolynomial (Fin n ⊕ Fin n) F) (hP : P.totalDegree ≤ D) (hM : M.totalDegree ≤ D)\n (hdecode : c * m ^ c ≤ D) (hnot : ¬ VanishesOn H P)\n (p : (Fin n → F) → Coefficients t r → ZMod 2)\n (M' : CertificatePoint F n → Coefficients t 1 → ZMod 2) (A : Auxiliary F n m c t)\n {δP δM : ℚ} (hp : HadamardDerivedOracle.fullDistance ρ p f ≤ δP)\n (hm : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) M'\n (fun x => encode 1 (ρ (eval x M))) ≤ δM) :\n (1 - ((D * H.card : ℕ) : ℚ) / Fintype.card F) / 2 ≤\n (1 + 2 * BinaryLocalCorrection.soundnessConstant c) *\n (rejectionRate ρ Q hQ nodes ζ H p M' A + 2 * δP) + 2 * δM +\n (D : ℚ) / (Fintype.card F - 1 : ℕ)", - "line": 246, - "end_line": 277, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Machine.NPTableau.exists_accepts_iff", - "module": "PCP.Complexity.NPTableau", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_accepts_iff (x : List Bool) :\n (∃ a : Assignment h q x, Accepts h q x a) ↔\n ∃ w : List Bool, w.length ≤ q.eval x.length ∧ R x w = true", - "line": 142, - "end_line": 152, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Machine.TableauCells.step_represents", - "module": "PCP.Complexity.TableauCells", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem step_represents {tm : FinTM2} {B : ℕ} {p p' : Prefix tm} {s s' : Cells tm B}\n {c : tm.Cfg} (hr : Represents p s c) (hl : Linked p s) (hst : Step p p' s s')\n (hb : ∀ k, ((keepStep tm.step c).stk k).length ≤ B) :\n Represents p' s' (keepStep tm.step c)", - "line": 155, - "end_line": 168, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Reduction.FiniteDomainConstraints.satisfiable_iff", - "module": "PCP.Reduction.FiniteDomainConstraints", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem satisfiable_iff (R : C → (Fin d → Fin a) → Bool) (s : C → Fin d → V) :\n (∃ b, LocalHolds (relation R) (scope s) b) ↔ ∃ x : V → Fin a, Holds R s x", - "line": 119, - "end_line": 125, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Reduction.NAEThreeColor.colorable_iff", - "module": "PCP.Reduction.NAEThreeColor", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem colorable_iff (Q : C → Fin 3 → Literal V) :\n (graph Q).Colorable 3 ↔ ∃ a : V → Bool, ∀ e, NAE (fun i => (Q e i).eval a)", - "line": 241, - "end_line": 247, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Verifier.Reduction.clog_eval_add_two_le", - "module": "PCP.Verifier.ReductionResources", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem clog_eval_add_two_le (p : Polynomial ℕ) (n : ℕ) :\n Nat.clog 2 (p.eval n + 2) ≤\n p.natDegree * Nat.clog 2 (n + 2) + Nat.clog 2 (p.eval 1 + 2)", - "line": 35, - "end_line": 49, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_constraints", - "module": "PCP.Algebraic.ThreeColorGrid", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem colorable_iff_exists_constraints [CharP F 2] {ω : F}\n (hω : IsPrimitiveRoot ω 3) (H : Finset F) (G : SimpleGraph (σ → H)) :\n G.Colorable 3 ↔ ∃ P : MvPolynomial σ F,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n VanishesOn H (validPolynomial P) ∧\n VanishesOn H (properPolynomial (edgeExtension H G) (differencePolynomial P))", - "line": 117, - "end_line": 132, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.HadamardDerivedOracle.answer_encode", - "module": "PCP.Algebraic.HadamardDerivedOracle", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem answer_encode (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (P : Polynomial F) (hP : P.natDegree ≤ r) (u : F)\n (L : Coefficients t 1) (R : Coefficients t r) :\n answer ρ P hP (encode r (ρ u)) L R = encode 1 (ρ (P.eval u)) L", - "line": 58, - "end_line": 65, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true", - "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_proof_test_eq_true (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : Function.Injective nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) {ω : F} (hω : IsPrimitiveRoot ω 3)\n (H : Finset F) (hH : H.Nonempty) (G : SimpleGraph (Fin n → H)) (hG : G.Colorable 3)\n (hdegree : 5 * ((H.card - 1) * n) < m ^ c) :\n ∃ π : Proof F n m c t, ∀ s, test ρ nodes ζ H G π s = true", - "line": 101, - "end_line": 128, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le_log_add_one", - "module": "PCP.Algebraic.ThreeColorParameterChoice", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem volume_le_log_add_one (N : ℕ) : volume N ≤ 32 * (Nat.clog 2 N + 1)", - "line": 79, - "end_line": 82, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate_eq", - "module": "PCP.Algebraic.ThreeColorFullFieldSampling", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem rejectionRate_eq (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → H))\n (π : Proof F n m c t) :\n rejectionRate ρ nodes ζ H G π = retention (Fintype.card F) *\n ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", - "line": 160, - "end_line": 165, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorBinaryVerifier.verification_guarantees", - "module": "PCP.Algebraic.ThreeColorBinaryVerifier", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem verification_guarantees (G : SimpleGraph V)\n (eV : V ≃ Fin (Fintype.card V)", - "line": 250, - "end_line": 260, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates", - "module": "PCP.Algebraic.ThreeColorGrid", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem colorable_iff_exists_certificates [CharP F 2] {ω : F}\n (hω : IsPrimitiveRoot ω 3) (H : Finset F) (hH : H.Nonempty)\n (G : SimpleGraph (σ → H)) :\n G.Colorable 3 ↔ ∃ (P : MvPolynomial σ F)\n (MVal : MvPolynomial (σ ⊕ σ) F)\n (MProp : MvPolynomial ((σ ⊕ σ) ⊕ (σ ⊕ σ)) F),\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n MVal.totalDegree ≤ 3 * ((H.card - 1) * Fintype.card σ) ∧\n MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) ∧\n IsCertificate H (validPolynomial P) MVal ∧\n IsCertificate H\n (properPolynomial (edgeExtension H G) (differencePolynomial P)) MProp", - "line": 135, - "end_line": 160, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "axioms": [], - "doc": null, - "end_line": 69, - "is_class": false, - "kind": "def", - "line": 67, - "module": "PCP.Algebraic.SetMultilinear", - "name": "PCP.Algebraic.SetMultilinear.decode", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nnoncomputable def decode : MvPolynomial (Variables m c) R →+* Polynomial R :=\n MvPolynomial.eval₂Hom Polynomial.C\n (fun ij => Polynomial.X ^ ((ij.2 : ℕ) * m ^ (ij.1 : ℕ)))", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 98, - "is_class": false, - "kind": "theorem", - "line": 89, - "module": "PCP.Algebraic.SetMultilinear", - "name": "PCP.Algebraic.SetMultilinear.decode_encode", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem decode_encode (P : Polynomial R) (hP : P.natDegree < m ^ c) :\n decode m c (encode m c P) = P", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 121, - "is_class": false, - "kind": "theorem", - "line": 116, - "module": "PCP.Algebraic.SetMultilinear", - "name": "PCP.Algebraic.SetMultilinear.encode_injective_on", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem encode_injective_on :\n Set.InjOn (encode m c : Polynomial R → MvPolynomial (Variables m c) R)\n {P | P.natDegree < m ^ c}", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 72, - "is_class": false, - "kind": "theorem", - "line": 62, - "module": "PCP.Algebraic.PointLineConstants", - "name": "PCP.Algebraic.PointLineConstants.rigidity_budget", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem rigidity_budget {q : ℕ} (hq : 1000000 ≤ q) {δ : ℚ} (hδ : δ ≤ smallError) :\n (2 * (endpointError δ q + 2 * δ) + δ + 4 * δ + endpointError δ q + 2 / q) /\n agreementError + endpointError δ q < 1", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 134, - "is_class": false, - "kind": "theorem", - "line": 114, - "module": "PCP.Algebraic.EncodedLineLowDegreeTest", - "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test_eval", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem test_eval (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : Function.Injective nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ)\n (P : MvPolynomial σ F) (hP : P.totalDegree < m ^ c) (s : Sample F σ m c t r) :\n test hr ρ nodes ζ (fun x => encode r (ρ (MvPolynomial.eval x P)))\n (honestTable (m := m) (c := c) ρ P) s = true", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 59, - "is_class": false, - "kind": "def", - "line": 45, - "module": "PCP.Algebraic.BinaryLocalCorrection", - "name": "PCP.Algebraic.BinaryLocalCorrection.run", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nnoncomputable def run (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → Coefficients t 1 → ZMod 2)\n (H : (σ → F) → RowOracle F m c t) (a b : σ → F) (z : Fˣ)\n (v : InnerPoint F m c) (w : Fin t → ZMod 2) (s : InnerSeed F m c t) :\n Option (ZMod 2) := by\n classical\n exact if BinaryLowDegreeTest.test (le_refl 1) ρ nodes (H b) s then\n if BinaryStandardLocalCorrection.correct c ζ ρ (H b)\n (SetMultilinear.evaluationPoint m c (z : F)) v w =\n f (point a b (z : F)) (homogeneousIndex (le_refl 1) w) then\n some (BinaryStandardLocalCorrection.correct c ζ ρ (H b)\n (SetMultilinear.evaluationPoint m c 0) v w)\n else none\n else none", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 67, - "is_class": false, - "kind": "def", - "line": 62, - "module": "PCP.Algebraic.BinaryLocalCorrection", - "name": "PCP.Algebraic.BinaryLocalCorrection.sample", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nnoncomputable def sample (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → Coefficients t 1 → ZMod 2)\n (H : (σ → F) → RowOracle F m c t) (a : σ → F)\n (s : Sample F σ m c t) : Option (ZMod 2) :=\n run ρ nodes ζ f H a s.1 s.2.1 s.2.2.1.1 s.2.2.1.2 s.2.2.2", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 112, - "is_class": false, - "kind": "theorem", - "line": 58, - "module": "PCP.Algebraic.ThreeColorVerifierSoundness", - "name": "PCP.Algebraic.ThreeColorVerifier.colorable_of_rejection_lt", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem colorable_of_rejection_lt\n (hc : 1 ≤ c)\n (hq : PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) {ω : F} (hω : IsPrimitiveRoot ω 3)\n (H : Finset F) (hH : H.Nonempty)\n (hgrid : 100 * (c * m ^ c) * H.card ≤ Fintype.card F)\n (hdegree : (H.card - 1) * n ≤ c * m ^ c)\n (G : SimpleGraph (Fin n → H)) (π : Proof F n m c t)\n (hsmall : rejectionRate ρ nodes ζ H G π < ThreeColorSoundnessBudget.gap c) :\n G.Colorable 3", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 41, - "is_class": false, - "kind": "theorem", - "line": 39, - "module": "PCP.Complexity.ReferenceNPConverse", - "name": "PCP.ReferenceNP.inNP_iff_mem", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem inNP_iff_mem {L : Complexity.Language} :\n PCP.InNP Machine.PolyTimeRel L ↔ L ∈ Complexity.NP", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 292, - "is_class": false, - "kind": "theorem", - "line": 246, - "module": "PCP.Algebraic.PointLineCrossing", - "name": "PCP.Algebraic.PointLineCrossing.crossing_eq_of_nearby_polynomial", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem crossing_eq_of_nearby_polynomial (f : F × F → F)\n (R C : F → Polynomial F)\n (hR : ∀ x, (R x).natDegree ≤ d) (hC : ∀ y, (C y).natDegree ≤ d)\n (P : MvPolynomial (Fin 2) F) (hP : ∀ i, P.degreeOf i ≤ d)\n (x₀ y₀ : F) {ε ρ ε' : ℚ}\n (hrows : relativeDistance f (fun z => (R z.1).eval z.2) ≤ ε)\n (hcols : relativeDistance f (fun z => (C z.2).eval z.1) ≤ ε)\n (hnear : relativeDistance f (fun z => MvPolynomial.eval ![z.1, z.2] P) ≤ ρ)\n (hlrow : relativeDistance (fun y => f (x₀, y)) (fun y => (C y).eval x₀) ≤ ε')\n (hlcol : relativeDistance (fun x => f (x, y₀)) (fun x => (R x).eval y₀) ≤ ε')\n (hminR : ∀ p : Polynomial F, p.natDegree ≤ d →\n relativeDistance (fun y => f (x₀, y)) (R x₀).eval ≤\n relativeDistance (fun y => f (x₀, y)) p.eval)\n (hminC : ∀ p : Polynomial F, p.natDegree ≤ d →\n relativeDistance (fun x => f (x, y₀)) (C y₀).eval ≤\n relativeDistance (fun x => f (x, y₀)) p.eval)\n (hradius : 2 * (ε' + ε + ρ + (d : ℚ) / Fintype.card F) <\n 1 - (d : ℚ) / Fintype.card F) : (R x₀).eval y₀ = (C y₀).eval x₀", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 89, - "is_class": false, - "kind": "theorem", - "line": 27, - "module": "PCP.Algebraic.CandidateCrossing", - "name": "PCP.Algebraic.CandidateCrossing.crossing_eq", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem crossing_eq (hd : 0 < d) (hq : 1000 * d ^ 3 ≤ Fintype.card F)\n (M : F × F → F) (R C : F → Polynomial F)\n (hR : ∀ y, (R y).natDegree ≤ d) (hC : ∀ z, (C z).natDegree ≤ d)\n (y₀ z₀ : F) {ε : ℚ} (hε : ε ≤ 1 / 100)\n (hrows : relativeDistance M (fun yz => (R yz.1).eval yz.2) ≤ ε)\n (hcols : relativeDistance M (fun yz => (C yz.2).eval yz.1) ≤ ε)\n (hrow : relativeDistance (fun z => M (y₀, z)) (fun z => (C z).eval y₀) ≤ ε)\n (hcol : relativeDistance (fun y => M (y, z₀)) (fun y => (R y).eval z₀) ≤ ε)\n (hown : relativeDistance (fun z => M (y₀, z)) (R y₀).eval ≤ ε)\n (hmin : ∀ p : Polynomial F, p.natDegree ≤ d →\n relativeDistance (fun y => M (y, z₀)) (C z₀).eval ≤\n relativeDistance (fun y => M (y, z₀)) p.eval)\n (hsmall : 6 * ε + 2 * ((d : ℚ) / Fintype.card F) < 1 / 2) :\n (R y₀).eval z₀ = (C z₀).eval y₀", - "type_dependencies": [], - "value_dependencies": [] - } - ] + "PCP.Algebraic.PointLineConstants.smallError" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.cubic.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F], PCP.Algebraic.HadamardDerivedOracle.cubic = Polynomial.X ^ 3 - 1", + "type_dependencies": [ + "CommRing", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "HSub.hSub", + "instHSub", + "Polynomial.instSub", + "CommRing.toRing", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.semiring", + "Polynomial.X", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "Polynomial.instOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The rest of the grid verifier, with its one primary bit supplied as an argument. ", + "end_line": 48, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t →\n PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t → ZMod 2 → Option (ZMod 2 × ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "Option", + "Prod" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "Sum", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every fixed column is controlled by the same global error plus the row\ncode's distance deficit. ", + "end_line": 83, + "is_class": false, + "kind": "theorem", + "line": 72, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.transverse_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {I : Type u_1} {J : Type u_2} {A : Type u_3} [inst : Fintype I] [inst_1 : Fintype J] [inst_2 : DecidableEq A]\n (R S : I → J → A) {τ : ℚ},\n 0 ≤ τ →\n (∀ (i : I), R i ≠ S i → 1 - τ ≤ PCP.Algebraic.relativeDistance (R i) (S i)) →\n ∀ (j : J),\n (PCP.Algebraic.relativeDistance (fun i => R i j) fun i => S i j) ≤\n (PCP.Algebraic.relativeDistance (fun p => R p.1 p.2) fun p => S p.1 p.2) + τ", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Rat", + "LE.le", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "Ne", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "PCP.Algebraic.relativeDistance", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) (a_2 : PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.color a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "One variable for each possible digit in each block. ", + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.Variables", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete finite-domain constraint graph, using the fixed-arity Boolean compiler. ", + "end_line": 129, + "is_class": false, + "kind": "definition", + "line": 127, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.graph", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {a d : ℕ} →\n (C → (Fin d → Fin a) → Bool) →\n (C → Fin d → V) →\n SimpleGraph\n (PCP.Reduction.NAEThreeColor.Vertex\n (PCP.Reduction.FiniteBooleanConstraints.Variable (PCP.Reduction.FiniteDomainConstraints.Variable V a)\n (PCP.Reduction.FiniteDomainConstraints.Constraint V C)\n (PCP.Reduction.FiniteDomainConstraints.arity a d) ⊕\n PCP.Reduction.FiniteBooleanConstraints.Clause (PCP.Reduction.FiniteDomainConstraints.Constraint V C)\n (PCP.Reduction.FiniteDomainConstraints.arity a d))\n (PCP.Reduction.FiniteBooleanConstraints.Clause (PCP.Reduction.FiniteDomainConstraints.Constraint V C)\n (PCP.Reduction.FiniteDomainConstraints.arity a d) ×\n Bool))", + "type_dependencies": [ + "Nat", + "Fin", + "Bool", + "SimpleGraph", + "PCP.Reduction.NAEThreeColor.Vertex", + "Sum", + "PCP.Reduction.FiniteBooleanConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteBooleanConstraints.Clause", + "Prod" + ], + "value_dependencies": [ + "Nat", + "Fin", + "Bool", + "PCP.Reduction.FiniteBooleanConstraints.graph", + "PCP.Reduction.FiniteDomainConstraints.Variable", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "PCP.Reduction.FiniteDomainConstraints.arity", + "PCP.Reduction.FiniteDomainConstraints.relation", + "PCP.Reduction.FiniteDomainConstraints.scope" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.PointLineTest.correction.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] {inst_4 : DecidableEq σ} [inst_5 : DecidableEq σ]\n (table table_1 : PCP.Algebraic.PointLineTest.LineTable F σ c),\n table = table_1 →\n ∀ (x x_1 : σ → F),\n x = x_1 → PCP.Algebraic.PointLineTest.correction table x = PCP.Algebraic.PointLineTest.correction table_1 x_1", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "Eq", + "PCP.Algebraic.PointLineTest.correction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every seed reads at most 187 actual bits of the indexed proof. ", + "end_line": 178, + "is_class": false, + "kind": "theorem", + "line": 173, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V)\n (s : PCP.Algebraic.ThreeColorBinaryVerifier.Seed (Fintype.card V))\n (eV : optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V)),\n (PCP.Algebraic.ThreeColorBinaryVerifier.queries G s eV).length ≤ 187", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "Fintype.card", + "optParam", + "Equiv", + "Fin", + "Fintype.equivFin", + "LE.le", + "Nat", + "instLENat", + "List.length", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "PCP.Algebraic.ThreeColorBinaryVerifier.queries", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardRowDecoding", + "name": "PCP.Algebraic.Hadamard.averageRejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} {t r : ℕ} [inst : Fintype ι] (hr : 1 ≤ r)\n (H H_1 : ι → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n H = H_1 → PCP.Algebraic.Hadamard.averageRejectionRate hr H = PCP.Algebraic.Hadamard.averageRejectionRate hr H_1", + "type_dependencies": [ + "Nat", + "Fintype", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Eq", + "Rat", + "PCP.Algebraic.Hadamard.averageRejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Theorem B.1, with the witness bundled as an actual binary linear map. ", + "end_line": 318, + "is_class": false, + "kind": "theorem", + "line": 313, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.exists_linearMap_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (H : (ι → ZMod 2) → ZMod 2),\n ∃ L, PCP.Algebraic.relativeDistance H ⇑L ≤ PCP.Algebraic.BLR.rejectionProbability H", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Exists", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap.instFunLike", + "PCP.Algebraic.BLR.rejectionProbability", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.queries_length_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (s : PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t),\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1) s.2.2.1.1\n s.2.2.1.2.1 s.2.2.1.2.2.1 s.2.1 s.2.2.1.2.2.2).length ≤\n 3 * c + 9 →\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)\n s.2.2.2.1 s.2.2.2.2.1 s.2.2.2.2.2.1 s.2.1 s.2.2.2.2.2.2).length ≤\n 3 * c + 9 →\n ¬(PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1) s.2.2.1.1\n s.2.2.1.2.1 s.2.2.1.2.2.1 s.2.1 s.2.2.1.2.2.2).length +\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ\n (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1) s.2.2.2.1 s.2.2.2.2.1 s.2.2.2.2.2.1 s.2.1\n s.2.2.2.2.2.2).length +\n 1 ≤\n 6 * c + 19 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The honest restricted table returns the requested value on every sample. ", + "end_line": 244, + "is_class": false, + "kind": "theorem", + "line": 240, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.correct_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F) (a b : σ → F) (z : Fˣ),\n PCP.Algebraic.LineTableLocalCorrection.correct (fun b => (PCP.Algebraic.PolynomialLine.restrict a b) P)\n (fun x => (MvPolynomial.eval x) P) a b z =\n some ((MvPolynomial.eval a) P)", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Eq", + "Option", + "PCP.Algebraic.LineTableLocalCorrection.correct", + "DFunLike.coe", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.PolynomialLine.restrict", + "MvPolynomial.eval", + "Option.some" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The linear map on the paper's actual domain of polynomials of degree at most `d`. ", + "end_line": 203, + "is_class": false, + "kind": "definition", + "line": 200, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] →\n (m : ℕ) →\n [NeZero m] →\n (c d : ℕ) → ↥(Polynomial.degreeLE R ↑d) →ₗ[R] MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Subtype", + "Polynomial", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearMap.comp", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.SetMultilinear.boundedEncode._proof_1", + "PCP.Algebraic.SetMultilinear.encode", + "Submodule.subtype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 435, + "is_class": false, + "kind": "theorem", + "line": 431, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 1 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.validCert π.validLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Sum", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Taking a coordinate slice does not increase its individual degree. ", + "end_line": 196, + "is_class": false, + "kind": "theorem", + "line": 170, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.natDegree_axisRestrict_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : DecidableEq σ] (u : σ → F) (i : σ) (P : MvPolynomial σ F),\n ((PCP.Algebraic.PointLineCrossing.axisRestrict u i) P).natDegree ≤ MvPolynomial.degreeOf i P", + "type_dependencies": [ + "Field", + "DecidableEq", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.PointLineCrossing.axisRestrict", + "MvPolynomial.degreeOf" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "DecidableEq PCP.Machine.Sym", + "type_dependencies": [ + "DecidableEq", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "PCP.Machine.instDecidableEqSym.decEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 165, + "is_class": false, + "kind": "definition", + "line": 165, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Relabel all colors so the palette vertices have their literal numeric colors. ", + "end_line": 204, + "is_class": false, + "kind": "definition", + "line": 200, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.normalize", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) →\n (PCP.Reduction.NAEThreeColor.graph Q).Coloring (Fin 3) → (PCP.Reduction.NAEThreeColor.graph Q).Coloring (Fin 3)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "SimpleGraph.Coloring.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Reduction.NAEThreeColor.palette", + "RelHom.instFunLike", + "SimpleGraph.Adj", + "SimpleGraph.completeGraph", + "PCP.Reduction.NAEThreeColor.normalize._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.test._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Zero rejection characterizes exactly the codewords. ", + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 72, + "module": "PCP.Algebraic.HadamardSoundness", + "name": "PCP.Algebraic.Hadamard.testRejectionRate_eq_zero_iff_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n PCP.Algebraic.Hadamard.testRejectionRate hr H = 0 ↔ ∃ x, H = ⇑(PCP.Algebraic.Hadamard.encode r x)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "Iff", + "Eq", + "Rat", + "PCP.Algebraic.Hadamard.testRejectionRate", + "Rat.instOfNat", + "Exists", + "Fin", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Below the selected exponent, an admissible predecessor cannot hold the input. ", + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.predecessor_volume_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ},\n 2 < PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n (PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1) *\n 2 ^ (PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1) <\n Nat.clog 2 N", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The internal randomness of a correction call, with the requested label separated out. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → Type u_3 → [Monoid F] → ℕ → ℕ → ℕ → Type (max (max u_2 u_3) u_2)", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "For valid colors, the edge cubic equation is exactly inequality. ", + "end_line": 70, + "is_class": false, + "kind": "theorem", + "line": 59, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.sub_cube_eq_one_iff_ne", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [CharP F 2] {a b : F}, a ^ 3 = 1 → b ^ 3 = 1 → ((a - b) ^ 3 = 1 ↔ a ≠ b)", + "type_dependencies": [ + "Field", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "Iff", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_mul_right", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (c : ℚ) (f : α → ℚ),\n (PCP.Algebraic.BLR.average fun x => f x * c) = PCP.Algebraic.BLR.average f * c", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "HMul.hMul", + "instHMul", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate_nodes._simp_1_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b ≠ 0) = (a ≠ b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "Ne", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 61, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Algebraic.Hadamard", + "name": "_private.PCP.Algebraic.Hadamard.0.PCP.Algebraic.Hadamard.add_nonzero_eq_zero_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : ZMod 2), b ≠ 0 → (a + b = 0 ↔ a ≠ 0)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Ne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Iff", + "Eq", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.exists_program._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) [DecidableEq h.tm.Λ]\n [DecidableEq h.tm.σ] [(k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)],\n PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk →\n ∀ {k a : ℕ} (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (P : PCP.Lang.Prog)\n (A C D : ℕ) (x : List Bool),\n PCP.Lang.listSize (List.map Bool.toNat x) ≤ 2 * x.length →\n ¬PCP.Lang.listSize (List.map Bool.toNat x) + 1 ≤ 2 * x.length + 1 → False", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Lang.Prog", + "LE.le", + "instLENat", + "PCP.Lang.listSize", + "List.map", + "Bool.toNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "Not", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.satisfies_represents._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {T : ℕ} {B : ℕ} {initial : tm.Cfg} (j : ℕ), j + 1 < T + 1 → ¬j < T → False", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "LT.lt", + "instLTNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The small-rejection binary guarantee for arbitrary finite coordinate types.\nIt is derived from the proved generic field theorem, without transporting or\nassuming a binary tester's soundness. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.exists_close_of_small_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {c t r : ℕ},\n 2 * c < Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (a : Fin (c + 1) → F),\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes a →\n ∀ (H : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n (112 * ↑(c + 2) + 4) * PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H ≤\n PCP.Algebraic.GeneratorLowDegreeTest.smallError c →\n ∃ Q,\n Q.totalDegree ≤ c ∧\n PCP.Algebraic.relativeDistance (fun p => H p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ ((MvPolynomial.eval x) Q)) ≤\n (112 * (↑c + 2) + 60) * PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr H fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) Q)))) ≤\n (112 * (↑c + 2) + 60) * PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "Rat.instMul", + "Rat.instAdd", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.GeneratorLowDegreeTest.smallError", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Option (ZMod 2) → Option (ZMod 2) → Option (ZMod 2) → Sort u_1) (x x_1 x_2 : Option (ZMod 2))\n (h_1 : (p m₀ mZ : ZMod 2) → motive (some p) (some m₀) (some mZ))\n (h_2 : (x x_3 x_4 : Option (ZMod 2)) → motive x x_3 x_4),\n (∀ (p m₀ mZ : ZMod 2), x = some p → x_1 = some m₀ → x_2 = some mZ → False) →\n (match x, x_1, x_2 with\n | some p, some m₀, some mZ => h_1 p m₀ mZ\n | x, x_4, x_5 => h_2 x x_4 x_5) =\n h_2 x x_1 x_2", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "False", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 270, + "is_class": false, + "kind": "definition", + "line": 269, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} → [Field F] → [Fintype F] → [DecidableEq F] → [Fintype σ] → [DecidableEq σ] → ℕ → F → ((σ → F) → F) → ℚ", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Rat" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "Pi.instFintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 53, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_add", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (f g : α → ℚ),\n (PCP.Algebraic.BLR.average fun x => f x + g x) = PCP.Algebraic.BLR.average f + PCP.Algebraic.BLR.average g", + "type_dependencies": [ + "Fintype", + "Rat", + "Eq", + "PCP.Algebraic.BLR.average", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 157, + "is_class": false, + "kind": "theorem", + "line": 143, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.seed_card_ratio", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F],\n ↑(Fintype.card (PCP.Algebraic.ThreeColorVerifier.Sample F n m c t)) /\n ↑(Fintype.card (PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t)) =\n PCP.Algebraic.ThreeColorFullFieldSampling.retention (Fintype.card F)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Pi.instFintype", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawBranchSeed", + "PCP.Algebraic.ThreeColorFullFieldSampling.rawBranchSeedFintype", + "PCP.Algebraic.ThreeColorFullFieldSampling.retention" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The finite tableau accepts exactly the checker's true result for each bounded witness. ", + "end_line": 139, + "is_class": false, + "kind": "theorem", + "line": 126, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.exists_rows_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) {x w : List Bool},\n w.length ≤ Polynomial.eval x.length q →\n ((∃ rows,\n PCP.Machine.ComputationTableau.Satisfies h.tm (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (PCP.Machine.NPTableau.input h x w)\n (PCP.Machine.NPTableau.output h true) rows) ↔\n R x w = true)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Iff", + "Exists", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.NPTableau.timePoly", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.ComputationTableau.Row", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "PCP.Machine.NPTableau.spacePoly", + "PCP.Machine.ComputationTableau.Satisfies", + "PCP.Machine.NPTableau.input", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 81, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n IsPrimitiveRoot ζ (Fintype.card F - 1) → ∀ (i : Fin (c + 1)), PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i ≠ 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Ne", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Binary relations on bit strings decidable in polynomial time. ", + "end_line": 81, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.PolyTimeRel", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → (List Bool → List Bool → Bool) → Prop", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool" + ], + "value_dependencies": [ + "PCP.CostModel" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 448, + "is_class": false, + "kind": "theorem", + "line": 444, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_three", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 3 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.properCert π.properLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Sum", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (f : (ι → ZMod 2) → ℚ) (a : ι → ZMod 2),\n PCP.Algebraic.BLR.fourier f a = PCP.Algebraic.BLR.average fun x => f x * PCP.Algebraic.BLR.character a x", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Rat", + "Eq", + "PCP.Algebraic.BLR.fourier", + "PCP.Algebraic.BLR.average", + "Pi.instFintype", + "ZMod.fintype", + "PCP.Algebraic.BLR.fourier._proof_1", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.character" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 442, + "is_class": false, + "kind": "theorem", + "line": 437, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_two", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 2 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.difference π.differenceLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Sum", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "Decidable.byContradiction", + "LE.le", + "instLENat", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 234, + "is_class": false, + "kind": "theorem", + "line": 229, + "module": "PCP.Algebraic.PointLineCrossing", + "name": "PCP.Algebraic.PointLineCrossing.eval_columnPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (P : MvPolynomial (Fin 2) F) (x y : F),\n Polynomial.eval x (PCP.Algebraic.PointLineCrossing.columnPolynomial P y) = (MvPolynomial.eval ![x, y]) P", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Polynomial.eval", + "CommSemiring.toSemiring", + "PCP.Algebraic.PointLineCrossing.columnPolynomial", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.gridSeed.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c t r : ℕ} (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.gridSeed s = (s.1, s.2.1)", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "Prod.mk", + "Fin", + "Prod", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 27, + "is_class": false, + "kind": "theorem", + "line": 24, + "module": "PCP.Algebraic.BLR", + "name": "_private.PCP.Algebraic.BLR.0.PCP.Algebraic.BLR.binary_cases", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : ZMod 2), b = 0 ∨ b = 1", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Or", + "Eq", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.polyTimeMap_constant._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The exponent vector of a basis image. ", + "end_line": 159, + "is_class": false, + "kind": "definition", + "line": 157, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents", + "provenance": "lean", + "structural_dependencies": [], + "type": "(m : ℕ) → [NeZero m] → (c : ℕ) → ℕ → PCP.Algebraic.SetMultilinear.Variables m c →₀ ℕ", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.sum", + "Fin", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "Finsupp.single", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.eval_le_coefficientSum._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (n : ℕ), ¬n ≤ n + 2 → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t : ℕ} {σ : Type u_2} (x : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n ((x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).2.1, (x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).2.2.1,\n ((x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).2.2.2.1, (x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).1),\n (x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).2.2.2.2) =\n ((x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).2.1, (x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).2.2.1,\n ((x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).2.2.2.1, (x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).1),\n (x.2.2.1.2, x.1, x.2.1, x.2.2.1.1, x.2.2.2).2.2.2.2)", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Prod.mk", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.answer._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 49, + "is_class": false, + "kind": "theorem", + "line": 45, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.natDegree_series_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommRing R] {k : ℕ} (v : Fin (k + 1) → R),\n (PCP.Algebraic.BerlekampWelchCertificate.series v).natDegree ≤ k", + "type_dependencies": [ + "CommRing", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.BerlekampWelchCertificate.series" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Formal polynomial recovery. The exponent bound is essential. ", + "end_line": 98, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c → (PCP.Algebraic.SetMultilinear.decode m c) ((PCP.Algebraic.SetMultilinear.encode m c) P) = P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "LinearMap", + "RingHom.id", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 157, + "is_class": false, + "kind": "theorem", + "line": 156, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.assemble_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {k : ℕ}, PCP.Algebraic.BerlekampWelchCertificate.assemble 0 = 0", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BerlekampWelchCertificate.assemble", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Polynomial", + "CommSemiring.toSemiring", + "Zero.toOfNat0", + "Pi.instZero", + "Polynomial.instZero", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Explicit constructor and coefficient indexing relative to the field coordinates. ", + "end_line": 66, + "is_class": false, + "kind": "definition", + "line": 62, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "(N : ℕ) → PCP.Algebraic.ThreeColorBinaryVerifier.Address N ≃ Fin (PCP.Algebraic.ThreeColorBinaryVerifier.proofLength N)", + "type_dependencies": [ + "Nat", + "Equiv", + "PCP.Algebraic.ThreeColorBinaryVerifier.Address", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorQueryIndex.equiv", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.size", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Nat.choose", + "PCP.Algebraic.ThreeColorBinaryVerifier.fieldIndex", + "PCP.Algebraic.BooleanCoefficientIndex.affineEquiv", + "PCP.Algebraic.BooleanCoefficientIndex.cubicEquiv" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.smallError_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "0 < PCP.Algebraic.PointLineConstants.smallError", + "type_dependencies": [ + "LT.lt", + "Rat", + "Rat.instLT", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.PointLineConstants.smallError" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Substitute powers of `Y` for the block variables, before evaluating `Y`. ", + "end_line": 69, + "is_class": false, + "kind": "definition", + "line": 66, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] → (m c : ℕ) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R →+* Polynomial R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial.eval₂Hom", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.SetMultilinear.Variables", + "Polynomial.commSemiring", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.semiring", + "Polynomial.X", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 75, + "is_class": false, + "kind": "definition", + "line": 75, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.var.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {P : Sort u} →\n {a : V} →\n {a_1 : Bool} →\n {a' : V} →\n {a'_1 : Bool} →\n PCP.Reduction.NAEThreeColor.Literal.var a a_1 = PCP.Reduction.NAEThreeColor.Literal.var a' a'_1 →\n (a ≍ a' → a_1 = a'_1 → P) → P", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.var", + "HEq" + ], + "value_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.var", + "HEq", + "id", + "PCP.Reduction.NAEThreeColor.Literal.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.field_bounds._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d q : ℕ}, 20 * d ≤ q → 1000000 ≤ q → ¬3 * d ≤ q → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The primary oracle uses degree-`r` queries; certificate queries keep their original types. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 61, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.Query", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 32, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.queries_length", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (c : ℕ) (ζ : F)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (u v : σ → F) (w : Fin t → ZMod 2),\n (PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ u v w).length = c + 1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "List.length", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 3", + "type_dependencies": [ + "LE.le", + "Nat", + "instLENat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Encoding an ordinary finite graph gives the intended completeness statement. ", + "end_line": 63, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.completeAt_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (G : SimpleGraph (Fin N)) [inst : DecidableRel G.Adj],\n G.Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CompleteAt (PCP.Algebraic.ThreeColorEncoding.encode G)", + "type_dependencies": [ + "Nat", + "SimpleGraph", + "Fin", + "DecidableRel", + "SimpleGraph.Adj", + "SimpleGraph.Colorable", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.CompleteAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "PCP.Algebraic.ThreeColorEncoding.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.retention.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (q : ℕ), PCP.Algebraic.ThreeColorFullFieldSampling.retention q = ((↑q - 1) / ↑q) ^ 4", + "type_dependencies": [ + "Nat", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorFullFieldSampling.retention", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Nat.cast", + "Rat.instNatCast", + "OfNat.ofNat", + "Rat.instOfNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.parameterShiftEquiv._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (t : F) (s : ((σ → F) × (σ → F)) × F),\n ((((s.1.1 + (t - s.2) • s.1.2, s.1.2), s.2).1.1 -\n (t - ((s.1.1 + (t - s.2) • s.1.2, s.1.2), s.2).2) • ((s.1.1 + (t - s.2) • s.1.2, s.1.2), s.2).1.2,\n ((s.1.1 + (t - s.2) • s.1.2, s.1.2), s.2).1.2),\n ((s.1.1 + (t - s.2) • s.1.2, s.1.2), s.2).2) =\n s", + "type_dependencies": [ + "Field", + "Prod", + "Eq", + "Prod.mk", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Prod.fst", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.bitsOfFin.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), PCP.bitsOfFin k r = List.map (fun j => (↑r).testBit j) (List.range k)", + "type_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "List", + "Bool", + "PCP.bitsOfFin", + "List.map", + "Nat.testBit", + "Fin.val", + "List.range" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A uniform parameter shifted by one has the same error against any constant line table. ", + "end_line": 112, + "is_class": false, + "kind": "theorem", + "line": 100, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.consecutive_error_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : Fintype σ] [inst_3 : DecidableEq σ]\n {A : Type u_3} [inst_4 : DecidableEq A] (f : (σ → F) → A) (b : (σ → F) × (σ → F) → A),\n (PCP.Algebraic.relativeDistance (fun s => f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 (s.2 + 1))) fun s =>\n b s.1) =\n PCP.Algebraic.relativeDistance (fun s => f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2)) fun s => b s.1", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "Prod.snd", + "HAdd.hAdd", + "instHAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.clog_eval_add_two_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (n : ℕ), ¬0 < n + 2 → False", + "type_dependencies": [ + "Nat", + "Not", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangle_iff._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {a : Prop}, (¬¬a) = a", + "type_dependencies": [ + "Eq", + "Not" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Encoding of an argument pair: `x`, separator, `w`. ", + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodePair", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool × List Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Prod", + "List", + "Bool", + "HAppend.hAppend", + "PCP.Machine.Sym", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.secondLabelEquiv._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_2} {W : Type u_1} (x : (V × W) × V),\n ((((x.2, x.1.1), x.1.2).1.2, ((x.2, x.1.1), x.1.2).2), ((x.2, x.1.1), x.1.2).1.1) =\n ((((x.2, x.1.1), x.1.2).1.2, ((x.2, x.1.1), x.1.2).2), ((x.2, x.1.1), x.1.2).1.1)", + "type_dependencies": [ + "Prod", + "Eq", + "Prod.mk", + "Prod.snd", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The algebraic conditions in Corollary 2.10, separate from degree bounds. ", + "end_line": 59, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.IsCertificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → Finset R → MvPolynomial σ R → MvPolynomial (σ ⊕ σ) R → Prop", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum" + ], + "value_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum", + "And", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n PCP.Algebraic.ThreeColorBinaryVerifier.randomBits N =\n PCP.Algebraic.ThreeColorSeedSize.rawBits\n (PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent N))\n (PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent N)) 4\n (PCP.Algebraic.ThreeColorParameters.binaryDimension (PCP.Algebraic.ThreeColorParameterChoice.exponent N))", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits", + "PCP.Algebraic.ThreeColorSeedSize.rawBits", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The sufficient upper bound on point-versus-line rejection. ", + "end_line": 22, + "is_class": false, + "kind": "definition", + "line": 21, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.smallError", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℚ", + "type_dependencies": [ + "Rat" + ], + "value_dependencies": [ + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 187, + "is_class": false, + "kind": "theorem", + "line": 180, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.represents_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} (c : tm.Cfg) (hs : PCP.Machine.StackSupported tm c.stk),\n (∀ (k : tm.K), (c.stk k).length ≤ B) →\n PCP.Machine.TableauCells.Represents (PCP.Machine.FiniteTransitionTable.prefixRow tm c hs)\n (PCP.Machine.TableauCells.encodeCells B c hs) c", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "LE.le", + "instLENat", + "List.length", + "PCP.Machine.TableauCells.Represents", + "PCP.Machine.FiniteTransitionTable.prefixRow", + "PCP.Machine.TableauCells.encodeCells" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The derived read is reliable at every fixed requested affine query. ", + "end_line": 77, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.answer_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (hP : P.natDegree ≤ r) (u : F) (H : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.HadamardDerivedOracle.answer ρ P hP H L) fun x =>\n (PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval u P))) L) ≤\n 2 * PCP.Algebraic.relativeDistance H ⇑(PCP.Algebraic.Hadamard.encode r (ρ u))", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A derived answer has an explicit fresh self-correction seed. ", + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.answer", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : CommRing F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (P : Polynomial F) →\n P.natDegree ≤ r →\n (PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardDerivedOracle.answer._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.Hadamard.selfCorrect", + "Pi.addCommGroup", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.HadamardComposition.query" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Nearest row and column polynomials agree at a crossing with sufficiently\nsmall local errors, under the proved bivariate agreement theorem's hypotheses. ", + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.BivariateCrossingSoundness", + "name": "PCP.Algebraic.BivariateCrossingSoundness.crossing_bestApproximation_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ},\n 0 < d →\n 1000 * d ^ 3 ≤ Fintype.card F →\n ∀ (f : F × F → F) (x₀ y₀ : F) {ε ε' : ℚ},\n ε ≤ 1 / 100 →\n (PCP.Algebraic.relativeDistance f fun z =>\n Polynomial.eval z.2 ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun y => f (z.1, y))) ≤\n ε →\n (PCP.Algebraic.relativeDistance f fun z =>\n Polynomial.eval z.1 ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun x => f (x, z.2))) ≤\n ε →\n (PCP.Algebraic.relativeDistance (fun y => f (x₀, y)) fun y =>\n Polynomial.eval x₀ ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun x => f (x, y))) ≤\n ε' →\n (PCP.Algebraic.relativeDistance (fun x => f (x, y₀)) fun x =>\n Polynomial.eval y₀ ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun y => f (x, y))) ≤\n ε' →\n 5 * ε + ε' + 2 * (↑d / ↑(Fintype.card F)) < 1 / 2 →\n Polynomial.eval y₀ ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun y => f (x₀, y)) =\n Polynomial.eval x₀ ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun x => f (x, y₀))", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "Prod", + "Rat", + "Rat.instLE", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.snd", + "Subtype.val", + "Polynomial", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.bestApproximation", + "Prod.mk", + "Prod.fst", + "Rat.instLT", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Change the sampled center to the point whose value is being predicted. ", + "end_line": 110, + "is_class": false, + "kind": "definition", + "line": 92, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.predictionSamplesEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → (σ → F) × (σ → F) × F ≃ ((σ → F) × (σ → F)) × F", + "type_dependencies": [ + "Field", + "Equiv", + "Prod" + ], + "value_dependencies": [ + "Field", + "Equiv.mk", + "Prod", + "Prod.mk", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Prod.fst", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.snd", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.PointLineTest.predictionSamplesEquiv._proof_1", + "PCP.Algebraic.PointLineTest.predictionSamplesEquiv._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The exact characterization is independent of the chosen finite coordinate type. ", + "end_line": 181, + "is_class": false, + "kind": "theorem", + "line": 162, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.exists_polynomial_of_hasLowDegreeLines_finite", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {σ : Type u_2} [Finite σ] {d : ℕ} (f : (σ → F) → F),\n 2 * d < Fintype.card F →\n PCP.Algebraic.PolynomialLine.HasLowDegreeLines d f →\n ∃ P, P.totalDegree ≤ d ∧ ∀ (x : σ → F), (MvPolynomial.eval x) P = f x", + "type_dependencies": [ + "Field", + "Fintype", + "Finite", + "Nat", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.PolynomialLine.HasLowDegreeLines", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 101, + "is_class": false, + "kind": "theorem", + "line": 97, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ),\n IsPrimitiveRoot (PCP.Algebraic.ThreeColorFields.generator k)\n (Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) - 1)", + "type_dependencies": [ + "Nat", + "IsPrimitiveRoot", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "CommRing.toCommMonoid", + "Field.toCommRing", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The relation is polynomial-time checkable. ", + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.check_polyTime", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L), P self.check", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "PCP.NPCertificate.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 152, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.polynomial_query", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (L : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (hP : P.natDegree ≤ r),\n (PCP.Algebraic.BinaryPolynomialSpace.polynomial t r) (PCP.Algebraic.HadamardComposition.query ρ P L hP) =\n PCP.Algebraic.multilinearReduction (PCP.Algebraic.HadamardComposition.formalQuery ρ P L)", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "MvPolynomial", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.BinaryPolynomialSpace.polynomial", + "PCP.Algebraic.HadamardComposition.query", + "PCP.Algebraic.multilinearReduction", + "PCP.Algebraic.HadamardComposition.formalQuery" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V)\n (s : PCP.Algebraic.ThreeColorBinaryVerifier.Seed (Fintype.card V)) (eV : V ≃ Fin (Fintype.card V)),\n PCP.Algebraic.ThreeColorBinaryVerifier.queries G s eV =\n List.map (⇑(PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv (Fintype.card V)))\n (PCP.Algebraic.ThreeColorFullFieldSampling.queries\n (PCP.Algebraic.ThreeColorParameters.coordinates\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))\n (⇑(PCP.Algebraic.ThreeColorParameters.nodes\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V))))\n (PCP.Algebraic.ThreeColorParameters.generator\n (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))\n (PCP.Algebraic.ThreeColorParameters.grid (PCP.Algebraic.ThreeColorParameterChoice.exponent (Fintype.card V)))\n (PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph G eV)\n ((PCP.Algebraic.ThreeColorBinaryVerifier.seedEquiv (Fintype.card V)).symm s))", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "Fintype.card", + "Equiv", + "Fin", + "Eq", + "List", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "PCP.Algebraic.ThreeColorBinaryVerifier.queries", + "List.map", + "PCP.Algebraic.ThreeColorBinaryVerifier.Address", + "DFunLike.coe", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv", + "PCP.Algebraic.ThreeColorFullFieldSampling.queries", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "Nat", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorParameters.fieldIndex", + "PCP.Algebraic.ThreeColorBinaryVerifier.test._proof_1", + "PCP.Algebraic.BinaryMaterializedField.instAlgebraZModOfNatNatElement", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorParameters.coordinates", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorParameters.nodes", + "PCP.Algebraic.ThreeColorParameters.generator", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.RawSeed", + "Equiv.symm", + "PCP.Algebraic.ThreeColorBinaryVerifier.seedEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An injective binary representation and a uniform homogeneous label detect\nexactly half of the field disagreements. ", + "end_line": 314, + "is_class": false, + "kind": "theorem", + "line": 306, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.homogeneous_distance_eq_half", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : DecidableEq F] [inst_1 : Fintype I] {t : ℕ} (ρ : F → Fin t → ZMod 2),\n Function.Injective ρ →\n ∀ (f g : I → F),\n (PCP.Algebraic.relativeDistance (fun s => (PCP.Algebraic.Hadamard.linearEncode (ρ (f s.1))) s.2) fun s =>\n (PCP.Algebraic.Hadamard.linearEncode (ρ (g s.1))) s.2) =\n 1 / 2 * PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "DecidableEq", + "Fintype", + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Prod.fst", + "Prod.snd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n PCP.Algebraic.SetMultilinear.encode m c = PCP.Algebraic.SetMultilinear.encode m c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False", + "type_dependencies": [ + "Zero", + "OfNat", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "NeZero", + "Eq", + "Zero.toOfNat0", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {d : ℕ} →\n {accept : Bool} →\n {d' : ℕ} →\n {accept' : Bool} →\n d = d' → PCP.QueryTree.leaf accept ≍ PCP.QueryTree.leaf accept' → (d = d' → accept = accept' → P) → P", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "HEq", + "PCP.QueryTree", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [ + "Nat", + "Bool", + "Eq", + "HEq", + "PCP.QueryTree", + "PCP.QueryTree.leaf", + "id", + "PCP.QueryTree.noConfusion" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.smallError_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 < PCP.Algebraic.GeneratorLowDegreeTest.smallError c", + "type_dependencies": [ + "Nat", + "LT.lt", + "Rat", + "Rat.instLT", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.GeneratorLowDegreeTest.smallError" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "No truncation can create acceptance: both real and required terminal stacks fit the budget. ", + "end_line": 262, + "is_class": false, + "kind": "theorem", + "line": 256, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.satisfies_boundedEval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {T B : ℕ} {initial final : tm.Cfg} {a : PCP.Machine.TableauCells.Assignment tm T B},\n PCP.Machine.TableauCells.Satisfies tm T B initial final a →\n PCP.Machine.mass initial.stk + PCP.Machine.machinePushBound tm * T ≤ B →\n (∀ (k : tm.K), (final.stk k).length ≤ B) → PCP.Machine.boundedEval tm T initial = final", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Assignment", + "PCP.Machine.TableauCells.Satisfies", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.mass", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.kFin", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Machine.machinePushBound", + "List.length", + "Eq", + "PCP.Machine.boundedEval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The verifier on one finite proof word and a fixed-length fair-bit seed. ", + "end_line": 163, + "is_class": false, + "kind": "definition", + "line": 157, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.test", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n [inst : Fintype V] →\n SimpleGraph V →\n PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (Fintype.card V) →\n PCP.Algebraic.ThreeColorBinaryVerifier.Seed (Fintype.card V) →\n optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V) → Bool", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Fintype.card", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "optParam", + "Equiv", + "Fin", + "Fintype.equivFin", + "Bool" + ], + "value_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Fintype.card", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "Equiv", + "Fin", + "Nat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorFullFieldSampling.test", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorParameters.fieldIndex", + "PCP.Algebraic.ThreeColorBinaryVerifier.test._proof_1", + "PCP.Algebraic.BinaryMaterializedField.instAlgebraZModOfNatNatElement", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameters.binaryDimension", + "PCP.Algebraic.ThreeColorParameters.coordinates", + "DFunLike.coe", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorParameters.nodes", + "PCP.Algebraic.ThreeColorParameters.generator", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof", + "PCP.Algebraic.ThreeColorBinaryVerifier.RawSeed", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.ThreeColorBinaryVerifier.seedEquiv" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 75, + "is_class": false, + "kind": "constructor", + "line": 75, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.var", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal" + ], + "type": "{V : Type u_1} → V → Bool → PCP.Reduction.NAEThreeColor.Literal V", + "type_dependencies": [ + "Bool", + "PCP.Reduction.NAEThreeColor.Literal" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same eight physical tables give perfect completeness on every raw seed. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 95, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.exists_proof_test_eq_true", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n G.Colorable 3 →\n 5 * ((H.card - 1) * n) < m ^ c →\n ∃ π,\n ∀ (s : PCP.Algebraic.ThreeColorFullFieldSampling.RawSample F n m c t),\n PCP.Algebraic.ThreeColorFullFieldSampling.test ρ nodes ζ H G π s = true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "SimpleGraph.Colorable", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Exists", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorFullFieldSampling.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) →\n ((color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t) →\n (validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t) →\n (properLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t) →\n motive\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines }) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {d addr : ℕ} →\n {onFalse onTrue : PCP.QueryTree d} →\n {d' addr' : ℕ} →\n {onFalse' onTrue' : PCP.QueryTree d'} →\n d + 1 = d' + 1 →\n PCP.QueryTree.query addr onFalse onTrue ≍ PCP.QueryTree.query addr' onFalse' onTrue' →\n (d = d' → addr = addr' → onFalse ≍ onFalse' → onTrue ≍ onTrue' → P) → P", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HEq", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HEq", + "PCP.QueryTree.query", + "id", + "PCP.QueryTree.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The tester constructs a nearby field function and an actual formal line table,\nwith point-line rejection controlled by its own rejection. No smallness is needed here. ", + "end_line": 319, + "is_class": false, + "kind": "theorem", + "line": 243, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.exists_decoded_table", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n ∃ g T,\n PCP.Algebraic.relativeDistance (fun p => f p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ (g x)) ≤\n 28 * PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ (g x)))) ≤\n 28 * PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ∧\n PCP.Algebraic.PointLineTest.rejectionRate g T ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Exists", + "PCP.Algebraic.PointLineTest.LineTable", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "And", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 114, + "is_class": false, + "kind": "theorem", + "line": 109, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_le_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.accProb x π ≤ 1", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Verifier.accProb", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 90, + "is_class": false, + "kind": "definition", + "line": 90, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.clauseVertex", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → {C : Type u_2} → C → Fin 3 → PCP.Reduction.NAEThreeColor.Vertex V C", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Vertex" + ], + "value_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inr", + "Sum", + "Prod", + "Bool", + "Prod.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The concrete reduction retains its exact language program for verifier composition. ", + "end_line": 241, + "is_class": false, + "kind": "theorem", + "line": 211, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.checker_program_reduction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ),\n ∃ f p P C d,\n ∀ (x : List Bool),\n P.run (List.map Bool.toNat x) = List.map Bool.toNat (f x) ∧\n P.cost (List.map Bool.toNat x) ≤ C * (x.length + 1) ^ d ∧\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔\n ∃ w, w.length ≤ Polynomial.eval x.length q ∧ R x w = true) ∧\n (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Exists", + "PCP.Lang.Prog", + "And", + "Eq", + "PCP.Lang.Prog.run", + "List.map", + "Bool.toNat", + "LE.le", + "instLENat", + "PCP.Lang.Prog.cost", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "OfNat.ofNat", + "instOfNatNat", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "Polynomial.eval", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.encodeCells.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} (B : ℕ) (c : tm.Cfg) (hs : PCP.Machine.StackSupported tm c.stk) (k : tm.K) (j : Fin B),\n PCP.Machine.TableauCells.encodeCells B c hs k j = if h : ↑j < (c.stk k).length then some ⟨(c.stk k)[↑j], ⋯⟩ else none", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "Fin", + "Eq", + "Option", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.TableauCells.encodeCells", + "dite", + "LT.lt", + "instLTNat", + "Fin.val", + "List.length", + "Nat.decLt", + "Option.some", + "Subtype.mk", + "PCP.Machine.Supported", + "GetElem.getElem", + "List", + "List.instGetElemNatLtLength", + "PCP.Machine.TableauCells.encodeCells._proof_1", + "Not", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A formal row mismatch bounds every evaluation-grid disagreement in that row. ", + "end_line": 171, + "is_class": false, + "kind": "theorem", + "line": 155, + "module": "PCP.Algebraic.BivariateAgreementFromRectangle", + "name": "PCP.Algebraic.BivariateAgreementFromRectangle.gridDistance_le_rowDistance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (R : F → Polynomial F)\n (P : MvPolynomial (Fin 2) F),\n (PCP.Algebraic.relativeDistance (fun z => Polynomial.eval z.1 (R z.2)) fun z => (MvPolynomial.eval ![z.1, z.2]) P) ≤\n PCP.Algebraic.relativeDistance R (PCP.Algebraic.PointLineCrossing.columnPolynomial P)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Polynomial.eval", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty", + "Polynomial.instDecidableEq", + "PCP.Algebraic.PointLineCrossing.columnPolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.parameterShiftEquiv.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (t : F),\n PCP.Algebraic.PointLineTest.parameterShiftEquiv t =\n { toFun := fun s => ((s.1.1 + (t - s.2) • s.1.2, s.1.2), s.2),\n invFun := fun s => ((s.1.1 - (t - s.2) • s.1.2, s.1.2), s.2), left_inv := ⋯, right_inv := ⋯ }", + "type_dependencies": [ + "Field", + "Eq", + "Equiv", + "Prod", + "PCP.Algebraic.PointLineTest.parameterShiftEquiv", + "Equiv.mk", + "Prod.mk", + "HAdd.hAdd", + "instHAdd", + "Pi.instAdd", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Prod.snd", + "Pi.instSub", + "PCP.Algebraic.PointLineTest.parameterShiftEquiv._proof_1", + "PCP.Algebraic.PointLineTest.parameterShiftEquiv._proof_2" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Encoding of an argument triple: input, random string, answers so far. ", + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeTriple", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool × List Bool × List Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Prod", + "List", + "Bool", + "HAppend.hAppend", + "PCP.Machine.Sym", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 99, + "is_class": false, + "kind": "theorem", + "line": 89, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {c t : ℕ} {ζ : F} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (Q : MvPolynomial σ F),\n Q.totalDegree ≤ c →\n ∀ (H : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) (u : σ → F),\n (PCP.Algebraic.relativeDistance\n (fun vw => PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ H u vw.1 vw.2) fun vw =>\n (PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval u) Q))) vw.2) ≤\n ↑(c + 1) *\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ H fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) Q)))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.homogeneousIndex.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ} (hr : 1 ≤ r), PCP.Algebraic.Hadamard.homogeneousIndex hr = PCP.Algebraic.Hadamard.homogeneousIndex hr", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "LinearMap", + "ZMod", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.Hadamard.homogeneousIndex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.direct.match_1.eq_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2}\n (motive : PCP.Reduction.NAEThreeColor.Vertex V C → PCP.Reduction.NAEThreeColor.Vertex V C → Sort u_3) (e : C)\n (i : Fin 3) (x : PCP.Reduction.NAEThreeColor.Vertex V C) (h_1 : (i j : Fin 3) → motive (Sum.inl i) (Sum.inl j))\n (h_2 : (val : V × Bool) → (i : Fin 3) → motive (Sum.inr (Sum.inl val)) (Sum.inl i))\n (h_3 : (v : V) → (b : Bool) → (w : V) → (d : Bool) → motive (Sum.inr (Sum.inl (v, b))) (Sum.inr (Sum.inl (w, d))))\n (h_4 : (e : C) → (i : Fin 3) → (f : C) → (j : Fin 3) → motive (Sum.inr (Sum.inr (e, i))) (Sum.inr (Sum.inr (f, j))))\n (h_5 : (e : C) → (i : Fin 3) → (x : PCP.Reduction.NAEThreeColor.Vertex V C) → motive (Sum.inr (Sum.inr (e, i))) x)\n (h_6 : (x x_1 : PCP.Reduction.NAEThreeColor.Vertex V C) → motive x x_1),\n (∀ (f : C) (j : Fin 3), x = Sum.inr (Sum.inr (f, j)) → False) →\n (match Sum.inr (Sum.inr (e, i)), x with\n | Sum.inl i, Sum.inl j => h_1 i j\n | Sum.inr (Sum.inl val), Sum.inl i => h_2 val i\n | Sum.inr (Sum.inl (v, b)), Sum.inr (Sum.inl (w, d)) => h_3 v b w d\n | Sum.inr (Sum.inr (e, i)), Sum.inr (Sum.inr (f, j)) => h_4 e i f j\n | Sum.inr (Sum.inr (e, i)), x => h_5 e i x\n | x, x_2 => h_6 x x_2) =\n h_5 e i x", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk", + "Eq", + "False", + "PCP.Reduction.NAEThreeColor.direct.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 83, + "is_class": false, + "kind": "theorem", + "line": 76, + "module": "PCP.Algebraic.ThreeColorAlgebra", + "name": "PCP.Algebraic.ThreeColorAlgebra.satisfies_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} [inst : Field F] [CharP F 2] (G : SimpleGraph V) (f : V → F),\n PCP.Algebraic.ThreeColorAlgebra.Satisfies G f ↔ (∀ (v : V), f v ^ 3 = 1) ∧ ∀ (v w : V), G.Adj v w → f v ≠ f w", + "type_dependencies": [ + "Field", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "SimpleGraph", + "Iff", + "PCP.Algebraic.ThreeColorAlgebra.Satisfies", + "And", + "Eq", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "SimpleGraph.Adj", + "Ne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.sizePoly._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(1 + 1).AtLeastTwo", + "type_dependencies": [ + "Nat.AtLeastTwo", + "HAdd.hAdd", + "Nat", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 148, + "is_class": false, + "kind": "definition", + "line": 144, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.firstLabelEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_3} → {W : Type u_4} → (V × V) × W ≃ (V × W) × V", + "type_dependencies": [ + "Equiv", + "Prod" + ], + "value_dependencies": [ + "Equiv.mk", + "Prod", + "Prod.mk", + "Prod.fst", + "Prod.snd", + "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.firstLabelEquiv._proof_1", + "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.firstLabelEquiv._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 121, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.card_vertex", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} [inst : Fintype V] [inst_1 : Fintype C],\n Fintype.card (PCP.Reduction.NAEThreeColor.Vertex V C) = 3 + 2 * Fintype.card V + 3 * Fintype.card C", + "type_dependencies": [ + "Fintype", + "Eq", + "Nat", + "Fintype.card", + "PCP.Reduction.NAEThreeColor.Vertex", + "instFintypeSum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Sum", + "Prod", + "Bool", + "Fin.fintype", + "instFintypeProd", + "Bool.fintype", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.read.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {t r : ℕ} (motive : PCP.Algebraic.BinaryDifferenceConsistency.Query F σ t r → Sort u_3)\n (p : (σ ⊕ σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p))\n (h_2 : (p : (σ ⊕ σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inr p)),\n (match Sum.inr p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_2 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Prod", + "Sum", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Substitution by the vanishing polynomials multiplies degree by at most `|H|`. ", + "end_line": 149, + "is_class": false, + "kind": "theorem", + "line": 141, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.totalDegree_substitute_coordinate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R),\n H.Nonempty →\n ∀ (M : MvPolynomial (σ ⊕ σ) R),\n ((PCP.Algebraic.GridVanishing.substitute (PCP.Algebraic.GridVanishing.coordinate H)) M).totalDegree ≤\n M.totalDegree * H.card", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "PCP.Algebraic.GridVanishing.coordinate", + "HMul.hMul", + "instHMul", + "instMulNat", + "Finset.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier =\n { randomness := PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget, queries := 187,\n run := PCP.Algebraic.ThreeColorCanonicalVerifier.tree }", + "type_dependencies": [ + "Eq", + "PCP.Verifier", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "PCP.Verifier.mk", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.tree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The entire quantified witness type is finite; no unbounded configurations occur. ", + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 105, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.Assignment", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} → PCP.Machine.NPTableau.Checker R → Polynomial ℕ → List Bool → Type", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Prod", + "PCP.Machine.NPTableau.BoundedWitness", + "Polynomial.eval", + "List.length", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.NPTableau.timePoly", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.ComputationTableau.Row", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "PCP.Machine.NPTableau.spacePoly" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.QueryTree.wordOfOracle.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (P : ℕ) (π : PCP.ProofOracle) (a : Fin P), PCP.QueryTree.wordOfOracle P π a = π ↑a", + "type_dependencies": [ + "Nat", + "PCP.ProofOracle", + "Fin", + "Eq", + "Bool", + "PCP.QueryTree.wordOfOracle", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The computed encoded graph has polynomial bit length. ", + "end_line": 151, + "is_class": false, + "kind": "theorem", + "line": 145, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.length_encode_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n ∃ p, ∀ (x : List Bool), (PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "Exists", + "LE.le", + "instLENat", + "List.length", + "PCP.Reduction.NPThreeColorRuntime.encode", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Read one tagged query from the actual three oracle components. ", + "end_line": 106, + "is_class": false, + "kind": "definition", + "line": 101, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n ((Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Query F n m c t → ZMod 2", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "PCP.Algebraic.BinaryZeroOnGridCorrection.read.match_1", + "Prod", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "PCP.Algebraic.BinaryLocalCorrection.read" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 31, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Complexity.CostModel", + "name": "PCP.length_bitsOfFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), (PCP.bitsOfFin k r).length = k", + "type_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "List.length", + "Bool", + "PCP.bitsOfFin" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness at `x` with error `s`: every proof is accepted with probability at most `s`. ", + "end_line": 134, + "is_class": false, + "kind": "definition", + "line": 133, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.SoundAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → ℚ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Rat" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Rat", + "PCP.ProofOracle", + "LE.le", + "Rat.instLE", + "PCP.Verifier.accProb" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The actual eight-table address space at the chosen parameters. ", + "end_line": 36, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.Address", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.size", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameters.binaryDimension" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 383, + "is_class": false, + "kind": "definition", + "line": 383, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeTestSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n [Fintype F] → [DecidableEq F] → {k r : ℕ} → Fintype (PCP.Algebraic.DerivedZeroOnGrid.TestSample F k m c t r)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Fin", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.ThreeColorVerifier.instFintypeGridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "recursor", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n {a : ℕ} → (t : PCP.QueryTree a) → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n {inst_3 : DecidableEq F} [inst_4 : DecidableEq F] [inst_5 : Fintype σ] {inst_6 : DecidableEq σ}\n [inst_7 : DecidableEq σ] (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (nodes nodes_1 : Fin (c + 1) → F),\n nodes = nodes_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (f f_1 : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n f = f_1 →\n ∀ (H H_1 : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t),\n H = H_1 →\n ∀ (a a_1 : σ → F),\n a = a_1 →\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a =\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ_1 nodes_1 ζ_1 f_1 H_1 a_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.predictionSamplesEquiv._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (s : (σ → F) × (σ → F) × F),\n (PCP.Algebraic.PolynomialLine.point ((s.1 - s.2.2 • s.2.1, s.2.1), s.2.2).1.1\n ((s.1 - s.2.2 • s.2.1, s.2.1), s.2.2).1.2 ((s.1 - s.2.2 • s.2.1, s.2.1), s.2.2).2,\n ((s.1 - s.2.2 • s.2.1, s.2.1), s.2.2).1.2, ((s.1 - s.2.2 • s.2.1, s.2.1), s.2.2).2) =\n s", + "type_dependencies": [ + "Field", + "Prod", + "Eq", + "Prod.mk", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The exact affine-line characterization, with both directions proved. ", + "end_line": 160, + "is_class": false, + "kind": "theorem", + "line": 153, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.hasLowDegreeLines_iff_exists_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {n d : ℕ} (f : (Fin n → F) → F),\n 2 * d < Fintype.card F →\n (PCP.Algebraic.PolynomialLine.HasLowDegreeLines d f ↔\n ∃ P, P.totalDegree ≤ d ∧ ∀ (x : Fin n → F), (MvPolynomial.eval x) P = f x)", + "type_dependencies": [ + "Field", + "Fintype", + "Nat", + "Fin", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Iff", + "PCP.Algebraic.PolynomialLine.HasLowDegreeLines", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 143, + "is_class": false, + "kind": "definition", + "line": 143, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n [Fintype F] → [Fintype σ] → [DecidableEq σ] → Fintype (PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "instFintypeProd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.PointLineEndpointConsistency.fraction_endpoint_disagreement_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Fintype F] {d : ℕ}, 20 * d ≤ Fintype.card F → ¬3 * d ≤ Fintype.card F → False", + "type_dependencies": [ + "Fintype", + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridCorrection.0.PCP.Algebraic.BinaryZeroOnGridCorrection.read.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (motive : PCP.Algebraic.BinaryZeroOnGridCorrection.Query F n m c t → Sort u_2)\n (q :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n ×\n PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t)\n (h_1 : (q : (Fin n → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl q))\n (h_2 :\n (q :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n ×\n PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t) →\n motive (Sum.inr q)),\n (match Sum.inr q with\n | Sum.inl q => h_1 q\n | Sum.inr q => h_2 q) =\n h_2 q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} {accept accept_1 : Bool}, PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1 → accept = accept_1", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "PCP.QueryTree", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every ordinary proof oracle for a noncolorable decoded graph has constant soundness. ", + "end_line": 164, + "is_class": false, + "kind": "theorem", + "line": 158, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.soundAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n ¬(PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorCanonicalVerifier.verifier.SoundAt x (1 - PCP.Algebraic.ThreeColorBinaryVerifier.gap)", + "type_dependencies": [ + "List", + "Bool", + "Not", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Verifier.SoundAt", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "HSub.hSub", + "Rat", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properGridQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3) →\n ((x : Fin (n + n) → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((fst : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F (n + n)) →\n (x : Fin (n + n) ⊕ Fin (n + n) → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (fst, Sum.inl (x, q)))) →\n ((a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F (n + n)) →\n (b : Fin (n + n) ⊕ Fin (n + n) → F) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr (a, Sum.inr (b, x, q)))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.adj_variable_base._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u} (r : V → V → Prop) (v w : V), (SimpleGraph.fromRel r).Adj v w = (v ≠ w ∧ (r v w ∨ r w v))", + "type_dependencies": [ + "Eq", + "SimpleGraph.Adj", + "SimpleGraph.fromRel", + "And", + "Ne", + "Or" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes_injective._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [inst : Fintype F],\n 2 * c < Fintype.card F → ∀ ⦃i : Fin (c + 1)⦄, 1 < Fintype.card F → ¬↑i < Fintype.card F - 1 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "Fin.val", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Nat" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.Prefix", + "provenance": "lean", + "structural_dependencies": [], + "type": "Turing.FinTM2 → Type", + "type_dependencies": [ + "Turing.FinTM2" + ], + "value_dependencies": [ + "Turing.FinTM2", + "PCP.Machine.ComputationTableau.Row", + "PCP.Machine.TM2Locality.machineWindow" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 90, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.cubeRoot_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), IsPrimitiveRoot (PCP.Algebraic.ThreeColorFields.cubeRoot k) 3", + "type_dependencies": [ + "Nat", + "IsPrimitiveRoot", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "CommRing.toCommMonoid", + "Field.toCommRing", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.cubeRoot" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 73, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.eval_coordinatePolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (x : Fin t → ZMod 2),\n (MvPolynomial.eval fun i => (algebraMap (ZMod 2) F) (x i))\n (PCP.Algebraic.HadamardComposition.coordinatePolynomial ρ) =\n ρ.symm x", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Algebra.algebraMap", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "LinearEquiv.symm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "_private.PCP.Reduction.NAEThreeColor.0.PCP.Reduction.NAEThreeColor.direct.match_1.eq_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2}\n (motive : PCP.Reduction.NAEThreeColor.Vertex V C → PCP.Reduction.NAEThreeColor.Vertex V C → Sort u_3)\n (x x_1 : PCP.Reduction.NAEThreeColor.Vertex V C) (h_1 : (i j : Fin 3) → motive (Sum.inl i) (Sum.inl j))\n (h_2 : (val : V × Bool) → (i : Fin 3) → motive (Sum.inr (Sum.inl val)) (Sum.inl i))\n (h_3 : (v : V) → (b : Bool) → (w : V) → (d : Bool) → motive (Sum.inr (Sum.inl (v, b))) (Sum.inr (Sum.inl (w, d))))\n (h_4 : (e : C) → (i : Fin 3) → (f : C) → (j : Fin 3) → motive (Sum.inr (Sum.inr (e, i))) (Sum.inr (Sum.inr (f, j))))\n (h_5 : (e : C) → (i : Fin 3) → (x : PCP.Reduction.NAEThreeColor.Vertex V C) → motive (Sum.inr (Sum.inr (e, i))) x)\n (h_6 : (x x_2 : PCP.Reduction.NAEThreeColor.Vertex V C) → motive x x_2),\n (∀ (i j : Fin 3), x = Sum.inl i → x_1 = Sum.inl j → False) →\n (∀ (val : V × Bool) (i : Fin 3), x = Sum.inr (Sum.inl val) → x_1 = Sum.inl i → False) →\n (∀ (v : V) (b : Bool) (w : V) (d : Bool), x = Sum.inr (Sum.inl (v, b)) → x_1 = Sum.inr (Sum.inl (w, d)) → False) →\n (∀ (e : C) (i : Fin 3) (f : C) (j : Fin 3),\n x = Sum.inr (Sum.inr (e, i)) → x_1 = Sum.inr (Sum.inr (f, j)) → False) →\n (∀ (e : C) (i : Fin 3), x = Sum.inr (Sum.inr (e, i)) → False) →\n (match x, x_1 with\n | Sum.inl i, Sum.inl j => h_1 i j\n | Sum.inr (Sum.inl val), Sum.inl i => h_2 val i\n | Sum.inr (Sum.inl (v, b)), Sum.inr (Sum.inl (w, d)) => h_3 v b w d\n | Sum.inr (Sum.inr (e, i)), Sum.inr (Sum.inr (f, j)) => h_4 e i f j\n | Sum.inr (Sum.inr (e, i)), x => h_5 e i x\n | x, x_7 => h_6 x x_7) =\n h_6 x x_1", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Vertex", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum.inl", + "Sum", + "Prod", + "Bool", + "Sum.inr", + "Prod.mk", + "Eq", + "False", + "PCP.Reduction.NAEThreeColor.direct.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Read one indexed primary or auxiliary bit. ", + "end_line": 84, + "is_class": false, + "kind": "definition", + "line": 80, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1", + "Prod", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 242, + "is_class": false, + "kind": "theorem", + "line": 225, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F} [Finite σ],\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : (σ → F) → F),\n (∀ (u v : σ → F), f u = PCP.Algebraic.GeneratorLowDegreeTest.correct c ζ f u v) →\n ∃ P, P.totalDegree ≤ c ∧ ∀ (x : σ → F), (MvPolynomial.eval x) P = f x", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Finite", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.correct", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Restriction at a fixed first coordinate evaluates the outer coefficient series. ", + "end_line": 113, + "is_class": false, + "kind": "theorem", + "line": 104, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.rowPolynomial_assemble", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {k : ℕ} (v : Fin (k + 1) → Polynomial F) (x : F),\n PCP.Algebraic.PointLineCrossing.rowPolynomial (PCP.Algebraic.BerlekampWelchCertificate.assemble v) x =\n ∑ j, v j * Polynomial.C (x ^ ↑j)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "PCP.Algebraic.BerlekampWelchCertificate.assemble", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → ℕ → Sort (max 1 u)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "cond", + "Nat.ble", + "PULift", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual proof word, not an independent bound parameter, has polynomial length. ", + "end_line": 102, + "is_class": false, + "kind": "theorem", + "line": 93, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), PCP.Algebraic.ThreeColorBinaryVerifier.proofLength N ≤ (4 * max 1 N) ^ 4224000", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 141, + "is_class": false, + "kind": "theorem", + "line": 139, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.card_constraint", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} [inst : Fintype V] [inst_1 : Fintype C],\n Fintype.card (PCP.Reduction.FiniteDomainConstraints.Constraint V C) = Fintype.card C + Fintype.card V", + "type_dependencies": [ + "Fintype", + "Eq", + "Nat", + "Fintype.card", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "instFintypeSum", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual normalized rejection over the complete finite seed. ", + "end_line": 149, + "is_class": false, + "kind": "definition", + "line": 145, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n [Fintype F] →\n [Fintype σ] →\n [DecidableEq σ] →\n 1 ≤ r →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample", + "instDecidableEqBool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "theorem", + "line": 126, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.degreeOf_inY_one_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (p : Polynomial F),\n MvPolynomial.degreeOf 1 (PCP.Algebraic.BerlekampWelchCertificate.inY p) ≤ p.natDegree", + "type_dependencies": [ + "Field", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.degreeOf", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.BerlekampWelchCertificate.inY", + "Polynomial.natDegree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The homogeneous-linear variant of the element distance identity. ", + "end_line": 180, + "is_class": false, + "kind": "theorem", + "line": 172, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_linearEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t : ℕ} (x y : Fin t → ZMod 2),\n x ≠ y →\n PCP.Algebraic.relativeDistance ⇑(PCP.Algebraic.Hadamard.linearEncode x) ⇑(PCP.Algebraic.Hadamard.linearEncode y) =\n 1 / 2", + "type_dependencies": [ + "Nat", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Ne", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.packWitness._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : ℕ} (w : List Bool), w.length ≤ W → w.length < W.succ", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "LE.le", + "instLENat", + "List.length", + "LT.lt", + "instLTNat", + "Nat.succ" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "One step of an adaptive verifier algorithm.\n\n`alg x r as` is given the input `x`, the random string `r` as a bit list, and the answer bits\nreceived so far (oldest first). It returns either `.inl b`, halting with decision `b`, or\n`.inr a`, naming the next proof address to query.\n\nThis is the algorithmic counterpart of `QueryTree`: a decision tree is what the algorithm *does*,\nthis is the algorithm itself, and a cost model measures the latter. ", + "end_line": 24, + "is_class": false, + "kind": "definition", + "line": 16, + "module": "PCP.Complexity.CostModel", + "name": "PCP.VerifierAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.LineTableLocalCorrection", + "name": "PCP.Algebraic.LineTableLocalCorrection.affineUnitsLabelEquiv._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {W : Type u_3} [inst : Field F] (s : ((σ → F) × W) × Fˣ), ↑s.2 ≠ 0", + "type_dependencies": [ + "Field", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Ne", + "Units.val", + "MonoidWithZero.toMonoid", + "Semiring.toMonoidWithZero", + "Prod.snd", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.interpolateSlices.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n d : ℕ} (a : Fin (d + 1) → F) (P : Fin (d + 1) → MvPolynomial (Fin n) F),\n PCP.Algebraic.PolynomialLine.interpolateSlices a P =\n ∑ i, (Polynomial.toMvPolynomial 0) (Lagrange.basis Finset.univ a i) * (MvPolynomial.rename Fin.succ) (P i)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.PolynomialLine.interpolateSlices", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "DFunLike.coe", + "AlgHom", + "Polynomial", + "Polynomial.semiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Polynomial.algebraOfAlgebra", + "Algebra.id", + "AddMonoidAlgebra.algebra", + "AlgHom.funLike", + "Polynomial.toMvPolynomial", + "Fin.instOfNat", + "PCP.Algebraic.PolynomialLine.interpolateSlices._proof_1", + "Lagrange.basis", + "instDecidableEqFin", + "MvPolynomial.rename", + "Fin.succ" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "_private.PCP.Algebraic.BinaryDifferenceConsistency.0.PCP.Algebraic.BinaryDifferenceConsistency.secondLabelEquiv._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {W : Type u_2} (x : (V × V) × W),\n ((((x.1.2, x.2), x.1.1).2, ((x.1.2, x.2), x.1.1).1.1), ((x.1.2, x.2), x.1.1).1.2) =\n ((((x.1.2, x.2), x.1.1).2, ((x.1.2, x.2), x.1.1).1.1), ((x.1.2, x.2), x.1.1).1.2)", + "type_dependencies": [ + "Prod", + "Eq", + "Prod.mk", + "Prod.snd", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 165, + "is_class": false, + "kind": "theorem", + "line": 163, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.binaryDimension_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), PCP.Algebraic.ThreeColorFields.binaryDimension M = 4 * max 1 (Nat.clog 16 M)", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Algebraic.ThreeColorFields.binaryDimension", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A certificate produces many rows agreeing at every selected nonzero column.\n\nThis is the clean-rectangle counting step. Construction of `E,N` and selection of\nthe nonzero column set `J` are explicit remaining inputs, not assumed soundness. ", + "end_line": 203, + "is_class": false, + "kind": "theorem", + "line": 173, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.fraction_clean_rows_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype I] {d e D : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (a : I → F),\n Function.Injective a →\n ∀ (C : I → Polynomial F) (R : F → Polynomial F) (E N : MvPolynomial (Fin 2) F) (J : Finset I),\n (∀ (y : F), (R y).natDegree ≤ d) →\n MvPolynomial.degreeOf 0 E ≤ e →\n MvPolynomial.degreeOf 0 N ≤ d + e →\n MvPolynomial.degreeOf 1 E ≤ D →\n (∀ (i : I),\n PCP.Algebraic.PointLineCrossing.rowPolynomial N (a i) =\n C i * PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i)) →\n (∀ i ∈ J, PCP.Algebraic.PointLineCrossing.rowPolynomial E (a i) ≠ 0) →\n d + 2 * e < Fintype.card I →\n ∀ {ε : ℚ},\n (∀ (i : I),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x =>\n Polynomial.eval x (C i)) ≤\n ε) →\n 1 - ↑(Fintype.card I) * ε / (↑e + 1) - ↑J.card * ↑D / ↑(Fintype.card F) ≤\n PCP.Algebraic.AffineLineSampling.fraction fun y =>\n ∀ i ∈ J, Polynomial.eval (a i) (R y) = Polynomial.eval y (C i)", + "type_dependencies": [ + "Field", + "Fintype", + "Nat", + "DecidableEq", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Finset", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "MvPolynomial.degreeOf", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.PointLineCrossing.rowPolynomial", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Ne", + "Zero.toOfNat0", + "Polynomial.instZero", + "LT.lt", + "instLTNat", + "instMulNat", + "Fintype.card", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Polynomial.eval", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Rat.instAdd", + "Finset.card", + "PCP.Algebraic.AffineLineSampling.fraction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangleWitness.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool → Bool → Bool → Sort u_1) →\n (x x_1 x_2 : Bool) →\n (Unit → motive false false true) →\n (Unit → motive true true false) →\n ((x : Bool) → motive false true x) → ((x x_3 x_4 : Bool) → motive x x_3 x_4) → motive x x_1 x_2", + "type_dependencies": [ + "Bool", + "Unit", + "Bool.false", + "Bool.true" + ], + "value_dependencies": [ + "Bool", + "Unit", + "Bool.false", + "Bool.true", + "Bool.casesOn", + "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_1", + "Unit.unit", + "Nat.hasNotBit", + "Bool.ctorIdx", + "PCP.Reduction.NAEThreeColor.triangleWitness._sparseCasesOn_2" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "constructor", + "line": 131, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The selected field, with all the same roots and coordinate constructions. ", + "end_line": 123, + "is_class": false, + "kind": "definition", + "line": 122, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.Chosen", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.index" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Substitute the coordinate reconstruction into the given univariate polynomial. ", + "end_line": 86, + "is_class": false, + "kind": "definition", + "line": 83, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.fieldPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : CommRing F] →\n [inst_1 : Algebra (ZMod 2) F] → {t : ℕ} → (F ≃ₗ[ZMod 2] Fin t → ZMod 2) → Polynomial F → MvPolynomial (Fin t) F", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "MvPolynomial" + ], + "value_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "Polynomial.eval₂", + "MvPolynomial", + "AddMonoidAlgebra.semiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.C", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 105, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] [Nonempty α] (f g : α → ZMod 2),\n (PCP.Algebraic.BLR.average fun x => PCP.Algebraic.BLR.sign (f x) * PCP.Algebraic.BLR.sign (g x)) =\n 1 - 2 * PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.average", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.BLR.sign", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "ZMod.decidableEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateAgreement", + "name": "PCP.Algebraic.BivariateAgreement.exists_nearby_of_close_columns._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [Fintype F] [DecidableEq F] {d : ℕ},\n 0 < d →\n ∀ (a : Fin (10 * d) → F) (C : Fin (10 * d) → Polynomial F) (R : F → Polynomial F) (E N : MvPolynomial (Fin 2) F)\n (b : Fin (d + 1) ↪ Fin (10 * d)), (Finset.map b Finset.univ).card = d + 1 → ¬d + 2 * (2 * d) < 10 * d → False", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "Function.Embedding", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "Finset.card", + "Finset.map", + "Finset.univ", + "Fin.fintype", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The three-edge triangle gadget enforces not-all-equal, in both directions. ", + "end_line": 63, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.triangle_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Fin 3 → Bool),\n (∃ g, Function.Injective g ∧ ∀ (i : Fin 3), g i ≠ PCP.Reduction.NAEThreeColor.boolColor (b i)) ↔\n PCP.Reduction.NAEThreeColor.NAE b", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Bool", + "Iff", + "Exists", + "And", + "Function.Injective", + "Ne", + "PCP.Reduction.NAEThreeColor.boolColor", + "PCP.Reduction.NAEThreeColor.NAE" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)),\n 5 * ((H.card - 1) * n) < m ^ c →\n ∀ (P : MvPolynomial (Fin n) F) (MVal : MvPolynomial (Fin n ⊕ Fin n) F)\n (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n MVal.totalDegree ≤ 3 * ((H.card - 1) * n) → ¬MVal.totalDegree < m ^ c → False", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(1 + 1).AtLeastTwo", + "type_dependencies": [ + "Nat.AtLeastTwo", + "HAdd.hAdd", + "Nat", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Taking a difference on disjoint variable blocks does not increase ordinary total degree. ", + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.totalDegree_differencePolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (P : MvPolynomial σ R),\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree ≤ P.totalDegree", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "Sum", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 45, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.readsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.ReadsBelow x\n (Polynomial.eval x.length PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "Polynomial.eval", + "Nat", + "Nat.instSemiring", + "List.length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The uniform space budget is derived from the proved source-machine growth bound. ", + "end_line": 232, + "is_class": false, + "kind": "theorem", + "line": 225, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.run_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {T B : ℕ} {initial : tm.Cfg},\n PCP.Machine.mass initial.stk + PCP.Machine.machinePushBound tm * T ≤ B →\n ∀ (i : Fin (T + 1)) (k : tm.K), ((PCP.Machine.boundedEval tm (↑i) initial).stk k).length ≤ B", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "Turing.FinTM2.Cfg", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Machine.mass", + "Turing.FinTM2.K", + "Turing.FinTM2.Γ", + "Turing.FinTM2.kFin", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Λ", + "Turing.FinTM2.σ", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Machine.machinePushBound", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.Machine.boundedEval", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 33, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_empty", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (i : σ), PCP.Algebraic.GridVanishing.coordinate ∅ i = 1", + "type_dependencies": [ + "CommRing", + "Eq", + "MvPolynomial", + "CommRing.toCommSemiring", + "PCP.Algebraic.GridVanishing.coordinate", + "EmptyCollection.emptyCollection", + "Finset", + "Finset.instEmptyCollection", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidAlgebra.zero", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 469, + "is_class": false, + "kind": "theorem", + "line": 460, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_five", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 5 =\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ\n (fun x => PCP.Algebraic.HadamardDerivedOracle.weightedCubic (PCP.Algebraic.ThreeColorVerifier.edgeValue H G x)) ⋯\n nodes ζ H (PCP.Algebraic.ThreeColorVerifier.flatDifference π) π.properCert\n (PCP.Algebraic.ThreeColorVerifier.properAuxiliary π)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_weightedCubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 458, + "is_class": false, + "kind": "theorem", + "line": 450, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_four", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 4 =\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ (fun x => PCP.Algebraic.HadamardDerivedOracle.cubic) ⋯ nodes ζ H\n π.color π.validCert (PCP.Algebraic.ThreeColorVerifier.validAuxiliary π)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_cubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.sep.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "sizeOf PCP.Machine.Sym.sep = 1", + "type_dependencies": [ + "Eq", + "Nat", + "SizeOf.sizeOf", + "PCP.Machine.Sym", + "PCP.Machine.Sym._sizeOf_inst", + "PCP.Machine.Sym.sep", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "definition", + "line": 44, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Sum", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instFintypeLiteral.match_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : Type u_1) →\n (motive : Bool ⊕ (_ : V) × Bool → Sort u_2) →\n (x : Bool ⊕ (_ : V) × Bool) →\n ((a : Bool) → motive (Sum.inl a)) → ((a : V) → (a_1 : Bool) → motive (Sum.inr ⟨a, a_1⟩)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Sigma", + "Sum.inl", + "Sum.inr", + "Sigma.mk" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Sigma", + "Sum.inl", + "Sum.inr", + "Sigma.mk", + "Sum.casesOn", + "Sigma.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "_private.PCP.Algebraic.WeightedConstraintSoundness.0.PCP.Algebraic.WeightedConstraint.grid_comm._abel_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {V : Type u_1} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n (a : I → F) (x y z b : V) (j i : I),\n x + a i • y + (a j • z + (a i * a j) • b) = x + a j • z + (a i • y + (a i * a j) • b)", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Eq", + "HAdd.hAdd", + "instHAdd", + "AddCommMagma.toAdd", + "AddCommSemigroup.toAddCommMagma", + "AddCommMonoid.toAddCommSemigroup", + "HSMul.hSMul", + "instHSMul", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction", + "AddZero.toAdd", + "SemigroupAction.toSMul", + "Monoid.toSemigroup", + "MulAction.toSemigroupAction", + "DistribMulAction.toMulAction", + "AddCommMonoid.toAddMonoid", + "HMul.hMul", + "instHMul", + "CommMagma.toMul", + "NonUnitalNonAssocCommSemiring.toCommMagma", + "NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring", + "NonUnitalCommRing.toNonUnitalNonAssocCommRing", + "CommRing.toNonUnitalCommRing", + "Field.toCommRing", + "MulOne.toMul", + "MulOneClass.toMulOne", + "Monoid.toMulOneClass" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Both chosen dimension and inner base are bounded by the parameter volume. ", + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.size_le_volume", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent N) ≤\n PCP.Algebraic.ThreeColorParameterChoice.volume N", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameterChoice.volume" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.decodedAt.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (Q : (σ → F) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F)\n (parameter : Fˣ → F) (s : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n PCP.Algebraic.BinaryLocalCorrection.decodedAt ρ Q parameter s =\n (PCP.Algebraic.Hadamard.linearEncode\n (ρ (Polynomial.eval (parameter s.2.1) ((PCP.Algebraic.SetMultilinear.decode m c) (Q s.1)))))\n s.2.2.1.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.decodedAt", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Evaluation of an ordinary total-degree-bounded polynomial has low-degree lines. ", + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 31, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.hasLowDegreeLines_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {σ : Type u_2} {d : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ d → PCP.Algebraic.PolynomialLine.HasLowDegreeLines d fun x => (MvPolynomial.eval x) P", + "type_dependencies": [ + "Field", + "Nat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.PolynomialLine.HasLowDegreeLines", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A nonzero binary additive functional is one on exactly half the domain. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 77, + "module": "PCP.Algebraic.Hadamard", + "name": "PCP.Algebraic.Hadamard.relativeDistance_addHom_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : AddCommGroup V] [inst_1 : Fintype V] (L : V →+ ZMod 2) (e : V),\n L e ≠ 0 → PCP.Algebraic.relativeDistance (⇑L) 0 = 1 / 2", + "type_dependencies": [ + "AddCommGroup", + "Fintype", + "AddMonoidHom", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "SubNegMonoid.toAddMonoid", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "AddMonoidWithOne.toAddMonoid", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "ZMod.instField", + "Nat.fact_prime_two", + "Ne", + "DFunLike.coe", + "AddMonoidHom.instFunLike", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "ZMod.decidableEq", + "Pi.instZero", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instInhabitedSym.default", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym", + "type_dependencies": [ + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "PCP.Machine.Sym.bit", + "Inhabited.default", + "Bool", + "instInhabitedBool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ f H s =\n (PCP.Algebraic.Hadamard.test hr (f s.1.1) s.2.2.2.1 &&\n PCP.Algebraic.BinaryLowDegreeTest.test PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1 ρ nodes (H s.1)\n s.2.2.2.2 &&\n decide\n (PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H s =\n f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2.2.1.2)))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "Bool.and", + "PCP.Algebraic.Hadamard.test", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "Decidable.decide", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 49, + "is_class": false, + "kind": "theorem", + "line": 44, + "module": "PCP.Algebraic.StandardLocalCorrection", + "name": "PCP.Algebraic.StandardLocalCorrection.correct_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (u v : σ → F) (f g : (σ → F) → F),\n (∀ x ∈ PCP.Algebraic.StandardLocalCorrection.queries c ζ u v, f x = g x) →\n PCP.Algebraic.StandardLocalCorrection.correct c ζ f u v = PCP.Algebraic.StandardLocalCorrection.correct c ζ g u v", + "type_dependencies": [ + "Field", + "Nat", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.StandardLocalCorrection.queries", + "Eq", + "PCP.Algebraic.StandardLocalCorrection.correct" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t : ℕ} {σ : Type u_2},\n PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv =\n { toFun := fun s => (s.2.1, s.2.2.1, (s.2.2.2.1, s.1), s.2.2.2.2),\n invFun := fun s => (s.2.2.1.2, s.1, s.2.1, s.2.2.1.1, s.2.2.2), left_inv := ⋯, right_inv := ⋯ }", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "Equiv", + "Prod", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv", + "Equiv.mk", + "Prod.mk", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_2" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryStandardLocalCorrection", + "name": "PCP.Algebraic.BinaryStandardLocalCorrection.correct._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "theorem", + "line": 130, + "module": "PCP.Algebraic.WeightedConstraintSoundness", + "name": "PCP.Algebraic.WeightedConstraint.prediction_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] [inst_4 : Fintype F] [inst_5 : DecidableEq F] [inst_6 : Fintype V] (a w : I → F),\n (∀ (i : I), a i ≠ 0) →\n ∀ (f : V → F) (x : V),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.WeightedConstraint.predict a w f x) fun x_1 =>\n PCP.Algebraic.WeightedConstraint.correction a w f x) ≤\n 2 * ↑(Fintype.card I) * PCP.Algebraic.WeightedConstraint.rejectionRate a w f", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.WeightedConstraint.predict", + "PCP.Algebraic.WeightedConstraint.correction", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "PCP.Algebraic.WeightedConstraint.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A uniform finite average; the empty-domain average is zero. ", + "end_line": 49, + "is_class": false, + "kind": "definition", + "line": 47, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average", + "provenance": "lean", + "structural_dependencies": [], + "type": "{α : Type u_1} → [Fintype α] → (α → ℚ) → ℚ", + "type_dependencies": [ + "Fintype", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "Rat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Finset.sum", + "Rat.addCommMonoid", + "Finset.univ", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.distance_sample_comparison", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] {A : Type u_3} [inst_5 : DecidableEq A]\n (k l : (σ → F) × Fˣ → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k (s.1, s.2.1) s.2.2.1.2) fun s => l (s.1, s.2.1) s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "instFintypeProd", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The discrepancy between two independently sampled values of one word. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.pairDisagreement", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → {A : Type u_2} → [Fintype V] → [DecidableEq A] → (V → A) → ℚ", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "DecidableEq", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.fullDistance._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineEndpointConsistency", + "name": "PCP.Algebraic.ProbabilisticCrossing.errors.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (d : ℕ) (f : F × F → F) (x y : F),\n PCP.Algebraic.ProbabilisticCrossing.errors d f x y =\n ![PCP.Algebraic.relativeDistance f fun z =>\n Polynomial.eval z.2 ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun t => f (z.1, t)),\n PCP.Algebraic.relativeDistance f fun z =>\n Polynomial.eval z.1 ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun t => f (t, z.2)),\n PCP.Algebraic.relativeDistance (fun t => f (x, t)) fun t =>\n Polynomial.eval x ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun s => f (s, t)),\n PCP.Algebraic.relativeDistance (fun t => f (t, y)) fun t =>\n Polynomial.eval y ↑(PCP.Algebraic.PointLineTest.bestApproximation d fun s => f (t, s))]", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Prod", + "Eq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Rat", + "PCP.Algebraic.ProbabilisticCrossing.errors", + "Matrix.vecCons", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.snd", + "Subtype.val", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.PointLineTest.bestApproximation", + "Prod.mk", + "Prod.fst", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 250, + "is_class": false, + "kind": "theorem", + "line": 244, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_properGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.properGridQuery q) =\n PCP.Algebraic.DerivedZeroOnGrid.read (PCP.Algebraic.ThreeColorVerifier.flatDifference π) π.properCert\n (PCP.Algebraic.ThreeColorVerifier.properAuxiliary π) q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery", + "PCP.Algebraic.DerivedZeroOnGrid.read", + "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "constructor", + "line": 133, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A supplied anchor table is exactly the paper's generator table. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → {c : ℕ} → [Fintype F] → (Fin (c + 1) → F) → Prop", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Exists", + "And", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Rejection normalized by the actual enlarged finite seed space. ", + "end_line": 129, + "is_class": false, + "kind": "definition", + "line": 125, + "module": "PCP.Algebraic.ThreeColorFullFieldSampling", + "name": "PCP.Algebraic.ThreeColorFullFieldSampling.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [Fintype F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F → (H : Finset F) → SimpleGraph (Fin n → ↥H) → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorFullFieldSampling.test._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawSample", + "Bool", + "Pi.instFintype", + "PCP.Algebraic.ThreeColorFullFieldSampling.RawBranchSeed", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.ThreeColorFullFieldSampling.rawBranchSeedFintype", + "instDecidableEqBool", + "PCP.Algebraic.ThreeColorFullFieldSampling.test", + "Bool.true" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct.eq_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V)\n (x x_1 : PCP.Reduction.NAEThreeColor.Vertex V C),\n (∀ (e : C) (i : Fin 3), x = Sum.inr (Sum.inr (e, i)) → False) →\n (∀ (i j : Fin 3), x = Sum.inl i → x_1 = Sum.inl j → False) →\n (∀ (val : V × Bool) (i : Fin 3), x = Sum.inr (Sum.inl val) → x_1 = Sum.inl i → False) →\n (∀ (v : V) (b : Bool) (w : V) (d : Bool),\n x = Sum.inr (Sum.inl (v, b)) → x_1 = Sum.inr (Sum.inl (w, d)) → False) →\n (∀ (e : C) (i : Fin 3) (f : C) (j : Fin 3),\n x = Sum.inr (Sum.inr (e, i)) → x_1 = Sum.inr (Sum.inr (f, j)) → False) →\n PCP.Reduction.NAEThreeColor.direct Q x x_1 = False", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Vertex", + "Eq", + "Sum.inr", + "Sum", + "Prod", + "Bool", + "Prod.mk", + "False", + "Sum.inl", + "PCP.Reduction.NAEThreeColor.direct" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.correction._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F], Nonempty F", + "type_dependencies": [ + "Field", + "Nonempty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le_log_add_one._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), ¬max 8 (Nat.clog 2 N) ≤ 8 * (Nat.clog 2 N + 1) → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_const._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] [Nonempty α], (Fintype.card α = 0) = False", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Eq", + "Nat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 76, + "is_class": false, + "kind": "definition", + "line": 72, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.Literal.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {motive : PCP.Reduction.NAEThreeColor.Literal V → Sort u} →\n (ctorIdx : ℕ) →\n (t : PCP.Reduction.NAEThreeColor.Literal V) →\n ctorIdx = t.ctorIdx → PCP.Reduction.NAEThreeColor.Literal.ctorElimType ctorIdx → motive t", + "type_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Nat", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal.ctorIdx", + "PCP.Reduction.NAEThreeColor.Literal.ctorElimType" + ], + "value_dependencies": [ + "PCP.Reduction.NAEThreeColor.Literal", + "Nat", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal.ctorIdx", + "PCP.Reduction.NAEThreeColor.Literal.ctorElimType", + "PCP.Reduction.NAEThreeColor.Literal.casesOn", + "Bool", + "PULift.down", + "PCP.Reduction.NAEThreeColor.Literal.const", + "Eq.ndrec", + "PCP.Reduction.NAEThreeColor.Literal.var" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 64, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Verifier.ReductionResources", + "name": "PCP.Verifier.Reduction.randomness_le_budget", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) {a b : ℕ},\n V.CanonicalRandomness a b →\n ∀ (f : List Bool → List Bool) (p : Polynomial ℕ),\n (∀ (x : List Bool), (f x).length ≤ Polynomial.eval x.length p) →\n ∀ (x : List Bool), V.randomness (f x).length ≤ PCP.Verifier.Reduction.budget p a b x.length", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "Polynomial", + "Nat.instSemiring", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "PCP.Verifier.randomness", + "PCP.Verifier.Reduction.budget" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.predictionSamplesEquiv.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F],\n PCP.Algebraic.PointLineTest.predictionSamplesEquiv =\n { toFun := fun s => ((s.1 - s.2.2 • s.2.1, s.2.1), s.2.2),\n invFun := fun s => (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2, s.1.2, s.2), left_inv := ⋯,\n right_inv := ⋯ }", + "type_dependencies": [ + "Field", + "Eq", + "Equiv", + "Prod", + "PCP.Algebraic.PointLineTest.predictionSamplesEquiv", + "Equiv.mk", + "Prod.mk", + "HSub.hSub", + "instHSub", + "Pi.instSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Prod.fst", + "HSMul.hSMul", + "instHSMul", + "Function.hasSMul", + "instSMulOfMul", + "Distrib.toMul", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.snd", + "PCP.Algebraic.PolynomialLine.point", + "PCP.Algebraic.PointLineTest.predictionSamplesEquiv._proof_1", + "PCP.Algebraic.PointLineTest.predictionSamplesEquiv._proof_2" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Per-branch query budgets in the same order as `BranchSeed`. ", + "end_line": 320, + "is_class": false, + "kind": "definition", + "line": 318, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueryBound", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Fin 7 → ℕ", + "type_dependencies": [ + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "Matrix.vecCons", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Matrix.vecEmpty" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest primary encodings identify the received grid check with its fixed honest counterpart. ", + "end_line": 145, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (f : (Fin n → F) → F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t)\n (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x)))) M A s =\n PCP.Algebraic.BinaryZeroOnGridCorrection.check ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval (f x) (Q x))))) M A\n (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check", + "Polynomial.eval", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.sign.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : ZMod 2), PCP.Algebraic.BLR.sign b = if b = 0 then 1 else -1", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.BLR.sign", + "ite", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "ZMod.decidableEq", + "Rat.instOfNat", + "Neg.neg", + "Rat.instNeg" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.exists_certificate_of_good_specializations._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} {d e : ℕ} {D : ℕ} [Fintype I] (S : Finset F), ¬d + 2 * e + 2 - 1 = d + 2 * e + 1 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Finset", + "Not", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n PCP.QueryTree.below (motive := fun x x_2 => PCP.ProofOracle → Bool) x_1 → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.eval.match_1", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "ite", + "Eq", + "Bool.true", + "instDecidableEqBool", + "PProd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 60, + "is_class": false, + "kind": "theorem", + "line": 59, + "module": "PCP.Algebraic.PointLineParameterError", + "name": "PCP.Algebraic.PointLineTest.rejectionAt_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (f : (σ → F) → F) (t : F), 0 ≤ PCP.Algebraic.PointLineTest.rejectionAt c f t", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.PointLineTest.rejectionAt" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.binaryDimension.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), PCP.Algebraic.ThreeColorFields.binaryDimension M = 4 * (PCP.Algebraic.ThreeColorFields.index M + 1)", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Algebraic.ThreeColorFields.binaryDimension", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.index" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "At radius strictly below half the distance bound, the nearby formal polynomial is unique. ", + "end_line": 95, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.PolynomialDistance", + "name": "PCP.Algebraic.eq_of_eval_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] [inst_2 : DecidableEq 𝔽] {m d : ℕ}\n (p q : MvPolynomial (Fin m) 𝔽),\n p.totalDegree ≤ d →\n q.totalDegree ≤ d →\n ∀ {w : (Fin m → 𝔽) → 𝔽} {ε : ℚ},\n 2 * ε < 1 - ↑d / ↑(Fintype.card 𝔽) →\n (PCP.Algebraic.relativeDistance w fun x => (MvPolynomial.eval x) p) ≤ ε →\n (PCP.Algebraic.relativeDistance w fun x => (MvPolynomial.eval x) q) ≤ ε → p = q", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Rat", + "LT.lt", + "Rat.instLT", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All mathematical resource and verification guarantees for every finite input graph.\nThe concrete runtime and NP reduction are supplied downstream by\n`PCP.Lang.ThreeColorRuntime.polyTimeAlg` and\n`PCP.Algebraic.ThreeColorFinalAssembly.of_runtime`. ", + "end_line": 260, + "is_class": false, + "kind": "theorem", + "line": 246, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.verification_guarantees", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V) (eV : optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V)),\n 0 < PCP.Algebraic.ThreeColorBinaryVerifier.gap ∧\n PCP.Algebraic.ThreeColorBinaryVerifier.randomBits (Fintype.card V) ≤ 32000000 * (Nat.clog 2 (Fintype.card V) + 1) ∧\n PCP.Algebraic.ThreeColorBinaryVerifier.proofLength (Fintype.card V) ≤ (4 * max 1 (Fintype.card V)) ^ 4224000 ∧\n (∀ (s : PCP.Algebraic.ThreeColorBinaryVerifier.Seed (Fintype.card V)),\n (PCP.Algebraic.ThreeColorBinaryVerifier.queries G s eV).length ≤ 187) ∧\n (G.Colorable 3 →\n ∃ π,\n ∀ (s : PCP.Algebraic.ThreeColorBinaryVerifier.Seed (Fintype.card V)),\n PCP.Algebraic.ThreeColorBinaryVerifier.test G π s eV = true) ∧\n (¬G.Colorable 3 →\n ∀ (π : PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (Fintype.card V)),\n PCP.Algebraic.ThreeColorBinaryVerifier.gap ≤\n PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate G π eV)", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "optParam", + "Equiv", + "Fin", + "Fintype.card", + "Fintype.equivFin", + "And", + "LT.lt", + "Rat", + "Rat.instLT", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap", + "LE.le", + "Nat", + "instLENat", + "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits", + "HMul.hMul", + "instHMul", + "instMulNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Nat.clog", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Max.max", + "Nat.instMax", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "List.length", + "PCP.Algebraic.ThreeColorBinaryVerifier.queries", + "SimpleGraph.Colorable", + "Exists", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorBinaryVerifier.test", + "Bool.true", + "Not", + "Rat.instLE", + "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 97, + "is_class": false, + "kind": "theorem", + "line": 92, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.checker_time_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) {x w : List Bool},\n w.length ≤ Polynomial.eval x.length q →\n Polynomial.eval (PCP.Machine.encodePair (x, w)).length h.time ≤\n Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "Prod.mk", + "Turing.TM2ComputableInPolyTime.time", + "Prod", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "PCP.Machine.NPTableau.timePoly" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Full coefficient-oracle proximity suffices, with the factor two for homogeneous labels. ", + "end_line": 356, + "is_class": false, + "kind": "theorem", + "line": 333, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le_full_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {D : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) {δ : ℚ},\n PCP.Algebraic.relativeDistance (fun p => f p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction 1 fun x => ρ ((MvPolynomial.eval x) P)) ≤\n δ →\n ∀ (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a)\n fun s =>\n some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2.2.1.2)) ≤\n PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a +\n 2 * δ +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "Option.instDecidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineConstants", + "name": "PCP.Algebraic.PointLineConstants.field_bounds._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} {q : ℕ}, 1000000 ≤ q → ¬0 < q → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 141, + "is_class": false, + "kind": "definition", + "line": 141, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instNonemptyInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F] {m c : ℕ}, Nonempty (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n t : ℕ} →\n (motive : PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3 → Sort u_2) →\n (x : PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3) →\n ((x : Fin n → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inr (x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "Sum", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "Sum", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 94, + "is_class": false, + "kind": "theorem", + "line": 91, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.certificate_isCertificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (H : Finset R) (p : MvPolynomial σ R)\n (Q : σ → MvPolynomial σ R),\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i →\n PCP.Algebraic.GridVanishing.IsCertificate H p (PCP.Algebraic.GridVanishing.certificate Q)", + "type_dependencies": [ + "CommRing", + "Fintype", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.GridVanishing.certificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.fieldWord.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (w : Fin (PCP.Algebraic.ThreeColorBinaryVerifier.proofLength N) → Bool)\n (i : Fin (PCP.Algebraic.ThreeColorBinaryVerifier.proofLength N)),\n PCP.Algebraic.ThreeColorCanonicalVerifier.fieldWord w i = PCP.Algebraic.BinarySeedPadding.boolEquiv (w i)", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "Bool", + "Eq", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.fieldWord", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.BinarySeedPadding.boolEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.series.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommRing R] {k : ℕ} (v : Fin (k + 1) → R),\n PCP.Algebraic.BerlekampWelchCertificate.series v = ∑ j, (Polynomial.monomial ↑j) (v j)", + "type_dependencies": [ + "CommRing", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.BerlekampWelchCertificate.series", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Finset.univ", + "Fin.fintype", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toModule", + "Polynomial.module", + "LinearMap.instFunLike", + "Polynomial.monomial", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The bivariate agreement theorem used as ALMSS Theorem 69, with explicit\nconstants. Approximating polynomial rows and columns are arbitrary; they need\nnot be optimal. The conclusion constructs the comparison polynomial. ", + "end_line": 165, + "is_class": false, + "kind": "theorem", + "line": 138, + "module": "PCP.Algebraic.BivariateAgreement", + "name": "PCP.Algebraic.BivariateAgreement.exists_polynomial_of_row_column_agreement", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] {d : ℕ},\n 0 < d →\n 1000 * d ^ 3 ≤ Fintype.card F →\n ∀ (f : F × F → F) (R C : F → Polynomial F),\n (∀ (y : F), (R y).natDegree ≤ d) →\n (∀ (x : F), (C x).natDegree ≤ d) →\n ∀ {ε : ℚ},\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.1 (R z.2)) ≤ ε →\n (PCP.Algebraic.relativeDistance f fun z => Polynomial.eval z.2 (C z.1)) ≤ ε →\n ε ≤ 1 / 100 →\n ∃ P,\n (∀ (j : Fin 2), MvPolynomial.degreeOf j P ≤ d) ∧\n (PCP.Algebraic.relativeDistance f fun z => (MvPolynomial.eval ![z.1, z.2]) P) ≤ 4 * ε", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "Prod", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Polynomial.natDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Polynomial.eval", + "Prod.fst", + "Prod.snd", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Exists", + "MvPolynomial", + "Fin", + "And", + "MvPolynomial.degreeOf", + "DFunLike.coe", + "RingHom", + "Nat.succ", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Matrix.vecCons", + "Matrix.vecEmpty", + "Rat.instMul" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.fourier._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each primary query has exactly the uniform point-and-label error marginal. ", + "end_line": 187, + "is_class": false, + "kind": "theorem", + "line": 156, + "module": "PCP.Algebraic.BinaryDifferenceConsistency", + "name": "PCP.Algebraic.BinaryDifferenceConsistency.primary_marginal", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [Field F] [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] {t r : ℕ}\n (hr : 1 ≤ r) (f f' : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n (PCP.Algebraic.relativeDistance (fun s => f s.1.1 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2)) fun s =>\n f' s.1.1 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2)) =\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f f' ∧\n (PCP.Algebraic.relativeDistance (fun s => f s.1.2 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2)) fun s =>\n f' s.1.2 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2)) =\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f f'", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "And", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Prod", + "Fin", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Pi.Function.module", + "Semiring.toModule", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "Prod.snd", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A strict majority of predictions determines the corrected value uniquely. ", + "end_line": 159, + "is_class": false, + "kind": "theorem", + "line": 155, + "module": "PCP.Algebraic.PointLineCorrection", + "name": "PCP.Algebraic.PointLineTest.correction_eq_of_error_lt_half", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (table : PCP.Algebraic.PointLineTest.LineTable F σ c) (x : σ → F)\n (a : F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.PointLineTest.prediction table x) fun x => a) < 1 / 2 →\n PCP.Algebraic.PointLineTest.correction table x = a", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "LT.lt", + "Rat", + "Rat.instLT", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.PointLineTest.prediction", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "Eq", + "PCP.Algebraic.PointLineTest.correction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.direct.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V) (val : V × Bool) (i : Fin 3),\n PCP.Reduction.NAEThreeColor.direct Q (Sum.inr (Sum.inl val)) (Sum.inl i) = (i = 2)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "Prod", + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.direct", + "Sum.inr", + "Sum", + "Sum.inl", + "Fin.instOfNat", + "PCP.Reduction.NAEThreeColor.boolColor._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Minimality is retained as a usable interface for every competing exponent. ", + "end_line": 39, + "is_class": false, + "kind": "theorem", + "line": 37, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.exponent_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N a : ℕ}, 2 ≤ a → Nat.clog 2 N ≤ a * 2 ^ a → PCP.Algebraic.ThreeColorParameterChoice.exponent N ≤ a", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.ThreeColorParameterChoice.exponent" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 227, + "is_class": false, + "kind": "theorem", + "line": 225, + "module": "PCP.Algebraic.HadamardDerivedOracle", + "name": "PCP.Algebraic.HadamardDerivedOracle.eval_weightedCubic", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] (a u : F),\n Polynomial.eval u (PCP.Algebraic.HadamardDerivedOracle.weightedCubic a) = a * (u ^ 3 - 1)", + "type_dependencies": [ + "CommRing", + "Eq", + "Polynomial.eval", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (a_2 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Embedding a univariate polynomial affects only its chosen variable. ", + "end_line": 39, + "is_class": false, + "kind": "theorem", + "line": 26, + "module": "PCP.Algebraic.GridInterpolation", + "name": "PCP.Algebraic.GridInterpolation.degreeOf_toMvPolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {𝔽 : Type u_1} {σ : Type u_2} [inst : Field 𝔽] [inst_1 : DecidableEq σ] (p : Polynomial 𝔽) (i j : σ),\n MvPolynomial.degreeOf j ((Polynomial.toMvPolynomial i) p) ≤ if i = j then p.natDegree else 0", + "type_dependencies": [ + "Field", + "DecidableEq", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.degreeOf", + "DFunLike.coe", + "AlgHom", + "MvPolynomial", + "Polynomial.semiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Polynomial.algebraOfAlgebra", + "Algebra.id", + "AddMonoidAlgebra.algebra", + "AlgHom.funLike", + "Polynomial.toMvPolynomial", + "ite", + "Eq", + "Polynomial.natDegree", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 208, + "is_class": false, + "kind": "theorem", + "line": 197, + "module": "PCP.Complexity.TableauCells", + "name": "PCP.Machine.TableauCells.step_of_represents", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {tm : Turing.FinTM2} {B : ℕ} {p p' : PCP.Machine.TableauCells.Prefix tm} {s s' : PCP.Machine.TableauCells.Cells tm B}\n {c : tm.Cfg},\n PCP.Machine.TableauCells.Represents p s c →\n PCP.Machine.TableauCells.Linked p s →\n PCP.Machine.TableauCells.Represents p' s' (PCP.Machine.keepStep tm.step c) →\n PCP.Machine.TableauCells.Step p p' s s'", + "type_dependencies": [ + "Turing.FinTM2", + "Nat", + "PCP.Machine.TableauCells.Prefix", + "PCP.Machine.TableauCells.Cells", + "Turing.FinTM2.Cfg", + "PCP.Machine.TableauCells.Represents", + "PCP.Machine.TableauCells.Linked", + "PCP.Machine.keepStep", + "Turing.FinTM2.step", + "PCP.Machine.TableauCells.Step" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries)\n (randomness_1 : ℕ → ℕ) (queries_1 : ℕ)\n (run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1),\n ({ randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 }) =\n (randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1)", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "And", + "HEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ), 0 < n → n ≤ c + 1 → ¬n - 1 < c + 1 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Markov's inequality controls the fraction of rows with more than `e` errors. ", + "end_line": 115, + "is_class": false, + "kind": "theorem", + "line": 101, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.fraction_many_rowErrors_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype I]\n (a : I → F) (C : I → Polynomial F) (R : F → Polynomial F) (e : ℕ) {ε : ℚ},\n (∀ (i : I),\n (PCP.Algebraic.relativeDistance (fun y => Polynomial.eval (a i) (R y)) fun x => Polynomial.eval x (C i)) ≤ ε) →\n (PCP.Algebraic.AffineLineSampling.fraction fun y => e < PCP.Algebraic.BivariateCleanRectangle.rowErrors a C R y) ≤\n ↑(Fintype.card I) * ε / (↑e + 1)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Nat", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Polynomial.eval", + "PCP.Algebraic.AffineLineSampling.fraction", + "LT.lt", + "instLTNat", + "PCP.Algebraic.BivariateCleanRectangle.rowErrors", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Fintype.card", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "definition", + "line": 43, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Sum", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a =\n PCP.Algebraic.AffineLineSampling.fraction fun s =>\n PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a s = none", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Eq", + "Rat", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "PCP.Algebraic.AffineLineSampling.fraction", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_2", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.brecOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} → (t : PCP.QueryTree a) → ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PProd", + "PCP.QueryTree.brecOn.go" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.inputSlot._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ}, d ≤ max 1 d", + "type_dependencies": [ + "Nat", + "LE.le", + "Preorder.toLE", + "PartialOrder.toPreorder", + "LinearOrder.toPartialOrder", + "Nat.instLinearOrder", + "Max.max", + "LinearOrder.toMax", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 100, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.totalDegree_fieldPolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F), (PCP.Algebraic.HadamardComposition.fieldPolynomial ρ P).totalDegree ≤ P.natDegree", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.HadamardComposition.fieldPolynomial", + "Polynomial.natDegree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Normalized rejection includes either abstention or a failed residual. ", + "end_line": 174, + "is_class": false, + "kind": "definition", + "line": 168, + "module": "PCP.Algebraic.BinaryZeroOnGridCorrection", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n ((Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "Option", + "Prod", + "instFintypeProd", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed._proof_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeCallSeedSumFin", + "Option.instDecidableEq", + "instDecidableEqProd", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check", + "Option.some", + "Prod.mk", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → {a : ℕ} → PCP.QueryTree a → {a' : ℕ} → PCP.QueryTree a' → Sort u", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.casesOn", + "Bool", + "Eq", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.outputCoordinate._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomCompTriple (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomCompTriple", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 212, + "is_class": false, + "kind": "theorem", + "line": 205, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_boundedEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c →\n ∀ (P : ↥(Polynomial.degreeLE R ↑d)),\n (PCP.Algebraic.SetMultilinear.decode m c) ((PCP.Algebraic.SetMultilinear.boundedEncode m c d) P) = ↑P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "LinearMap", + "RingHom.id", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.boundedEncode", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual rejection probability under uniform fixed-length binary randomness. ", + "end_line": 211, + "is_class": false, + "kind": "definition", + "line": 208, + "module": "PCP.Algebraic.ThreeColorBinaryVerifier", + "name": "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n [inst : Fintype V] →\n SimpleGraph V →\n PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord (Fintype.card V) →\n optParam (V ≃ Fin (Fintype.card V)) (Fintype.equivFin V) → ℚ", + "type_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Fintype.card", + "optParam", + "Equiv", + "Fin", + "Fintype.equivFin", + "Rat" + ], + "value_dependencies": [ + "Fintype", + "SimpleGraph", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord", + "Fintype.card", + "Equiv", + "Fin", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed", + "Bool", + "Pi.instFintype", + "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorBinaryVerifier.rejectionRate._proof_1", + "instDecidableEqBool", + "PCP.Algebraic.ThreeColorBinaryVerifier.test", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.palette._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (Q : C → Fin 3 → PCP.Reduction.NAEThreeColor.Literal V)\n (f : (PCP.Reduction.NAEThreeColor.graph Q).Coloring (Fin 3)),\n (Function.Injective fun i => f (PCP.Reduction.NAEThreeColor.base i)) →\n (Function.Injective fun i => f (PCP.Reduction.NAEThreeColor.base i)) ∧\n Function.Surjective fun i => f (PCP.Reduction.NAEThreeColor.base i)", + "type_dependencies": [ + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Reduction.NAEThreeColor.Literal", + "SimpleGraph.Coloring", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.graph", + "Function.Injective", + "DFunLike.coe", + "RelHom.instFunLike", + "SimpleGraph.Adj", + "SimpleGraph.completeGraph", + "PCP.Reduction.NAEThreeColor.base", + "And", + "Function.Surjective" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.variableVertex.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} (v : V) (b : Bool),\n PCP.Reduction.NAEThreeColor.variableVertex v b = Sum.inr (Sum.inl (v, b))", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Reduction.NAEThreeColor.Vertex", + "PCP.Reduction.NAEThreeColor.variableVertex", + "Sum.inr", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Sum", + "Prod", + "Sum.inl", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The corresponding true bit in a chosen decoded polynomial row. ", + "end_line": 118, + "is_class": false, + "kind": "definition", + "line": 114, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.decodedAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n ((σ → F) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F) →\n (Fˣ → F) → PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "_private.PCP.Reduction.FiniteDomainConstraints.0.PCP.Reduction.FiniteDomainConstraints.scope.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} {C : Type u_2} {a d : ℕ}\n (motive :\n PCP.Reduction.FiniteDomainConstraints.Constraint V C →\n Fin (PCP.Reduction.FiniteDomainConstraints.arity a d) → Sort u_3)\n (v : V) (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d))\n (h_1 : (e : C) → (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) → motive (Sum.inl e) n)\n (h_2 : (v : V) → (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) → motive (Sum.inr v) n),\n (match Sum.inr v, n with\n | Sum.inl e, n => h_1 e n\n | Sum.inr v, n => h_2 v n) =\n h_2 v n", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.arity", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Reduction.FiniteDomainConstraints.scope.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 103, + "is_class": false, + "kind": "theorem", + "line": 101, + "module": "PCP.Algebraic.ThreeColorCanonicalVerifier", + "name": "PCP.Algebraic.ThreeColorCanonicalVerifier.tree_addresses_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool) (r : Fin (2 ^ PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget x.length)),\n ∀ i ∈ (PCP.Algebraic.ThreeColorCanonicalVerifier.tree x r).addresses,\n i < PCP.Algebraic.ThreeColorBinaryVerifier.proofLength (PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder x)", + "type_dependencies": [ + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget", + "List.length", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "PCP.Algebraic.ThreeColorCanonicalVerifier.tree", + "LT.lt", + "instLTNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.coordinatePolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n PCP.Algebraic.HadamardComposition.coordinatePolynomial ρ =\n ∑ i, (MvPolynomial.monomial (Finsupp.single i 1)) (ρ.symm (Pi.single i 1))", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "MvPolynomial", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.univ", + "Fin.fintype", + "DFunLike.coe", + "LinearMap", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "MvPolynomial.monomial", + "Finsupp.single", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "LinearEquiv.symm", + "Pi.single", + "instMulZeroClassOfSemiring", + "instDecidableEqFin", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n PCP.Algebraic.ThreeColorParameterChoice.volume N =\n PCP.Algebraic.ThreeColorParameterChoice.exponent N * 2 ^ PCP.Algebraic.ThreeColorParameterChoice.exponent N", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Algebraic.ThreeColorParameterChoice.volume", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} {m c : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (P : MvPolynomial (Fin n) F) (MVal : MvPolynomial (Fin n ⊕ Fin n) F)\n (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n MProp.totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree +\n 3 * (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree ≤ 2 * ((H.card - 1) * n) →\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree ≤ (H.card - 1) * n →\n ¬MProp.totalDegree ≤ 5 * ((H.card - 1) * n) → False", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Preorder.toLE", + "Nat.instPreorder", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Keep the sampled parameter while changing the center and direction into its two endpoints. ", + "end_line": 82, + "is_class": false, + "kind": "definition", + "line": 76, + "module": "PCP.Algebraic.PointLineConstant", + "name": "PCP.Algebraic.PointLineTest.consecutiveSamplesEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ((σ → F) × (σ → F)) × F ≃ ((σ → F) × (σ → F)) × F", + "type_dependencies": [ + "Field", + "Equiv", + "Prod" + ], + "value_dependencies": [ + "Field", + "Equiv.mk", + "Prod", + "Prod.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.PointLineTest.consecutivePointsEquiv", + "Prod.snd", + "Prod.fst", + "Equiv.symm", + "PCP.Algebraic.PointLineTest.consecutiveSamplesEquiv._proof_1", + "PCP.Algebraic.PointLineTest.consecutiveSamplesEquiv._proof_2" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : ℕ) → (x_1 : PCP.QueryTree x) → PCP.QueryTree.below x_1 → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "Finset", + "PCP.QueryTree.addresses.match_1", + "Bool", + "PCP.QueryTree.leaf", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "PProd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The honest auxiliary encoded line at a fixed requested outer point. ", + "end_line": 126, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.BinaryLocalCorrection", + "name": "PCP.Algebraic.BinaryLocalCorrection.honestTable", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n [NeZero m] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n MvPolynomial σ F → (σ → F) → (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Polynomial", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.encode", + "PCP.Algebraic.PolynomialLine.restrict" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Reduction.FiniteDomainConstraints", + "name": "PCP.Reduction.FiniteDomainConstraints.scope.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} →\n {C : Type u_2} →\n {a d : ℕ} →\n (motive :\n PCP.Reduction.FiniteDomainConstraints.Constraint V C →\n Fin (PCP.Reduction.FiniteDomainConstraints.arity a d) → Sort u_3) →\n (x : PCP.Reduction.FiniteDomainConstraints.Constraint V C) →\n (x_1 : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) →\n ((e : C) → (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) → motive (Sum.inl e) n) →\n ((v : V) → (n : Fin (PCP.Reduction.FiniteDomainConstraints.arity a d)) → motive (Sum.inr v) n) →\n motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.arity", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Reduction.FiniteDomainConstraints.Constraint", + "Fin", + "PCP.Reduction.FiniteDomainConstraints.arity", + "Sum.inl", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [], + "doc": "The two queries used by the correction rule, with random seed `R`. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.HadamardCorrection", + "name": "PCP.Algebraic.Hadamard.selfCorrect", + "provenance": "lean", + "structural_dependencies": [], + "type": "{V : Type u_1} → {W : Type u_2} → [AddCommGroup V] → [AddCommGroup W] → (V → W) → V → V → W", + "type_dependencies": [ + "AddCommGroup" + ], + "value_dependencies": [ + "AddCommGroup", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddCommGroup.toAddGroup", + "HAdd.hAdd", + "instHAdd", + "AddCommMagma.toAdd", + "AddCommSemigroup.toAddCommMagma", + "AddCommMonoid.toAddCommSemigroup", + "AddCommGroup.toAddCommMonoid" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NAEThreeColor", + "name": "PCP.Reduction.NAEThreeColor.instDecidableEqLiteral.decEq._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {V : Type u_1} (a b : Bool),\n ¬a = b → PCP.Reduction.NAEThreeColor.Literal.const a = PCP.Reduction.NAEThreeColor.Literal.const b → False", + "type_dependencies": [ + "Bool", + "Not", + "Eq", + "PCP.Reduction.NAEThreeColor.Literal", + "PCP.Reduction.NAEThreeColor.Literal.const", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Encoding of a Boolean result. ", + "end_line": 48, + "is_class": false, + "kind": "definition", + "line": 47, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeBool", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "Bool", + "List", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Bool", + "List.cons", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "List.nil" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PolynomialLineCharacterization", + "name": "PCP.Algebraic.PolynomialLine.exists_polynomial_of_hasLowDegreeLines._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Fintype F] {d : ℕ}, 2 * d < Fintype.card F → ¬d + 1 ≤ Fintype.card F → False", + "type_dependencies": [ + "Fintype", + "Nat", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Include a univariate polynomial as a polynomial in the second variable alone. ", + "end_line": 61, + "is_class": false, + "kind": "definition", + "line": 59, + "module": "PCP.Algebraic.BerlekampWelchCertificate", + "name": "PCP.Algebraic.BerlekampWelchCertificate.inY", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : Field F] → Polynomial F →+* MvPolynomial (Fin 2) F", + "type_dependencies": [ + "Field", + "RingHom", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid" + ], + "value_dependencies": [ + "Field", + "Polynomial.eval₂RingHom", + "MvPolynomial", + "Fin", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.commSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "MvPolynomial.C", + "MvPolynomial.X", + "Fin.instOfNat", + "PCP.Algebraic.BerlekampWelchCertificate.inY._proof_1" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BLR", + "name": "PCP.Algebraic.BLR.average_sign_mul._simp_1_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False", + "type_dependencies": [ + "AddMonoidWithOne", + "CharZero", + "Nat", + "Eq", + "HAdd.hAdd", + "instHAdd", + "AddSemigroup.toAdd", + "AddMonoid.toAddSemigroup", + "AddMonoidWithOne.toAddMonoid", + "Nat.cast", + "AddMonoidWithOne.toNatCast", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "Zero.toOfNat0", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 123, + "is_class": false, + "kind": "theorem", + "line": 120, + "module": "PCP.Algebraic.HadamardComposition", + "name": "PCP.Algebraic.HadamardComposition.eval_outputCoordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (P : Polynomial F) (x : Fin t → ZMod 2) (i : Fin t),\n (MvPolynomial.eval x) (PCP.Algebraic.HadamardComposition.outputCoordinate ρ P i) = ρ (Polynomial.eval (ρ.symm x) P) i", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.HadamardComposition.outputCoordinate", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "LinearEquiv.symm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "¬1 ≤ 3 → False", + "type_dependencies": [ + "Not", + "LE.le", + "Nat", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The tape alphabet: a bit, or a separator between arguments.\n\nA separator is needed because the machine takes one input list, while our relations and algorithms\ntake two or three bit strings. Self-delimiting encodings would avoid it at the cost of a length\nprefix; a separator symbol is the simpler convention and is fixed here once. ", + "end_line": 25, + "is_class": false, + "kind": "inductive", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym" + ], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NPTableau", + "name": "PCP.Machine.NPTableau.witnessList.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : ℕ} (w : PCP.Machine.NPTableau.BoundedWitness W), PCP.Machine.NPTableau.witnessList w = List.ofFn w.snd", + "type_dependencies": [ + "Nat", + "PCP.Machine.NPTableau.BoundedWitness", + "Eq", + "List", + "Bool", + "PCP.Machine.NPTableau.witnessList", + "List.ofFn", + "Fin.val", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Sigma.fst", + "Fin", + "Sigma.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_X_inr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R) (i : σ),\n (PCP.Algebraic.GridVanishing.substitute Y) (MvPolynomial.X (Sum.inr i)) = Y i", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "MvPolynomial.X", + "Sum.inr" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BivariateCleanRectangle", + "name": "PCP.Algebraic.BivariateCleanRectangle.rowErrors.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {I : Type u_2} [inst : Field F] [inst_1 : DecidableEq F] [inst_2 : Fintype I] (a : I → F)\n (C : I → Polynomial F) (R : F → Polynomial F) (y : F),\n PCP.Algebraic.BivariateCleanRectangle.rowErrors a C R y =\n hammingDist (fun i => Polynomial.eval (a i) (R y)) fun i => Polynomial.eval y (C i)", + "type_dependencies": [ + "Field", + "DecidableEq", + "Fintype", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "Nat", + "PCP.Algebraic.BivariateCleanRectangle.rowErrors", + "hammingDist", + "Polynomial.eval" + ], + "value_dependencies": [] + } + ], + "lean_version": "4.35.0-rc2", + "modules": [ + "PCP.Algebraic.BLR", + "PCP.Algebraic.BerlekampWelchCertificate", + "PCP.Algebraic.BinaryDifferenceConsistency", + "PCP.Algebraic.BinaryLocalCorrection", + "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "PCP.Algebraic.BinaryLocalRowDecoding", + "PCP.Algebraic.BinaryStandardLocalCorrection", + "PCP.Algebraic.BinaryZeroOnGridCorrection", + "PCP.Algebraic.BinaryZeroOnGridSoundness", + "PCP.Algebraic.BivariateAgreement", + "PCP.Algebraic.BivariateAgreementBoost", + "PCP.Algebraic.BivariateAgreementFromRectangle", + "PCP.Algebraic.BivariateCleanRectangle", + "PCP.Algebraic.BivariateColumnSelection", + "PCP.Algebraic.BivariateCrossingSoundness", + "PCP.Algebraic.CandidateCrossing", + "PCP.Algebraic.DerivedZeroOnGridSoundness", + "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "PCP.Algebraic.EncodedLineLowDegreeTest", + "PCP.Algebraic.GeneratorLowDegreeTest", + "PCP.Algebraic.GridInterpolation", + "PCP.Algebraic.GridVanishing", + "PCP.Algebraic.Hadamard", + "PCP.Algebraic.HadamardComposition", + "PCP.Algebraic.HadamardCorrection", + "PCP.Algebraic.HadamardDerivedOracle", + "PCP.Algebraic.HadamardRowDecoding", + "PCP.Algebraic.HadamardSoundness", + "PCP.Algebraic.LineTableLocalCorrection", + "PCP.Algebraic.PointLineConstant", + "PCP.Algebraic.PointLineConstants", + "PCP.Algebraic.PointLineCorrection", + "PCP.Algebraic.PointLineCrossing", + "PCP.Algebraic.PointLineEndpointConsistency", + "PCP.Algebraic.PointLineParameterError", + "PCP.Algebraic.PointLineSoundness", + "PCP.Algebraic.PolynomialDistance", + "PCP.Algebraic.PolynomialLineCharacterization", + "PCP.Algebraic.RuledSurfaceRigidity", + "PCP.Algebraic.SetMultilinear", + "PCP.Algebraic.StandardLocalCorrection", + "PCP.Algebraic.ThreeColorAlgebra", + "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "PCP.Algebraic.ThreeColorBinaryVerifier", + "PCP.Algebraic.ThreeColorCanonicalVerifier", + "PCP.Algebraic.ThreeColorFields", + "PCP.Algebraic.ThreeColorFinalAssembly", + "PCP.Algebraic.ThreeColorFullFieldSampling", + "PCP.Algebraic.ThreeColorGrid", + "PCP.Algebraic.ThreeColorParameterChoice", + "PCP.Algebraic.ThreeColorVerifier", + "PCP.Algebraic.ThreeColorVerifierCompleteness", + "PCP.Algebraic.ThreeColorVerifierSoundness", + "PCP.Algebraic.VanishingCertificate", + "PCP.Algebraic.WeightedConstraintSoundness", + "PCP.Complexity.CostModel", + "PCP.Complexity.Machine", + "PCP.Complexity.NP", + "PCP.Complexity.NPTableau", + "PCP.Complexity.ReferenceNPConverse", + "PCP.Complexity.TableauCells", + "PCP.Complexity.ThreeColorRuntime", + "PCP.Reduction.FiniteDomainConstraints", + "PCP.Reduction.NAEThreeColor", + "PCP.Reduction.NPThreeColorRuntime", + "PCP.ReverseConcrete", + "PCP.Theorem", + "PCP.Verifier.Definition", + "PCP.Verifier.ReductionResources" + ], + "provenance": { + "kind": "lean", + "text": "Read by Lean 4.35.0-rc2 from the authors' compiled modules." + } } diff --git a/papers/pcp-full-argument/links.json b/papers/pcp-full-argument/links.json index 2de1d2d..c079d15 100644 --- a/papers/pcp-full-argument/links.json +++ b/papers/pcp-full-argument/links.json @@ -1119,7 +1119,198 @@ "PCP.Algebraic.ThreeColorVerifier.colorable_of_rejection_lt": "Small rejection implies colourability", "PCP.ReferenceNP.inNP_iff_mem": "Equivalence with reference NP", "PCP.Algebraic.PointLineCrossing.crossing_eq_of_nearby_polynomial": "Crossing agreement near a polynomial", - "PCP.Algebraic.CandidateCrossing.crossing_eq": "Crossing agreement with a candidate" + "PCP.Algebraic.CandidateCrossing.crossing_eq": "Crossing agreement with a candidate", + "PCP.Algebraic.BLR.rejectionProbability": "Rejection rate of the BLR test", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial": "The difference polynomial P(a) - P(b)", + "PCP.Algebraic.BinaryDifferenceConsistency.check": "The binary difference check", + "PCP.Algebraic.BinaryDifferenceConsistency.Query": "Query locations of the difference check", + "PCP.Algebraic.BinaryDifferenceConsistency.queries": "Query list of the difference check", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate": "Rejection rate of the difference check", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint": "Points of the inner encoding", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle": "Binary table of one encoded row", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed": "Randomness of the inner test", + "PCP.Algebraic.BinaryLocalCorrection.Sample": "Randomness of outer local correction", + "PCP.Algebraic.BinaryLocalCorrection.Query": "Query locations of local correction", + "PCP.Algebraic.BinaryLocalCorrection.queries": "Query list of outer local correction", + "PCP.Algebraic.BinaryLocalCorrection.honestTable": "Honest auxiliary table at one point", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant": "Loss constant of local correction", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate": "Rejection rate of local correction", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant": "Inner decoding constant", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct": "Corrected bit from a weighted sum", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries": "Query list of weighted correction", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed": "Randomness of one correction call", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call": "One correction call at a label", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint": "Points of a certificate table", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary": "Line tables for each certificate point", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample": "Randomness of the ZERO test", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness": "ZERO randomness apart from the point", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample": "Randomness of the derived ZERO test", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed": "Drop the fresh correction seed", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit": "ZERO test given its primary bit", + "PCP.Algebraic.DerivedZeroOnGrid.check": "The derived ZERO check", + "PCP.Algebraic.DerivedZeroOnGrid.Query": "Query locations of derived ZERO", + "PCP.Algebraic.DerivedZeroOnGrid.callQueries": "Query list of one correction call", + "PCP.Algebraic.DerivedZeroOnGrid.queries": "Query list of the derived ZERO test", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerPoint": "Finitely many inner points (ZERO)", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed": "Finitely many inner seeds (ZERO)", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeCallSeedSumFin": "Finitely many call seeds (ZERO)", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeGridRandomness": "Finitely many grid seeds (ZERO)", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate": "Rejection rate of the derived ZERO test", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant": "Line error factor of the line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant": "Proximity factor of the line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines": "Lines as point and direction", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary": "Encoded line-table type", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample": "Randomness of the encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query": "Query locations of the encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected": "Corrected comparison bit", + "PCP.Algebraic.EncodedLineLowDegreeTest.test": "The encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries": "Query list of the encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable": "Honest encodings of all lines", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint": "Finitely many inner points (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed": "Finitely many inner seeds (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed": "Finitely many seed pairs (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample": "Finitely many samples (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate": "Rejection rate of the encoded-line test", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes": "Powers of the generator as nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights": "Lagrange weights at zero", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes": "Nodes from a primitive root", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate": "Inner weighted test rejection rate", + "PCP.Algebraic.GridInterpolation.basis": "Grid basis polynomial", + "PCP.Algebraic.GridInterpolation.interpolate": "Interpolating a table on the grid", + "PCP.Algebraic.GridVanishing.coordinate": "Vanishing polynomial of one coordinate", + "PCP.Algebraic.GridVanishing.VanishesOn": "Vanishing on the grid", + "PCP.Algebraic.Hadamard.encode": "The Hadamard encoding", + "PCP.Algebraic.Hadamard.encodeFunction": "Hadamard encoding of a function", + "PCP.Algebraic.Hadamard.linearEncode": "Homogeneous linear encoding", + "PCP.Algebraic.Hadamard.homogeneousIndex": "Linear queries among degree-r queries", + "PCP.Algebraic.HadamardComposition.mapCoefficients": "Apply a functional to each coefficient", + "PCP.Algebraic.HadamardComposition.coordinatePolynomial": "Field element from binary coordinates", + "PCP.Algebraic.HadamardComposition.fieldPolynomial": "A polynomial in binary coordinates", + "PCP.Algebraic.HadamardComposition.outputCoordinate": "One output coordinate as a polynomial", + "PCP.Algebraic.HadamardComposition.formalQuery": "Query after coordinate substitution", + "PCP.Algebraic.HadamardComposition.query": "Composed query in coefficients", + "PCP.Algebraic.Hadamard.selfCorrect": "The self-correction rule", + "PCP.Algebraic.HadamardDerivedOracle.answer": "Self-corrected derived answer", + "PCP.Algebraic.HadamardDerivedOracle.queries": "Query list of a derived answer", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance": "Distance of the primary table", + "PCP.Algebraic.HadamardDerivedOracle.cubic": "The cube-minus-one polynomial", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic": "Weighted cube-minus-one polynomial", + "PCP.Algebraic.Hadamard.averageRejectionRate": "Average Hadamard rejection over rows", + "PCP.Algebraic.LineTableLocalCorrection.correct": "Line-table correction at one sample", + "PCP.Algebraic.PointLineConstants.fieldFactor": "Cubic field-size factor", + "PCP.Algebraic.PointLineConstants.smallError": "Point-line rejection threshold", + "PCP.Algebraic.PointLineConstants.agreementError": "Bivariate agreement threshold", + "PCP.Algebraic.PointLineConstants.endpointError": "Endpoint prediction error", + "PCP.Algebraic.Plurality.exists_minimizer": "A most frequent value exists", + "PCP.Algebraic.Plurality.value": "A most frequent value", + "PCP.Algebraic.PointLineCrossing.axisRestrict": "Restriction to one coordinate axis", + "PCP.Algebraic.PointLineCrossing.rowPolynomial": "Row polynomial through a point", + "PCP.Algebraic.PointLineTest.rejectionAt": "Line rejection at one parameter", + "PCP.Algebraic.PolynomialLine.HasLowDegreeLines": "Low degree on every line", + "PCP.Algebraic.SetMultilinear.Variables": "Variables of the digit encoding", + "PCP.Algebraic.SetMultilinear.digitMonomial": "Digit monomial for a power", + "PCP.Algebraic.SetMultilinear.encode": "The set-multilinear digit encoding", + "PCP.Algebraic.SetMultilinear.evaluationPoint": "Digit-substitution point", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes": "Distinct nodes and a nonzero generator", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions": "Fixed repetition count", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier": "The amplified verifier", + "PCP.Algebraic.ThreeColorBinaryVerifier.Address": "Addresses in the eight tables", + "PCP.Algebraic.ThreeColorBinaryVerifier.proofLength": "Length of the binary proof word", + "PCP.Algebraic.ThreeColorBinaryVerifier.randomBits": "Random bits of the whole-field sampler", + "PCP.Algebraic.ThreeColorBinaryVerifier.ProofWord": "Binary proof words", + "PCP.Algebraic.ThreeColorBinaryVerifier.Seed": "Binary random seeds", + "PCP.Algebraic.ThreeColorBinaryVerifier.StructuredProof": "Eight-table proof at chosen sizes", + "PCP.Algebraic.ThreeColorBinaryVerifier.fieldIndex": "Field elements numbered by their bits", + "PCP.Algebraic.ThreeColorBinaryVerifier.addressEquiv": "Numbering the proof addresses", + "PCP.Algebraic.ThreeColorBinaryVerifier.decodeProof": "Read the tables from a proof word", + "PCP.Algebraic.ThreeColorBinaryVerifier.RawSeed": "Whole-field seeds", + "PCP.Algebraic.ThreeColorBinaryVerifier.seedEquiv": "Binary strings as whole-field seeds", + "PCP.Algebraic.ThreeColorBinaryVerifier.gridGraph": "The input graph placed in the grid", + "PCP.Algebraic.ThreeColorBinaryVerifier.test": "The binary verifier", + "PCP.Algebraic.ThreeColorBinaryVerifier.queries": "Query list of the binary verifier", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap": "Fixed gap of the binary verifier", + "PCP.Algebraic.ThreeColorCanonicalVerifier.graphOrder": "Vertex count of the decoded graph", + "PCP.Algebraic.ThreeColorCanonicalVerifier.vertexCode": "Numbering the decoded vertices", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBudget": "Randomness budget in input length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.randomBits_le_budget": "Random bits within the budget", + "PCP.Algebraic.ThreeColorCanonicalVerifier.sample": "Seed from a canonical random string", + "PCP.Algebraic.ThreeColorCanonicalVerifier.fieldWord": "Boolean word as binary-field bits", + "PCP.Algebraic.ThreeColorCanonicalVerifier.tree": "Query tree of the canonical verifier", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier": "The canonical verifier", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound": "Polynomial bound on proof addresses", + "PCP.Algebraic.ThreeColorFullFieldSampling.test": "The whole-field sampled test", + "PCP.Algebraic.ThreeColorFullFieldSampling.queries": "Query list of whole-field sampling", + "PCP.Algebraic.ThreeColorGrid.validPolynomial": "Vertex constraint polynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial": "Edge constraint polynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension": "Low-degree extension of the edges", + "_private.PCP.Algebraic.ThreeColorParameterChoice.0.PCP.Algebraic.ThreeColorParameterChoice.exists_exponent": "An admissible exponent exists", + "PCP.Algebraic.ThreeColorParameterChoice.exponent": "Least admissible exponent", + "PCP.Algebraic.ThreeColorVerifier.Vertex": "Points for one vertex", + "PCP.Algebraic.ThreeColorVerifier.PairPoint": "Points for a pair of vertices", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint": "Points for the edge certificate", + "PCP.Algebraic.ThreeColorVerifier.Proof": "The eight proof tables", + "PCP.Algebraic.ThreeColorVerifier.flatten": "Flattening two vertex blocks", + "PCP.Algebraic.ThreeColorVerifier.edgeValue": "Adjacency extension at a point", + "PCP.Algebraic.ThreeColorVerifier.flatDifference": "Difference table on flat coordinates", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary": "Line tables for the vertex certificate", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary": "Line tables for the edge certificate", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed": "Seven branch seed types", + "PCP.Algebraic.ThreeColorVerifier.Sample": "Randomness of the graph verifier", + "PCP.Algebraic.ThreeColorVerifier.branchTest": "Seven concrete branch tests", + "PCP.Algebraic.ThreeColorVerifier.test": "Conjunction of the seven checks", + "PCP.Algebraic.ThreeColorVerifier.Query": "Eight physical query tags", + "PCP.Algebraic.ThreeColorVerifier.colorQuery": "Tagging colour-table queries", + "PCP.Algebraic.ThreeColorVerifier.validQuery": "Tagging vertex-certificate queries", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery": "Tagging difference-table queries", + "PCP.Algebraic.ThreeColorVerifier.properQuery": "Tagging edge-certificate queries", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery": "Tagging vertex grid-check queries", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery": "Tagging edge grid-check queries", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery": "Tagging difference-check queries", + "PCP.Algebraic.ThreeColorVerifier.branchQueries": "Query lists of the seven branches", + "PCP.Algebraic.ThreeColorVerifier.queries": "Query list of the graph verifier", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint": "Finitely many inner points (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed": "Finitely many inner seeds (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeProdTestRandomnessInnerSeed": "Finitely many seed pairs (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeSampleOfDecidableEq": "Finitely many line samples (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeCallSeedOfDecidableEq": "Finitely many call seeds (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeGridRandomness": "Finitely many grid seeds (verifier)", + "PCP.Algebraic.ThreeColorVerifier.instFintypeTestSample": "Finitely many ZERO samples (verifier)", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype": "Finite seed space of each branch", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate": "Rejection rate of the graph verifier", + "PCP.Algebraic.GridVanishing.substitute": "Substitute into the second block", + "PCP.Algebraic.GridVanishing.IsCertificate": "Conditions for a vanishing certificate", + "PCP.Algebraic.WeightedConstraint.predict": "Weighted prediction along a direction", + "PCP.Algebraic.WeightedConstraint.rejectionRate": "Weighted constraint rejection rate", + "PCP.Algebraic.WeightedConstraint.correction": "The weighted plurality correction", + "PCP.Machine.NPTableau.BoundedWitness": "Witnesses of bounded length", + "PCP.Machine.NPTableau.witnessList": "A bounded witness as a bit list", + "PCP.Machine.NPTableau.Checker": "Polynomial-time checker of a relation", + "PCP.Machine.NPTableau.inputPoly": "Input length bound", + "PCP.Machine.NPTableau.timePoly": "Uniform time bound", + "PCP.Machine.NPTableau.spacePoly": "Uniform space bound", + "PCP.Machine.NPTableau.input": "Machine input for a pair", + "PCP.Machine.NPTableau.output": "Machine output for a Boolean", + "PCP.Machine.NPTableau.Assignment": "A witness with tableau rows", + "PCP.Machine.NPTableau.Accepts": "The tableau is accepting", + "PCP.Reduction.FiniteDomainConstraints.Variable": "Boolean positions of a variable", + "PCP.Reduction.FiniteDomainConstraints.Constraint": "Relations and one-hot constraints", + "PCP.Reduction.FiniteDomainConstraints.arity": "Arity of the Boolean constraints", + "PCP.Reduction.FiniteDomainConstraints.slot": "Position of one value slot", + "PCP.Reduction.FiniteDomainConstraints.inputSlot": "Slot for an input coordinate", + "PCP.Reduction.FiniteDomainConstraints.firstSlot": "Slot in the first block", + "PCP.Reduction.FiniteDomainConstraints.scope": "Positions read by each constraint", + "PCP.Reduction.FiniteDomainConstraints.Holds": "Finite-domain constraints hold", + "PCP.Reduction.FiniteDomainConstraints.relation": "One-hot truth tables", + "PCP.Reduction.NAEThreeColor.boolColor": "Colour of a Boolean value", + "PCP.Reduction.NAEThreeColor.NAE": "A not-all-equal triple", + "PCP.Reduction.NAEThreeColor.Literal": "Literals with constants", + "PCP.Reduction.NAEThreeColor.Literal.eval": "Value of a literal", + "PCP.Reduction.NAEThreeColor.Vertex": "Vertices of the NAE graph", + "PCP.Reduction.NAEThreeColor.base": "Palette triangle vertex", + "PCP.Reduction.NAEThreeColor.variableVertex": "Vertex for a variable and sign", + "PCP.Reduction.NAEThreeColor.literalVertex": "Vertex for a literal", + "PCP.Reduction.NAEThreeColor.direct": "Edges in one orientation", + "PCP.Reduction.NAEThreeColor.graph": "The graph of an NAE instance" }, "fidelity_held": "The selected source has not yet been compared against elaborated Lean statements for this page." } diff --git a/papers/pcp-full-argument/paper.toml b/papers/pcp-full-argument/paper.toml index 4496c0a..3f9298e 100644 --- a/papers/pcp-full-argument/paper.toml +++ b/papers/pcp-full-argument/paper.toml @@ -16,7 +16,7 @@ source = "https://github.com/troyjlee/tcs-formalizations/tree/a0ce13ed0fa264f051 source_name = "tcs-formalizations at a0ce13e" source_lines = "https://github.com/troyjlee/tcs-formalizations/blob/a0ce13ed0fa264f051c1278e039596ce65557fa4/{path}#L{line}-L{end}" licence = "Apache-2.0" -scope = "Selected source excerpts appear alongside retained Lean statements and the extracted reading-guide interface. Each declaration shows its source status. Proof dependencies and axiom reports are available only for records with the relevant extraction." +scope = "Lean 4.35.0-rc2 compiled the listed modules of the authors' project, and each declaration's statement, dependencies and axioms shown here are Lean's own report from those compiled modules. The links from the paper's sentences to the Lean, the plain titles and the notes were made with AI and have not been reviewed by the authors." [reading] language = "lean" diff --git a/papers/pcp-full-argument/source-review.md b/papers/pcp-full-argument/source-review.md index bdffc27..f018380 100644 --- a/papers/pcp-full-argument/source-review.md +++ b/papers/pcp-full-argument/source-review.md @@ -2,7 +2,17 @@ The shared `lean/` tree contains the PCP and `vendor/` paths, `PCP.lean`, project configuration, citation, README and licence files from `troyjlee/tcs-formalizations` at `a0ce13ed0fa264f051c1278e039596ce65557fa4`. A Git-blob comparison against that revision checked all 1,063 copied files, with no differing or extra files. The selected upstream paths contain `LICENSE`, `vendor/LICENSE`, and `vendor/LICENSE-CSLib`; no file named NOTICE occurs in those paths. See `vendor/UPSTREAM.json` for vendor provenance. -Each companion's `generated/lean.json` retains the 207 rows from `papers/pcp-reading-guide/generated/lean.json` (SHA-256 `c11f9771516b06f5486191d4ef2fbc1cbf9283291ae756e4f97b1ffeb93fc2f4`): 206 rows have `lean` provenance and the `PCP.np_subset_pcp` statement has `statement-compiled` provenance. Its statement was compiled as a surrogate in the guide's retained extraction; its proof was not built by that extraction and no proof-use edges or axiom report are supplied for it. The other selected proof declarations are source-read, with no extracted proof-use edges or axiom reports. The top-level provenance is deliberately `source-read` because the combined edition is not a fresh extraction. Per-row provenance remains in each JSON file. This record does not assert a new Lean build or independent review. +Each companion's `generated/lean.json` is Lean's report on compiled modules. On 16 November 2026 a GitHub Actions run in this repository ([run 43790700983](https://github.com/wcook04/proof-reader/actions/runs/43790700983), commit `b50cf8b632b4c0bf55060af8c2294823ee074ba0`, workflow `.github/workflows/pcp-extract.yml`) fetched Mathlib's compiled files with `lake exe cache get`, compiled the 71 PCP modules the three companions list with `lake build` at the project's toolchain (Lean 4.35.0-rc2; the log ends "Build completed successfully (4041 jobs)"), and ran `tools/extract_built.py` for each companion. That tool uses a module only when the compiled project's source is byte-identical to the copy under `papers/pcp-full-argument/lean/`. Every row has `lean` provenance, including `PCP.np_subset_pcp`, whose proof was built in this run. Dependencies, the split between statement and proof uses, and axiom reports come from those compiled modules. Across the three companions Lean reports no axioms beyond `propext`, `Classical.choice` and `Quot.sound`. + +| Report | Modules | Rows | SHA-256 | +| --- | --- | --- | --- | +| `papers/pcp-exposition/generated/lean.json` | 26 | 890 | `598e8a5d5c59924a3818838f4831d1232f138ee19cc49ccfef56ac95dd879440` | +| `papers/pcp-full-argument/generated/lean.json` | 69 | 1792 | `a0d304ad2df6105e9eae6bf40129f934b80a8586126ac759616ba1967a5a0bb5` | +| `papers/pcp-specialist/generated/lean.json` | 26 | 815 | `e30848ba23623b6db744829751234c9aee1d865fe522ea2b807a82b863bcc2af` | + +The original guide's page (`papers/pcp-reading-guide`) keeps its earlier extraction: 206 rows with `lean` provenance and a statement-only compilation of `PCP.np_subset_pcp`. + +This record says that Lean compiled these modules in that run and what it reported. It is not a review of the mathematics, and it does not establish that the papers' prose and the Lean have the same meaning. The links, plain titles and notes were made with AI and have not been reviewed by the authors; comparisons of statements with their Lean remain held. The five guide files are byte-identical to their files in the shared source tree. Their SHA-256 hashes are: diff --git a/papers/pcp-specialist/generated/lean.json b/papers/pcp-specialist/generated/lean.json index 3c0c6ad..1b5a630 100644 --- a/papers/pcp-specialist/generated/lean.json +++ b/papers/pcp-specialist/generated/lean.json @@ -1,7604 +1,36257 @@ { - "modules": [ - "PCP.Algebraic.BinaryLocalCorrectionSoundness", - "PCP.Algebraic.BinaryLocalRowDecoding", - "PCP.Algebraic.BinaryZeroOnGridSoundness", - "PCP.Algebraic.DerivedZeroOnGridSoundness", - "PCP.Algebraic.EncodedLineLowDegreeSoundness", - "PCP.Algebraic.EncodedLineLowDegreeTest", - "PCP.Algebraic.GeneratorLowDegreeTest", - "PCP.Algebraic.GridVanishing", + "declarations": [ + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Numeric field codes in the order determined by the supplied binary coordinates. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 62, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldCode", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → PCP.Algebraic.ThreeColorFields.FieldFamily k ≃ Fin (2 ^ (4 * (k + 1)))", + "type_dependencies": [ + "Nat", + "Equiv", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "Equiv.trans", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "ZMod", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "LinearEquiv.toEquiv", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instField", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instModuleZModOfNatNatElement", + "Pi.Function.module", + "Semiring.toModule", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorFields.fieldCode._proof_1", + "PCP.Algebraic.ThreeColorFields.coordinates", + "Equiv.symm", + "PCP.Algebraic.BinarySeedPadding.Seed", + "PCP.Algebraic.BinarySeedPadding.finSeedEquiv" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "Reading the first `N` bits of an oracle back out reproduces it below `N`. ", + "end_line": 219, + "is_class": false, + "kind": "theorem", + "line": 216, + "module": "PCP.Verifier.Definition", + "name": "PCP.oracleOfWitness_prefix", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (π : PCP.ProofOracle) (N : ℕ) {j : ℕ}, j < N → PCP.oracleOfWitness (List.map π (List.range N)) j = π j", + "type_dependencies": [ + "PCP.ProofOracle", + "Nat", + "LT.lt", + "instLTNat", + "Eq", + "Bool", + "PCP.oracleOfWitness", + "List.map", + "List.range" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "A proof oracle is an infinite Boolean string; `π a` is the bit at address `a`. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Verifier.Definition", + "name": "PCP.ProofOracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "Nat", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_C", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (a : R),\n (PCP.Algebraic.SetMultilinear.encode m c) (Polynomial.C a) = a • PCP.Algebraic.SetMultilinear.digitMonomial m c 0", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "RingHom", + "RingHom.instFunLike", + "Polynomial.C", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The independent inner test's average rejection is visible in actual rejection. ", + "end_line": 162, + "is_class": false, + "kind": "theorem", + "line": 137, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.average_inner_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (Finset.univ.expect fun b => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate ⋯ ρ nodes (H b)) ≤\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "LE.le", + "Rat", + "Rat.instLE", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "Pi.instFintype", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.SetMultilinear.Variables", + "instFintypeProd", + "Fin.fintype", + "instDecidableEqProd", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.costPoly", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} → PCP.Machine.NPTableau.Checker R → Polynomial ℕ → ℕ → ℕ → ℕ → ℕ → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatAtLeastTwo", + "Polynomial.instNatCast", + "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_1", + "Polynomial.X", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatNat", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_2" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodePair.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : List Bool × List Bool),\n PCP.Machine.encodePair p = PCP.Machine.ofBits p.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits p.2", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Logarithmic randomness as an upper bound: at most `a * ⌈log₂ (n + 2)⌉ + b` fair bits on\ninputs of length `n`.\n\n**This is too weak to be an efficiency hypothesis on its own.** An upper bound does not make\n`randomness` computable, and `Verifier.randomness` is an unrestricted function `ℕ → ℕ`. Take\n`randomness n = if f n then 1 else 0` for arbitrary `f`: the\nbound `LogRandomness 0 1` holds, yet the budget smuggles in an arbitrary Boolean function of the\ninput length, which an algorithm recovers just by measuring the length of the random string it is\nhanded. Use `CanonicalRandomness` wherever efficiency is at stake. ", + "end_line": 146, + "is_class": false, + "kind": "definition", + "line": 136, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.LogRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ → ℕ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "LE.le", + "instLENat", + "PCP.Verifier.randomness", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 48, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.fraction_shared_fst", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (E : W × S → Prop),\n (PCP.Algebraic.AffineLineSampling.fraction fun s => E (s.1, s.2.1)) = PCP.Algebraic.AffineLineSampling.fraction E", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.AffineLineSampling.fraction", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator_spec._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ),\n 16 ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) →\n ¬0 < Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) - 1 → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "Not", + "LT.lt", + "instLTNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → ℕ → Type (max (max u_3 u_4) u_4 u_3)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every finite field has the full multiplicative generator required by the test. ", + "end_line": 149, + "is_class": false, + "kind": "theorem", + "line": 144, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_generator", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F], ∃ ζ, IsPrimitiveRoot ζ (Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Fintype", + "Exists", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "Nat", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s =\n (List.ofFn fun i => PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i (s i)).flatten", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Eq", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.queries", + "List.flatten", + "List.ofFn", + "PCP.Algebraic.ThreeColorVerifier.branchQueries" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_X_inl", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R) (i : σ),\n (PCP.Algebraic.GridVanishing.substitute Y) (MvPolynomial.X (Sum.inl i)) = MvPolynomial.X i", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "MvPolynomial.X", + "Sum.inl" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "theorem", + "line": 29, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "0 < PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "type_dependencies": [ + "LT.lt", + "Nat", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.decodedTable._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c : ℕ} [NeZero m]\n (Q : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F),\n (∀ (uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ), (Q uv).totalDegree ≤ c) →\n ∀ (uv : (σ → F) × (σ → F)), ((PCP.Algebraic.SetMultilinear.decode m c) (Q uv)).natDegree ≤ c * m ^ c", + "type_dependencies": [ + "Field", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Prod", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 68, + "is_class": false, + "kind": "theorem", + "line": 66, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.sixteen_le_card", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), 16 ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "constructor", + "line": 79, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.CostModel" + ], + "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.extensionDegree_pos._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), ¬0 < 4 * (k + 1) → False", + "type_dependencies": [ + "Nat", + "Not", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 374, + "is_class": false, + "kind": "definition", + "line": 374, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A verifier algorithm is polynomial-time when some `FinTM2` machine computes its step function\nwithin a polynomial number of steps in the encoded input length. ", + "end_line": 73, + "is_class": false, + "kind": "definition", + "line": 69, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.PolyTimeAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.VerifierAlg → Prop", + "type_dependencies": [ + "PCP.VerifierAlg" + ], + "value_dependencies": [ + "PCP.VerifierAlg", + "Nonempty", + "Turing.TM2ComputableInPolyTime", + "Prod", + "List", + "Bool", + "Sum", + "Nat", + "PCP.Machine.Sym", + "PCP.Machine.encodeTriple", + "PCP.Machine.encodeAnswer", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 388, + "is_class": false, + "kind": "theorem", + "line": 388, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyGridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t k : ℕ}, Nonempty (PCP.Algebraic.DerivedZeroOnGrid.GridRandomness F k m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] → [(a : List Bool) → SizeOf (L a)] → PCP.NPCertificate P L → ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "PCP.NPCertificate", + "Nat" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "PCP.NPCertificate", + "PCP.NPCertificate.rec", + "Nat", + "Polynomial", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "Polynomial._sizeOf_inst", + "instSizeOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨0, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 3 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 18 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "Decidable.byContradiction", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "If the oracles agree on every address the tree can reach, the tree cannot tell them apart. ", + "end_line": 77, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (T : PCP.QueryTree d) {π π' : PCP.ProofOracle}, (∀ a ∈ T.addresses, π a = π' a) → T.eval π = T.eval π'", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Transfer to the grid verifier with honestly derived primary answers,\nusing the actual fresh randomized marginal. ", + "end_line": 198, + "is_class": false, + "kind": "theorem", + "line": 185, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejection_transfer", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (Q : (Fin n → F) → Polynomial F)\n (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) (f : (Fin n → F) → F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval (f x) (Q x))))) M A ≤\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ Q hQ nodes ζ H p M A +\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ p f", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Rat.instAdd", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Field.toCommRing", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each concrete branch has the claimed count, including fresh derived-read seeds. ", + "end_line": 359, + "is_class": false, + "kind": "theorem", + "line": 322, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (i : Fin 7)\n (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i),\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i s).length ≤\n PCP.Algebraic.ThreeColorVerifier.branchQueryBound c i", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "PCP.Algebraic.ThreeColorVerifier.branchQueryBound" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.brecOn.go", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t ×' PCP.QueryTree.below t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PProd" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.QueryTree.rec", + "PProd", + "Bool", + "PProd.mk", + "PCP.QueryTree.leaf", + "PUnit", + "PUnit.unit", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 1 →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Polynomial bound on witness length. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.witnessBound", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 481, + "is_class": false, + "kind": "theorem", + "line": 471, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_six", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 6 =\n PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate ⋯ π.color π.difference", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BinaryDifferenceConsistency.rejectionRate", + "Fin.fintype", + "instDecidableEqFin", + "Decidable.byContradiction", + "LE.le", + "instLENat", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 389, + "is_class": false, + "kind": "theorem", + "line": 389, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyTestSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t k r : ℕ}, Nonempty (PCP.Algebraic.DerivedZeroOnGrid.TestSample F k m c t r)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "A language over the binary alphabet: inputs are bit strings. ", + "end_line": 15, + "is_class": false, + "kind": "definition", + "line": 14, + "module": "PCP.Complexity.NP", + "name": "PCP.Language", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "List", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (d : ℕ) (f t : PCP.QueryTree d),\n (f.addresses ∪ t.addresses).card ≤ f.addresses.card + t.addresses.card →\n ¬(f.addresses ∪ t.addresses).card + 1 ≤ 1 + (f.addresses.card + t.addresses.card) → False", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "LE.le", + "instLENat", + "Finset.card", + "Union.union", + "Finset", + "Finset.instUnion", + "instDecidableEqNat", + "PCP.QueryTree.addresses", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instReprSym.repr", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym → ℕ → Format", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "Std.Format" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "PCP.Machine.instFintypeSym.match_5", + "Std.Format", + "Bool", + "Repr.addAppParen", + "Std.Format.group", + "Std.Format.nest", + "ite", + "Int", + "GE.ge", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.decLe", + "instOfNat", + "HAppend.hAppend", + "instHAppendOfAppend", + "Std.Format.instAppend", + "Std.Format.text", + "Std.Format.line", + "reprArg", + "instReprBool", + "Std.Format.FlattenBehavior.allOrNone", + "Unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A failed comparison also forces rejection, regardless of the inner test's outcome. ", + "end_line": 178, + "is_class": false, + "kind": "theorem", + "line": 164, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.comparison_error_le_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H fun z => ↑z) fun s =>\n f (PCP.Algebraic.PolynomialLine.point a s.1 ↑s.2.1) ((PCP.Algebraic.Hadamard.homogeneousIndex ⋯) s.2.2.1.2)) ≤\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "Units.val", + "PCP.Algebraic.PolynomialLine.point", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All mathematical field parameters for the fixed inner degree four are supplied together. ", + "end_line": 177, + "is_class": false, + "kind": "theorem", + "line": 170, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.chosen_parameters", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ),\n M ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) ∧\n Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) ≤ 16 * max 1 M ∧\n Function.Injective ⇑(PCP.Algebraic.ThreeColorFields.nodes (PCP.Algebraic.ThreeColorFields.index M)) ∧\n PCP.Algebraic.StandardLocalCorrection.GoodNodes 4\n (PCP.Algebraic.ThreeColorFields.generator (PCP.Algebraic.ThreeColorFields.index M)) ∧\n IsPrimitiveRoot (PCP.Algebraic.ThreeColorFields.cubeRoot (PCP.Algebraic.ThreeColorFields.index M)) 3", + "type_dependencies": [ + "Nat", + "And", + "LE.le", + "instLENat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Function.Injective", + "Fin", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "DFunLike.coe", + "Function.Embedding", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorFields.nodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorFields.cubeRoot" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Vertex", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → ℕ", + "type_dependencies": [ + "PCP.CostModel", + "Nat" + ], + "value_dependencies": [ + "PCP.CostModel", + "PCP.CostModel.rec", + "Nat", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Verifier algorithms running in polynomial time. ", + "end_line": 83, + "is_class": false, + "kind": "definition", + "line": 83, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.PolyTimeAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → PCP.VerifierAlg → Prop", + "type_dependencies": [ + "PCP.CostModel", + "PCP.VerifierAlg" + ], + "value_dependencies": [ + "PCP.CostModel" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeTest.0.PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p)) →\n ((p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr" + ], + "value_dependencies": [ + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk", + "PCP.NPCertificate.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval._sunfold", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "PCP.QueryTree.eval.match_1", + "Bool", + "ite", + "Eq", + "Bool.true", + "instDecidableEqBool", + "PCP.QueryTree.eval" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The `k`-bit binary expansion of a random string index, least significant bit first. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Complexity.CostModel", + "name": "PCP.bitsOfFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → Fin (2 ^ k) → List Bool", + "type_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List", + "Bool" + ], + "value_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.map", + "Bool", + "Nat.testBit", + "Fin.val", + "List.range" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨3, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 1 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 14 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {color : PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t}\n {validLines differenceLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t}\n {properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t}\n {color_1 :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {validCert_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {difference_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2}\n {properCert_1 :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2}\n {colorLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t}\n {validLines_1 differenceLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t}\n {properLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t},\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines } =\n { color := color_1, validCert := validCert_1, difference := difference_1, properCert := properCert_1,\n colorLines := colorLines_1, validLines := validLines_1, differenceLines := differenceLines_1,\n properLines := properLines_1 } →\n color = color_1 ∧\n validCert = validCert_1 ∧\n difference = difference_1 ∧\n properCert = properCert_1 ∧\n colorLines = colorLines_1 ∧\n validLines = validLines_1 ∧ differenceLines = differenceLines_1 ∧ properLines = properLines_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "theorem", + "line": 123, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_eq_zero_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c → ((PCP.Algebraic.SetMultilinear.encode m c) P = 0 ↔ P = 0)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Iff", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Polynomial.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Least numeric code of a full multiplicative generator. ", + "end_line": 95, + "is_class": false, + "kind": "definition", + "line": 92, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → PCP.Algebraic.ThreeColorFields.FieldFamily k", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorFields.FieldFamily" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.FiniteGeneratorSearch.root", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Equiv.decidableEq", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.ThreeColorFields.fieldCode", + "instDecidableEqFin", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.edgeValue.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (x : Fin (n + n) → F),\n PCP.Algebraic.ThreeColorVerifier.edgeValue H G x =\n (MvPolynomial.eval (x ∘ ⇑(PCP.Algebraic.ThreeColorVerifier.flatten n)))\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Function.comp", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 57, + "is_class": false, + "kind": "theorem", + "line": 53, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.coe_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} (H : Finset F) (a b : σ → ↥H),\n (fun i => ↑(Sum.elim a b i)) = Sum.elim (fun i => ↑(a i)) fun i => ↑(b i)", + "type_dependencies": [ + "Finset", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "Sum", + "Subtype.val", + "Sum.elim" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.difference" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual rejection with the newly sampled primary correction seed. ", + "end_line": 183, + "is_class": false, + "kind": "definition", + "line": 177, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t r : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Q : (Fin n → F) → Polynomial F) →\n (∀ (x : Fin n → F), (Q x).natDegree ≤ r) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n ((Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Option", + "Prod", + "instFintypeProd", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeGridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed._proof_1", + "Option.instDecidableEq", + "instDecidableEqProd", + "ZMod.decidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "Option.some", + "Prod.mk", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d), (PCP.QueryTree.query a f t).addresses = insert a (f.addresses ∪ t.addresses)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "Finset", + "PCP.QueryTree.addresses", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 56, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodeTriple", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (t : List Bool × List Bool × List Bool),\n (PCP.Machine.encodeTriple t).length = t.1.length + t.2.1.length + t.2.2.length + 2", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "Nat", + "List.length", + "PCP.Machine.Sym", + "PCP.Machine.encodeTriple", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(P : (List Bool → List Bool → Bool) → Prop) →\n (L : PCP.Language) →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] →\n [(a : List Bool) → SizeOf (L a)] → SizeOf (PCP.NPCertificate P L)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "SizeOf.mk", + "PCP.NPCertificate", + "PCP.NPCertificate._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n 0 ≤ PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "LE.le", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness against an honestly encoded outer polynomial. The distance on\nthe left counts both `none` and an incorrect returned bit as failures. The inner\npolynomials are decoded from arbitrary received rows without a small-error premise. ", + "end_line": 313, + "is_class": false, + "kind": "theorem", + "line": 219, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {D : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) {δ : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) ≤\n δ →\n ∀ (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a)\n fun s =>\n some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2.2.1.2)) ≤\n PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a +\n δ +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "PCP.Algebraic.Hadamard.linearEncode", + "Prod.snd", + "Prod.fst", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Both required root orders divide the multiplicative group order. ", + "end_line": 73, + "is_class": false, + "kind": "theorem", + "line": 70, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fifteen_dvd_card_sub_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), 15 ∣ Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) - 1", + "type_dependencies": [ + "Nat", + "Dvd.dvd", + "Nat.instDvd", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The common field family for the degree-four tester and the three colors. ", + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.FieldFamily", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryMaterializedField.Element", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Acceptance probability, as an exact rational: the fraction of the `2 ^ randomness` equally\nlikely random strings on which `V` accepts. ", + "end_line": 104, + "is_class": false, + "kind": "definition", + "line": 101, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → PCP.ProofOracle → ℚ", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Rat" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.acceptingRandomness", + "Rat.instPowNat", + "Rat.instOfNat" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} → ℕ → Sort (max 1 u)", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "cond", + "Nat.ble", + "PULift", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 126, + "is_class": false, + "kind": "definition", + "line": 126, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.validCert a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness for every seed of the actual seven-branch conjunction. ", + "end_line": 98, + "is_class": false, + "kind": "theorem", + "line": 82, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.test_honestProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (P : MvPolynomial (Fin n) F)\n (MVal : MvPolynomial (Fin n ⊕ Fin n) F) (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n P.totalDegree < m ^ c →\n MVal.totalDegree < m ^ c →\n MProp.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal →\n PCP.Algebraic.GridVanishing.IsCertificate H\n ((MvPolynomial.rename ⇑(PCP.Algebraic.ThreeColorVerifier.flatten n))\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)))\n MProp →\n ∀ (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G\n (PCP.Algebraic.ThreeColorVerifier.honestProof ρ P MVal MProp) s =\n true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "DFunLike.coe", + "AlgHom", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "PCP.Algebraic.ThreeColorVerifier.honestProof", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.completeAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CompleteAt x", + "type_dependencies": [ + "List", + "Bool", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Verifier.CompleteAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness at `x`: some proof is accepted with probability 1. ", + "end_line": 131, + "is_class": false, + "kind": "definition", + "line": 130, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CompleteAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → Prop", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Exists", + "PCP.ProofOracle", + "Eq", + "Rat", + "PCP.Verifier.accProb", + "OfNat.ofNat", + "Rat.instOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Exact normalized rejection of the seven-check finite verifier. ", + "end_line": 405, + "is_class": false, + "kind": "definition", + "line": 401, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F → (H : Finset F) → SimpleGraph (Fin n → ↥H) → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.FiniteConjunction.rejectionRate", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.fintype", + "instDecidableEqFin", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)),\n sizeOf\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n 1", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "SizeOf.sizeOf", + "PCP.CostModel", + "PCP.CostModel._sizeOf_inst", + "PCP.CostModel.mk", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "recursor", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n (t : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) → motive t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The common label keeps its uniform marginal when the two independent call seeds are added. ", + "end_line": 83, + "is_class": false, + "kind": "theorem", + "line": 74, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.distance_lift_labels", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} {S : Type u_3} {A : Type u_4} [inst : Fintype X] [inst_1 : Fintype W]\n [inst_2 : Fintype S] [Nonempty S] [inst_4 : DecidableEq A] (f g : X × W → A),\n (PCP.Algebraic.relativeDistance (fun s => f (s.1, s.2.1)) fun s => g (s.1, s.2.1)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "The randomness budget is **exactly** `a * ⌈log₂ (n + 2)⌉ + b`.\n\nTwo constants determine the whole budget, so it is computable by construction and carries no\ninformation of its own. This is the \"canonical computable budget\" repair: it closes the hole that\n`LogRandomness` leaves open, and it is without loss of generality because a verifier that wants\nfewer bits can ignore the surplus. ", + "end_line": 155, + "is_class": false, + "kind": "definition", + "line": 148, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CanonicalRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ → ℕ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "Eq", + "PCP.Verifier.randomness", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 375, + "is_class": false, + "kind": "definition", + "line": 375, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.exists_program._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) [DecidableEq h.tm.Λ]\n [DecidableEq h.tm.σ] [(k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)],\n PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk →\n ∀ {k a : ℕ} (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (P : PCP.Lang.Prog)\n (A C D : ℕ) (x : List Bool),\n PCP.Lang.listSize\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q) x) ≤\n A * (2 * x.length + 1) →\n ¬PCP.Lang.listSize\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q)\n x) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1 ≤\n A * (2 * x.length + 1) + Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1 →\n False", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Lang.Prog", + "LE.le", + "instLENat", + "PCP.Lang.listSize", + "PCP.Machine.NPTableauSource.input", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The virtual point-line rejection factor, after both binary decoding steps. ", + "end_line": 47, + "is_class": false, + "kind": "definition", + "line": 45, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "Rat", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instAddNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The NP checking relation induced by a verifier: accept `(x, w)` when the finite witness `w`,\nread as a proof, makes `V` accept on *every* random string.\n\nThis is decidable because the random space `Fin (2 ^ randomness)` is finite, which is the whole\npoint: perfect completeness turns into a finite check. Whether it is *polynomial-time* decidable\nis a separate question, answered by `CostModel.polyTimeRel_finiteWitnessCheck`. ", + "end_line": 210, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Verifier.Definition", + "name": "PCP.finiteWitnessCheck", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → List Bool → Bool", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Decidable.decide", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Eq", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "PCP.oracleOfWitness", + "Bool.true", + "Nat.decidableForallFin", + "instDecidableEqBool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Package a family of coefficient polynomials into one polynomial in two blocks. ", + "end_line": 77, + "is_class": false, + "kind": "definition", + "line": 75, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → [Fintype σ] → (σ → MvPolynomial σ R) → MvPolynomial (σ ⊕ σ) R", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum" + ], + "value_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Finset.sum", + "Sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "DFunLike.coe", + "AlgHom", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Sum.inl", + "MvPolynomial.X", + "Sum.inr" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The low-degree extension of the input graph's zero-one adjacency table. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 59, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [Fintype σ] → [DecidableEq σ] → [DecidableEq F] → (H : Finset F) → SimpleGraph (σ → ↥H) → MvPolynomial (σ ⊕ σ) F", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Sum", + "MvPolynomial", + "Pi.addCommMonoid", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Pi.Function.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.GridInterpolation.interpolate", + "instFintypeSum", + "instDecidableEqSum", + "ite", + "SimpleGraph.Adj", + "Sum.inl", + "Sum.inr", + "Classical.propDecidable", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 68, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.distance_shared_snd", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} {A : Type u_4} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S]\n [inst_3 : DecidableEq A] (f g : W × S → A),\n (PCP.Algebraic.relativeDistance (fun s => f (s.1, s.2.2)) fun s => g (s.1, s.2.2)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A binary relation on bit strings is polynomial-time when some `FinTM2` machine computes it\nwithin a polynomial number of steps in the encoded input length. ", + "end_line": 67, + "is_class": false, + "kind": "definition", + "line": 64, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.PolyTimeRel", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → List Bool → Bool) → Prop", + "type_dependencies": [ + "List", + "Bool" + ], + "value_dependencies": [ + "List", + "Bool", + "Nonempty", + "Turing.TM2ComputableInPolyTime", + "Prod", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Auxiliary inner rejection is another normalized marginal of actual rejection. ", + "end_line": 145, + "is_class": false, + "kind": "theorem", + "line": 114, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.inner_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n (Finset.univ.expect fun uv => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate ⋯ ρ nodes (H uv)) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "Finset.expect", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.SetMultilinear.Variables", + "Fin.fintype", + "instDecidableEqProd", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "definition", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ),\n ¬n ≤ c + 1 → ∀ (i : Fin (c + 1)), ↑i < c → ¬↑i + 1 + (n - (c + 1)) < n → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "LT.lt", + "instLTNat", + "Fin.val", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "constructor", + "line": 127, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The tree reads at most `d` bits along any branch: its address set has at most `2 ^ d - 1`\nelements, and along a single run at most `d` queries are made. ", + "end_line": 65, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (T : PCP.QueryTree d), T.addresses.card < 2 ^ d", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The full bit-input construction has one program and proved polynomial cost and output size. ", + "end_line": 116, + "is_class": false, + "kind": "theorem", + "line": 62, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.exists_program", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n ∃ P pc ps,\n ∀ (x : List Bool),\n P.run (List.map Bool.toNat x) = List.map Bool.toNat (PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x) ∧\n P.cost (List.map Bool.toNat x) ≤ Polynomial.eval x.length pc ∧\n PCP.Lang.listSize (P.run (List.map Bool.toNat x)) ≤ Polynomial.eval x.length ps", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "Exists", + "PCP.Lang.Prog", + "And", + "Eq", + "PCP.Lang.Prog.run", + "List.map", + "Bool.toNat", + "PCP.Reduction.NPThreeColorRuntime.encode", + "LE.le", + "instLENat", + "PCP.Lang.Prog.cost", + "Polynomial.eval", + "List.length", + "PCP.Lang.listSize" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Reindexing the actual full corrector sample separates its uniform requested label. ", + "end_line": 244, + "is_class": false, + "kind": "theorem", + "line": 209, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.call_failure_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (M : MvPolynomial (Fin n ⊕ Fin n) F),\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n {δ : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δ →\n ∀ (a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n),\n (PCP.Algebraic.relativeDistance\n (fun ws => PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M' A a ws.1 ws.2)\n fun ws => some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) M))) ws.1)) ≤\n (PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.AffineLineSampling.fraction fun ws =>\n PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M' A a ws.1 ws.2 = none) +\n δ +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.relativeDistance", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Pi.instFintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeCallSeedSumFin_1", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "Prod.fst", + "Prod.snd", + "Option.some", + "PCP.Algebraic.Hadamard.linearEncode", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.AffineLineSampling.fraction", + "Eq", + "Option.none", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Rat.instOfNat", + "HSub.hSub", + "instHSub", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 385, + "is_class": false, + "kind": "theorem", + "line": 385, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F] {m c t : ℕ}, Nonempty (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.eval_substitute", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R) (M : MvPolynomial (σ ⊕ σ) R) (x : σ → R),\n (MvPolynomial.eval x) ((PCP.Algebraic.GridVanishing.substitute Y) M) =\n (MvPolynomial.eval (Sum.elim x fun i => (MvPolynomial.eval x) (Y i))) M", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.GridVanishing.substitute", + "Sum.elim" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.expect_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : Fintype B] (k : A × B → ℚ),\n (Finset.univ.expect fun p => k p) = Finset.univ.expect fun a => Finset.univ.expect fun b => k (a, b)", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language}\n [inst : (a : List Bool → List Bool → Bool) → SizeOf (P a)] [inst_1 : (a : List Bool) → SizeOf (L a)]\n (witnessBound : Polynomial ℕ) (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true),\n sizeOf { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n 1 + sizeOf witnessBound + sizeOf check_polyTime", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "SizeOf", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "SizeOf.sizeOf", + "PCP.NPCertificate", + "PCP.NPCertificate._sizeOf_inst", + "PCP.NPCertificate.mk", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Polynomial._sizeOf_inst", + "instSizeOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Stop and accept (`true`) or reject (`false`). ", + "end_line": 35, + "is_class": false, + "kind": "constructor", + "line": 34, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf", + "provenance": "lean", + "structural_dependencies": [ + "PCP.QueryTree" + ], + "type": "{d : ℕ} → Bool → PCP.QueryTree d", + "type_dependencies": [ + "Nat", + "Bool", + "PCP.QueryTree" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The two grid equations are precisely the vertex and edge constraints. ", + "end_line": 114, + "is_class": false, + "kind": "theorem", + "line": 90, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.constraints_iff_satisfies", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)) (P : MvPolynomial σ F),\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) ∧\n PCP.Algebraic.GridVanishing.VanishesOn H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)) ↔\n PCP.Algebraic.ThreeColorAlgebra.Satisfies G fun a => (MvPolynomial.eval fun i => ↑(a i)) P", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Iff", + "And", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "Sum", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.ThreeColorAlgebra.Satisfies", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match d + 1, PCP.QueryTree.query a f t with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_2 d a f t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.addresses.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 52, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodePair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : List Bool × List Bool), (PCP.Machine.encodePair p).length = p.1.length + p.2.length + 1", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "Nat", + "List.length", + "PCP.Machine.Sym", + "PCP.Machine.encodePair", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every received row admits an actual bounded-degree polynomial satisfying\nboth distance bounds; there is no small-rejection hypothesis. ", + "end_line": 144, + "is_class": false, + "kind": "theorem", + "line": 106, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.exists_polynomial_distance_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {c t r : ℕ},\n 2 * c < Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (a : Fin (c + 1) → F),\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes a →\n ∀ (H : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n ∃ Q,\n Q.totalDegree ≤ c ∧\n PCP.Algebraic.relativeDistance (fun p => H p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ ((MvPolynomial.eval x) Q)) ≤\n PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c *\n PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr H fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) Q)))) ≤\n PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c *\n PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "theorem", + "line": 78, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.generator_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {ζ : F}, IsPrimitiveRoot ζ (Fintype.card F - 1) → ζ ≠ 0", + "type_dependencies": [ + "Field", + "Fintype", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "Nat", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat", + "Ne", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 24, + "is_class": false, + "kind": "constructor", + "line": 24, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.sep", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Machine.Sym" + ], + "type": "PCP.Machine.Sym", + "type_dependencies": [ + "PCP.Machine.Sym" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 52, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness with an explicit identity for the derived outer polynomial. ", + "end_line": 164, + "is_class": false, + "kind": "theorem", + "line": 151, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r)\n {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {H : Finset F} (f : (Fin n → F) → F) (P : MvPolynomial (Fin n) F),\n (∀ (x : Fin n → F), Polynomial.eval (f x) (Q x) = (MvPolynomial.eval x) P) →\n ∀ (M : MvPolynomial (Fin n ⊕ Fin n) F),\n M.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H P M →\n ∀ (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x))))\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M))))\n (PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M) s =\n some (0, 0)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "MvPolynomial", + "Eq", + "Polynomial.eval", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary", + "Option.some", + "Prod.mk", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueryBound.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ),\n PCP.Algebraic.ThreeColorVerifier.branchQueryBound c =\n ![2 * c + 18, 2 * c + 14, 2 * c + 18, 2 * c + 14, 6 * c + 20, 6 * c + 20, 3]", + "type_dependencies": [ + "Nat", + "Eq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.branchQueryBound", + "Matrix.vecCons", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Matrix.vecEmpty" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "definition", + "line": 128, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 3 →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 182, + "is_class": false, + "kind": "definition", + "line": 180, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.Query.difference" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a b : Bool), ¬a = b → PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit b → False", + "type_dependencies": [ + "Bool", + "Not", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) → Function.Injective (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Function.Injective", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n (PCP.Algebraic.SetMultilinear.encode m c) P =\n ∑ k ∈ P.support, P.coeff k • PCP.Algebraic.SetMultilinear.digitMonomial m c k", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Finset.sum", + "Polynomial.support", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "instMulZeroClassOfSemiring", + "Finsupp.instFunLike", + "Polynomial.coeff", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 416, + "is_class": false, + "kind": "theorem", + "line": 413, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.rejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n 0 ≤ PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "LE.le", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t r : ℕ} →\n [Fintype F] →\n Fintype (PCP.Algebraic.Hadamard.TestRandomness t r × PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each branch accepts the same honest eight-table proof for every seed. ", + "end_line": 79, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest_honestProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (P : MvPolynomial (Fin n) F)\n (MVal : MvPolynomial (Fin n ⊕ Fin n) F) (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n P.totalDegree < m ^ c →\n MVal.totalDegree < m ^ c →\n MProp.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal →\n PCP.Algebraic.GridVanishing.IsCertificate H\n ((MvPolynomial.rename ⇑(PCP.Algebraic.ThreeColorVerifier.flatten n))\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)))\n MProp →\n ∀ (i : Fin 7) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i),\n PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G\n (PCP.Algebraic.ThreeColorVerifier.honestProof ρ P MVal MProp) i s =\n true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "DFunLike.coe", + "AlgHom", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.branchTest", + "PCP.Algebraic.ThreeColorVerifier.honestProof", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness of the actual two-corrector grid verifier against nearby polynomial encodings.\nBoth proximity hypotheses are global homogeneous-query distances.\nThe auxiliary proof is arbitrary. ", + "end_line": 298, + "is_class": false, + "kind": "theorem", + "line": 246, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_lower_bound", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ p' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) ≤\n δP →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δM →\n (1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 ≤\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) *\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p' M' A +\n δP +\n 2 * δM +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "Fin.fintype", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instFintypeSum", + "instDecidableEqSum", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ),\n IsScalarTower R R (AddMonoidAlgebra R (PCP.Algebraic.SetMultilinear.Variables m c →₀ ℕ))", + "type_dependencies": [ + "CommSemiring", + "Nat", + "IsScalarTower", + "AddMonoidAlgebra", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "SMulZeroClass.toSMul", + "AddZero.toZero", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddMonoidWithOne.toAddMonoid", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "DistribSMul.toSMulZeroClass", + "DistribMulAction.toDistribSMul", + "Semiring.toMonoid", + "Module.toDistribMulAction", + "Semiring.toAddCommMonoid", + "Semiring.toModule", + "AddMonoidAlgebra.instAddMonoid", + "AddMonoidAlgebra.smulZeroClass" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.encode.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q q_1 : Polynomial ℕ),\n q = q_1 →\n ∀ {inst : DecidableEq h.tm.Λ} [inst_1 : DecidableEq h.tm.Λ] {inst_2 : DecidableEq h.tm.σ}\n [inst_3 : DecidableEq h.tm.σ] {inst_4 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)}\n [inst_5 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK eK_1 : h.tm.K ≃ Fin k),\n eK = eK_1 →\n ∀ (eA eA_1 : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n eA = eA_1 →\n ∀ (x x_1 : List Bool),\n x = x_1 →\n PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x =\n PCP.Reduction.NPThreeColorRuntime.encode h q_1 hs eK_1 eA_1 x_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Reduction.NPThreeColorRuntime.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.encode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (x : List Bool),\n PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x = PCP.Reduction.NPTableauGraphLang.encode h hs eK eA x ⋯", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "Eq", + "PCP.Reduction.NPThreeColorRuntime.encode", + "PCP.Reduction.NPTableauGraphLang.encode", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "PCP.Machine.NPCellConstraints.accepting_length_le" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Option (ZMod 2) → Option (ZMod 2) → Option (ZMod 2) → Sort u_1) →\n (p m₀ mZ : Option (ZMod 2)) →\n ((p m₀ mZ : ZMod 2) → motive (some p) (some m₀) (some mZ)) →\n ((x x_1 x_2 : Option (ZMod 2)) →\n (∀ (p m₀ mZ : ZMod 2), x = some p → x_1 = some m₀ → x_2 = some mZ → False) → motive x x_1 x_2) →\n motive p m₀ mZ", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "False" + ], + "value_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "False", + "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.splitter._sparseCasesOn_2", + "Nat.hasNotBit", + "Option.ctorIdx", + "Option.some.noConfusion", + "HEq", + "Eq.ndrec", + "absurd", + "Nat.land", + "Nat.shiftRight", + "Nat.eq_of_beq_eq_true", + "Eq.refl", + "Bool", + "Bool.true", + "Eq.symm" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeTest.0.PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p))\n (h_2 :\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inl p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_1 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(a : ℕ) → SizeOf (PCP.QueryTree a)", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "SizeOf.mk", + "PCP.QueryTree", + "PCP.QueryTree._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 101, + "is_class": false, + "kind": "theorem", + "line": 93, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.weights_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) → ∀ (i : Fin (c + 1)), PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i ≠ 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Ne", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 65, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.queries_length", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (u v : σ → F),\n (PCP.Algebraic.GeneratorLowDegreeTest.queries c ζ u v).length = c + 2", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "List.length", + "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries_length_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 0 (s 0)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 1 (s 1)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 2 (s 2)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 3 (s 3)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 4 (s 4)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 5 (s 5)).length +\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 6 (s 6)).length))))) ≤\n 2 * c + 18 + (2 * c + 14 + (2 * c + 18 + (2 * c + 14 + (6 * c + 20 + (6 * c + 20 + 3))))) →\n ¬(PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 0 (s 0)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 1 (s 1)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 2 (s 2)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 3 (s 3)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 4 (s 4)).length +\n ((PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 5 (s 5)).length +\n (PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G 6 (s 6)).length))))) ≤\n 20 * c + 107 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "LE.le", + "Preorder.toLE", + "Nat.instPreorder", + "AddZero.toAdd", + "AddZeroClass.toAddZero", + "AddMonoid.toAddZeroClass", + "AddCommMonoid.toAddMonoid", + "Nat.instAddCommMonoid", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "Fin.instOfNat", + "instNeZeroNatHAdd_1", + "Nat.instNeZeroSucc", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "instLENat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every language with a concrete polynomial-time witness checker belongs to\nthe exact pinned ComplexityLib nondeterministic-machine class. ", + "end_line": 30, + "is_class": false, + "kind": "theorem", + "line": 18, + "module": "PCP.Complexity.ReferenceNPConverse", + "name": "PCP.ReferenceNP.of_inNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : Complexity.Language}, PCP.InNP PCP.Machine.PolyTimeRel L → L ∈ Complexity.NP", + "type_dependencies": [ + "Complexity.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Membership.mem", + "Set", + "Set.instMembership", + "Complexity.NP" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (ctorIdx : ℕ) → (t : PCP.Machine.Sym) → ctorIdx = t.ctorIdx → PCP.Machine.Sym.ctorElimType ctorIdx → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "Eq", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.ctorElimType" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Nat", + "Eq", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.ctorElimType", + "PCP.Machine.Sym.casesOn", + "Bool", + "PULift.down", + "PCP.Machine.Sym.bit", + "Eq.ndrec", + "PCP.Machine.Sym.sep" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The witness-checking relation. ", + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → List Bool → List Bool → Bool", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.sixteen_le_card._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), ¬1 ≤ k + 1 → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every actual branch rate is bounded by the combined rate, with no branch factor. ", + "end_line": 423, + "is_class": false, + "kind": "theorem", + "line": 418, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (i : Fin 7),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π i ≤\n PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "definition", + "line": 23, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → t.ctorIdx = 0 → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "Bool", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Likewise for the proper certificate, after flattening the constraint coordinates. ", + "end_line": 80, + "is_class": false, + "kind": "definition", + "line": 77, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properAuxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F (n + n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines", + "Prod.mk", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Encoding of a verifier algorithm's answer. A halt decision is one bit; a query is the\nseparator followed by the address in binary. ", + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeAnswer", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool ⊕ ℕ → List PCP.Machine.Sym", + "type_dependencies": [ + "Sum", + "Bool", + "Nat", + "List", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Nat", + "PCP.Machine.encodeAnswer.match_1", + "List", + "PCP.Machine.Sym", + "List.cons", + "PCP.Machine.Sym.bit", + "List.nil", + "PCP.Machine.Sym.sep", + "PCP.Machine.ofBits", + "Nat.bits" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 62, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.distance_shared_fst", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} {A : Type u_4} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S]\n [inst_3 : DecidableEq A] (f g : W × S → A),\n (PCP.Algebraic.relativeDistance (fun s => f (s.1, s.2.1)) fun s => g (s.1, s.2.1)) =\n PCP.Algebraic.relativeDistance f g", + "type_dependencies": [ + "Fintype", + "Nonempty", + "DecidableEq", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 232, + "is_class": false, + "kind": "theorem", + "line": 229, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_properQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.properQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.properCert π.properLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.properQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instFintypeSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "Fintype PCP.Machine.Sym", + "type_dependencies": [ + "Fintype", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Fintype.ofEquiv", + "PCP.Machine.Sym", + "Sum", + "Bool", + "Unit", + "instFintypeSum", + "Bool.fintype", + "PUnit.fintype", + "PCP.Machine.Sym.proxyTypeEquiv" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (0 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n PCP.Algebraic.EncodedLineLowDegreeTest.read f H (Sum.inr p) = H p.1 p.2.1 p.2.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "Sum.inr", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 155, + "is_class": false, + "kind": "theorem", + "line": 152, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n 0 ≤ PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Every extension exponent is positive, including the first member. ", + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 37, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.extensionDegree_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), 0 < 4 * (k + 1)", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Complete runtime certificate for the production amplified verifier. ", + "end_line": 15, + "is_class": false, + "kind": "theorem", + "line": 10, + "module": "PCP.Complexity.ThreeColorRuntime", + "name": "PCP.Lang.ThreeColorRuntime.polyTimeAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.PolyTimeAlg PCP.Algebraic.ComputableThreeColorAmplifiedQueryAlgorithm.algorithm", + "type_dependencies": [ + "PCP.Machine.PolyTimeAlg", + "PCP.Algebraic.ComputableThreeColorAmplifiedQueryAlgorithm.algorithm" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "SizeOf PCP.Verifier", + "type_dependencies": [ + "SizeOf", + "PCP.Verifier" + ], + "value_dependencies": [ + "SizeOf.mk", + "PCP.Verifier", + "PCP.Verifier._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual freshly randomized derived-grid verifier has perfect completeness. ", + "end_line": 242, + "is_class": false, + "kind": "theorem", + "line": 230, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : NeZero m] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {H : Finset F} (f : (Fin n → F) → F) (P : MvPolynomial (Fin n) F),\n (∀ (x : Fin n → F), Polynomial.eval (f x) (Q x) = (MvPolynomial.eval x) P) →\n ∀ (M : MvPolynomial (Fin n ⊕ Fin n) F),\n M.totalDegree < m ^ c →\n PCP.Algebraic.GridVanishing.IsCertificate H P M →\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ Q hQ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x))))\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M))))\n (PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M) =\n 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "MvPolynomial", + "Eq", + "Polynomial.eval", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.GridVanishing.IsCertificate", + "Field.toCommRing", + "Rat", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_monomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ) (a : R),\n (PCP.Algebraic.SetMultilinear.encode m c) ((Polynomial.monomial k) a) =\n a • PCP.Algebraic.SetMultilinear.digitMonomial m c k", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.monomial", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.queries_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.queries = PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 187", + "type_dependencies": [ + "Eq", + "Nat", + "PCP.Verifier.queries", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → ℕ", + "type_dependencies": [ + "PCP.CostModel", + "Nat" + ], + "value_dependencies": [ + "PCP.CostModel" + ] + }, + { + "axioms": [], + "doc": "A bit string as tape symbols. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.ofBits", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "List", + "Bool", + "List.map", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ] + }, + { + "axioms": [], + "doc": "Run the decision tree against a proof oracle. ", + "end_line": 44, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "PCP.QueryTree.brecOn", + "Bool", + "PCP.QueryTree.eval._f" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} {a_2 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.properCert a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The four primary tables and their four shared encoded-line tables. ", + "end_line": 45, + "is_class": false, + "kind": "inductive", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Read an actual query from the degree-`r` primary oracle or certificate proof. ", + "end_line": 109, + "is_class": false, + "kind": "definition", + "line": 104, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t r : ℕ} →\n ((Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t →\n PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t r → ZMod 2", + "type_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.Query" + ], + "value_dependencies": [ + "Nat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.DerivedZeroOnGrid.read.match_1", + "Prod", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "PCP.Algebraic.BinaryLocalCorrection.read" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "Bound on the number of proof **bits** read (bits, not larger proof symbols). ", + "end_line": 89, + "is_class": false, + "kind": "definition", + "line": 89, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} {S : Type u_3} (p : X → W → ZMod 2) (a b : X → W → S → Option (ZMod 2))\n (s : X × W × S × S),\n PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck p a b s =\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck (some (p s.1 s.2.1)) (a s.1 s.2.1 s.2.2.1) (b s.1 s.2.1 s.2.2.2)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Prod", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Prop) (x : ℕ) (x_1 : PCP.QueryTree x),\n (∀ (x : ℕ) (accept : Bool), motive x (PCP.QueryTree.leaf accept)) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d), motive d.succ (PCP.QueryTree.query a f t)) → motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "Nat.succ", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "Nat.succ", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "Eq", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 46, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.fraction_prod", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} [inst : Fintype X] [inst_1 : Fintype W] (E : X × W → Prop),\n PCP.Algebraic.AffineLineSampling.fraction E =\n Finset.univ.expect fun x => PCP.Algebraic.AffineLineSampling.fraction fun w => E (x, w)", + "type_dependencies": [ + "Fintype", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.AffineLineSampling.fraction", + "instFintypeProd", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → PCP.CostModel → PCP.CostModel → Sort u", + "type_dependencies": [ + "PCP.CostModel" + ], + "value_dependencies": [ + "PCP.CostModel", + "PCP.CostModel.casesOn", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.weights.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (c : ℕ) (ζ : F),\n PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ =\n PCP.Algebraic.LagrangeConstraint.weight (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) 0", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "PCP.Algebraic.LagrangeConstraint.weight", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "theorem", + "line": 125, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) = 16 ^ max 1 (Nat.clog 16 M)", + "type_dependencies": [ + "Nat", + "Eq", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each branch's physical queries occur in the complete list. ", + "end_line": 298, + "is_class": false, + "kind": "theorem", + "line": 292, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.mem_queries_of_branch", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t) (i : Fin 7)\n {q : PCP.Algebraic.ThreeColorVerifier.Query F n m c t},\n q ∈ PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i (s i) →\n q ∈ PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "PCP.Algebraic.ThreeColorVerifier.queries" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness: a polynomial-time relation is computable. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 85, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.polyTimeRel_computable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (self : PCP.CostModel) (R : List Bool → List Bool → Bool), self.PolyTimeRel R → Computable₂ R", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.CostModel.PolyTimeRel", + "Computable₂", + "Primcodable.list", + "Primcodable.bool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.1, extended linearly to all univariate polynomials. ", + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] →\n (m : ℕ) → [NeZero m] → (c : ℕ) → Polynomial R →ₗ[R] MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial.lsum", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.smulRight", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.SetMultilinear.encode._proof_1", + "LinearMap.id", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "Fair random bits used on inputs of length `n`. ", + "end_line": 87, + "is_class": false, + "kind": "definition", + "line": 87, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.randomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 168, + "is_class": false, + "kind": "definition", + "line": 167, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.chosenCoordinates", + "provenance": "lean", + "structural_dependencies": [], + "type": "(M : ℕ) →\n PCP.Algebraic.ThreeColorFields.Chosen M ≃ₗ[ZMod 2] Fin (PCP.Algebraic.ThreeColorFields.binaryDimension M) → ZMod 2", + "type_dependencies": [ + "Nat", + "LinearEquiv", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "PCP.Algebraic.ThreeColorFields.Chosen", + "Fin", + "PCP.Algebraic.ThreeColorFields.binaryDimension", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.index", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instModuleZModOfNatNatElement", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorFields.coordinates", + "PCP.Algebraic.ThreeColorFields.index" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every location read by the tester, including the primary Hadamard check. ", + "end_line": 69, + "is_class": false, + "kind": "definition", + "line": 59, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n 1 ≤ r →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r →\n List (PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "List", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "HAppend.hAppend", + "List", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.Hadamard.testQueries", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "List.cons", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "List.nil" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 40, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.eval_coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ) (x : σ → R),\n (MvPolynomial.eval x) (PCP.Algebraic.GridVanishing.coordinate H i) = ∏ a ∈ H, (x i - a)", + "type_dependencies": [ + "CommRing", + "Finset", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.GridVanishing.coordinate", + "Finset.prod", + "CommRing.toCommMonoid", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "CommRing.toRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.predecessor_volume_lt._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ},\n 2 < PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1 < PCP.Algebraic.ThreeColorParameterChoice.exponent N → False", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Not", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u_2) →\n (x : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ((x : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color x q)) →\n ((x : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert x q)) →\n ((x : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference x q)) →\n ((x : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert x q)) →\n ((uv : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine uv x q)) →\n ((uv :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine uv x q)) →\n ((uv :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine uv x q)) →\n ((uv :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine uv x q)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Closure: an efficiently implemented verifier with logarithmic randomness and a polynomial\nproof-length bound induces a polynomial-time NP checking relation.\n\nThis is the bridge between verifier efficiency and NP-checker efficiency.\nDischarging it means showing the model is closed under: enumerating `2 ^ O(log n)` random\nstrings, unfolding a constant-depth query tree, and indexing a polynomially long witness.\n\nThe budget hypothesis is `CanonicalRandomness`, **not** `LogRandomness`. With only an upper\nbound this field is not justifiable for any standard model: an arbitrary `f : ℕ → Bool` can be\nhidden in the budget (see `Verifier.LogRandomness`) and recovered by an elementary\nlength-measuring algorithm, so the field would assert that every unary language has a computable\nchecking relation. A canonical budget is determined by `a` and `b` and carries no such\ninformation. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 104, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.polyTimeRel_finiteWitnessCheck", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (self : PCP.CostModel) (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n self.PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → self.PolyTimeRel (PCP.finiteWitnessCheck V)", + "type_dependencies": [ + "PCP.CostModel", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.CostModel.PolyTimeAlg", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.CostModel.PolyTimeRel", + "PCP.finiteWitnessCheck" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) →\n (x : ℕ) → Nat.below (motive := fun x => List Bool → PCP.QueryTree x) x → List Bool → PCP.QueryTree x", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Nat.below", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Nat.below", + "PCP.QueryTree", + "PCP.QueryTree.ofStep.match_3", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.ofStep.match_1", + "PCP.QueryTree.leaf", + "Bool.false", + "Nat.succ", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.QueryTree.query", + "PProd", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "List.nil", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Exactly the five consecutive noncentral generator powers in the paper. ", + "end_line": 110, + "is_class": false, + "kind": "definition", + "line": 107, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.nodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → Fin 5 ↪ PCP.Algebraic.ThreeColorFields.FieldFamily k", + "type_dependencies": [ + "Nat", + "Function.Embedding", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorFields.FieldFamily" + ], + "value_dependencies": [ + "Nat", + "Function.Embedding.mk", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator", + "PCP.Algebraic.ThreeColorFields.nodes._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "All grid randomness except its outer point. ", + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 27, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → Type (max 0 u_2)", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Prod", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep._sunfold", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree.ofStep.match_3", + "PCP.QueryTree", + "PCP.QueryTree.ofStep.match_1", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.leaf", + "Bool.false", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.QueryTree.query", + "PCP.QueryTree.ofStep", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "List.nil", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`L` is in NP relative to the polynomial-time-checkability notion `P`. ", + "end_line": 43, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Complexity.NP", + "name": "PCP.InNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Prop", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Nonempty", + "PCP.NPCertificate" + ] + }, + { + "axioms": [], + "doc": "The selected binary coordinate count. ", + "end_line": 161, + "is_class": false, + "kind": "definition", + "line": 160, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.binaryDimension", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.index" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 382, + "is_class": false, + "kind": "definition", + "line": 382, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeGridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n [Fintype F] → [DecidableEq F] → {k : ℕ} → Fintype (PCP.Algebraic.DerivedZeroOnGrid.GridRandomness F k m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.instFintypeCallSeedOfDecidableEq", + "instFintypeSum", + "instDecidableEqSum" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 53, + "is_class": false, + "kind": "definition", + "line": 52, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat" + ], + "value_dependencies": [ + "Field", + "Nat", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.GeneratorLowDegreeTest.correct" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.digitMonomial m c k = ∏ i, MvPolynomial.X (i, PCP.Algebraic.digit m k ↑i)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "Finset.prod", + "Fin", + "CommSemiring.toCommMonoid", + "AddMonoidAlgebra.commSemiring", + "Finsupp", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "MvPolynomial.X", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n ℕ → Sort (max 1 (imax (u_2 + 1) u) (imax (u_2 + 1) (u_2 + 1) u))", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "cond", + "Nat.ble", + "PULift", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 79, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (Y Q : σ → MvPolynomial σ R),\n (PCP.Algebraic.GridVanishing.substitute Y) (PCP.Algebraic.GridVanishing.certificate Q) = ∑ i, Q i * Y i", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "PCP.Algebraic.GridVanishing.certificate", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "constructor", + "line": 30, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.NPCertificate" + ], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every concrete NP language has a certified program computing its encoded graph reduction. ", + "end_line": 265, + "is_class": false, + "kind": "theorem", + "line": 256, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.of_inNP_program", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language},\n PCP.InNP PCP.Machine.PolyTimeRel L →\n ∃ f p P C d,\n ∀ (x : List Bool),\n P.run (List.map Bool.toNat x) = List.map Bool.toNat (f x) ∧\n P.cost (List.map Bool.toNat x) ≤ C * (x.length + 1) ^ d ∧\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧\n (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "List", + "Bool", + "Polynomial", + "Nat", + "Nat.instSemiring", + "PCP.Lang.Prog", + "And", + "Eq", + "PCP.Lang.Prog.run", + "List.map", + "Bool.toNat", + "LE.le", + "instLENat", + "PCP.Lang.Prog.cost", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "OfNat.ofNat", + "instOfNatNat", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.validPolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F),\n PCP.Algebraic.ThreeColorGrid.validPolynomial P = P ^ 3 - 1", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "AddMonoidAlgebra.semiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidAlgebra.zero", + "Finsupp.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "SizeOf PCP.Machine.Sym", + "type_dependencies": [ + "SizeOf", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "SizeOf.mk", + "PCP.Machine.Sym", + "PCP.Machine.Sym._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An actual `FinTM2` realizes the complete construction at the unchanged public bit encoding. ", + "end_line": 143, + "is_class": false, + "kind": "theorem", + "line": 134, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.polyTimeMap", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits (PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits", + "PCP.Reduction.NPThreeColorRuntime.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 24, + "is_class": false, + "kind": "definition", + "line": 24, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.sep.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} → (t : PCP.Machine.Sym) → t.ctorIdx = 1 → motive PCP.Machine.Sym.sep → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Nat", + "PCP.Machine.Sym.ctorIdx", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le_log_add_one._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), max 8 (Nat.clog 2 N) ≤ 8 * (Nat.clog 2 N + 1) → ¬4 * max 8 (Nat.clog 2 N) ≤ 32 * (Nat.clog 2 N + 1) → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "Preorder.toLE", + "Nat.instPreorder", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The selected cardinality meets the requested threshold, also at zero. ", + "end_line": 133, + "is_class": false, + "kind": "theorem", + "line": 129, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.le_card_chosen", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), M ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The two fresh primary queries followed by both unchanged certificate query lists. ", + "end_line": 83, + "is_class": false, + "kind": "definition", + "line": 73, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Q : (Fin n → F) → Polynomial F) →\n (∀ (x : Fin n → F), (Q x).natDegree ≤ r) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r →\n List (PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t r)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.DerivedZeroOnGrid.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "HAppend.hAppend", + "List", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.HadamardDerivedOracle.queries", + "Field.toCommRing", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "PCP.Algebraic.DerivedZeroOnGrid.callQueries", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Lemma 3.3 for the generator-weighted test, strengthened to the linear field-size\nhypothesis `q > 2c` (the paper assumes `q > C*c^3`). ", + "end_line": 292, + "is_class": false, + "kind": "theorem", + "line": 272, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F} [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ],\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : (σ → F) → F) {δ : ℚ},\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f ≤ δ →\n δ < 1 / (2 * (↑c + 2) ^ 2) →\n ∃ P, P.totalDegree ≤ c ∧ (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤ 2 * δ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t} →\n {validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t} →\n {properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t} →\n {color' :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {validCert' :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {difference' :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2} →\n {properCert' :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2} →\n {colorLines' : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t} →\n {validLines' differenceLines' :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t} →\n {properLines' :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c\n t} →\n { color := color, validCert := validCert, difference := difference,\n properCert := properCert, colorLines := colorLines, validLines := validLines,\n differenceLines := differenceLines, properLines := properLines } =\n { color := color', validCert := validCert', difference := difference',\n properCert := properCert', colorLines := colorLines', validLines := validLines',\n differenceLines := differenceLines', properLines := properLines' } →\n (color ≍ color' →\n validCert ≍ validCert' →\n difference ≍ difference' →\n properCert ≍ properCert' →\n colorLines ≍ colorLines' →\n validLines ≍ validLines' →\n differenceLines ≍ differenceLines' → properLines ≍ properLines' → P) →\n P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.WeightedConstraint.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {V : Type u_2} {I : Type u_3} [inst : Field F] [inst_1 : AddCommGroup V] [inst_2 : _root_.Module F V]\n [inst_3 : Fintype I] [inst_4 : DecidableEq F] [inst_5 : Fintype V] (a w : I → F) (f : V → F),\n PCP.Algebraic.WeightedConstraint.rejectionRate a w f =\n PCP.Algebraic.relativeDistance (fun s => f s.1) fun s => PCP.Algebraic.WeightedConstraint.predict a w f s.1 s.2", + "type_dependencies": [ + "Field", + "AddCommGroup", + "Module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddCommGroup.toAddCommMonoid", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Prod.fst", + "PCP.Algebraic.WeightedConstraint.predict", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.generator_ne_zero._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Fintype F], 1 < Fintype.card F → Fintype.card F - 1 = 0 → False", + "type_dependencies": [ + "Fintype", + "LT.lt", + "Nat", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Program-bearing NP certificate reduction, ready for actual verifier preprocessing. ", + "end_line": 254, + "is_class": false, + "kind": "theorem", + "line": 243, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.of_certificate_program", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language} (cert : PCP.NPCertificate PCP.Machine.PolyTimeRel L),\n ∃ f p P C d,\n ∀ (x : List Bool),\n P.run (List.map Bool.toNat x) = List.map Bool.toNat (f x) ∧\n P.cost (List.map Bool.toNat x) ≤ C * (x.length + 1) ^ d ∧\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧ (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "PCP.Language", + "PCP.NPCertificate", + "PCP.Machine.PolyTimeRel", + "Exists", + "List", + "Bool", + "Polynomial", + "Nat", + "Nat.instSemiring", + "PCP.Lang.Prog", + "And", + "Eq", + "PCP.Lang.Prog.run", + "List.map", + "Bool.toNat", + "LE.le", + "instLENat", + "PCP.Lang.Prog.cost", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "OfNat.ofNat", + "instOfNatNat", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (5 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 163, + "is_class": false, + "kind": "theorem", + "line": 161, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents_apply", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (c k : ℕ) (i : Fin c) (j : Fin m),\n (PCP.Algebraic.SetMultilinear.digitExponents m c k) (i, j) = if PCP.Algebraic.digit m k ↑i = j then 1 else 0", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Fin", + "Eq", + "DFunLike.coe", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "Finsupp.instFunLike", + "PCP.Algebraic.SetMultilinear.digitExponents", + "Prod.mk", + "ite", + "PCP.Algebraic.digit", + "Fin.val", + "instDecidableEqFin", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 85, + "is_class": false, + "kind": "constructor", + "line": 85, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Verifier" + ], + "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "constructor", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The center and the `c+1` generator positions are all the queried values. ", + "end_line": 62, + "is_class": false, + "kind": "definition", + "line": 60, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → (σ → F) → (σ → F) → List (σ → F)", + "type_dependencies": [ + "Field", + "Nat", + "List" + ], + "value_dependencies": [ + "Field", + "Nat", + "List.cons", + "List.ofFn", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨1, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 1 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 14 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ], + "value_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk", + "PCP.CostModel.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every branch uses only its own mapped physical query list. ", + "end_line": 290, + "is_class": false, + "kind": "theorem", + "line": 258, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π π' : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (i : Fin 7)\n (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i),\n (∀ q ∈ PCP.Algebraic.ThreeColorVerifier.branchQueries ρ nodes ζ H G i s,\n PCP.Algebraic.ThreeColorVerifier.read π q = PCP.Algebraic.ThreeColorVerifier.read π' q) →\n PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G π i s =\n PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G π' i s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.read", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.ProofOracle) (b : Bool), (PCP.QueryTree.leaf b).eval x_1 = b", + "type_dependencies": [ + "Nat", + "PCP.ProofOracle", + "Bool", + "Eq", + "PCP.QueryTree.eval", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval._unsafe_rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "PCP.QueryTree.eval.match_1", + "Bool", + "ite", + "Eq", + "Bool.true", + "instDecidableEqBool", + "PCP.QueryTree.eval._unsafe_rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.canonicalRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CanonicalRandomness\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000)\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000)", + "type_dependencies": [ + "PCP.Verifier.CanonicalRandomness", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HMul.hMul", + "Nat", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (π : PCP.ProofOracle) (h_1 : (x : ℕ) → (b : Bool) → (x_1 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_1)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match d + 1, PCP.QueryTree.query a f t, π with\n | x, PCP.QueryTree.leaf b, x_1 => h_1 x b x_1\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_2 d a f t π", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.eval.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 80, + "is_class": false, + "kind": "theorem", + "line": 73, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.totalDegree_coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R) (i : σ),\n (PCP.Algebraic.GridVanishing.coordinate H i).totalDegree = H.card", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "Eq", + "Nat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.GridVanishing.coordinate", + "Finset.card" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : PCP.ProofOracle) (d a : ℕ) (f t : PCP.QueryTree d),\n (PCP.QueryTree.query a f t).eval x = if x a = true then t.eval x else f.eval x", + "type_dependencies": [ + "PCP.ProofOracle", + "Nat", + "PCP.QueryTree", + "Eq", + "Bool", + "PCP.QueryTree.eval", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "ite", + "Bool.true", + "instDecidableEqBool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.certificate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (Q : σ → MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.certificate Q = ∑ i, (MvPolynomial.rename Sum.inl) (Q i) * MvPolynomial.X (Sum.inr i)", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "Sum", + "PCP.Algebraic.GridVanishing.certificate", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "DFunLike.coe", + "AlgHom", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Sum.inl", + "MvPolynomial.X", + "Sum.inr" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.sample.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F)\n (s : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a s =\n PCP.Algebraic.BinaryLocalCorrection.run ρ nodes ζ f H a s.1 s.2.1 s.2.2.1.1 s.2.2.1.2 s.2.2.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.run._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "PCP.Algebraic.BinaryLocalCorrection.run", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{a : ℕ} → PCP.QueryTree a → ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.rec", + "Bool", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "instSizeOfNat", + "Bool._sizeOf_inst" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The input bound in the paper's `degree ≤ d`, `d < m ^ c` form. ", + "end_line": 113, + "is_class": false, + "kind": "theorem", + "line": 109, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_encode_of_degree_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c →\n ∀ (P : Polynomial R),\n P.natDegree ≤ d →\n ∀ (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n ((PCP.Algebraic.SetMultilinear.encode m c) P) =\n Polynomial.eval x P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Polynomial", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "LinearMap", + "RingHom.id", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The public adjacency extension, on the flattened pair of vertex coordinates. ", + "end_line": 54, + "is_class": false, + "kind": "definition", + "line": 50, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.edgePolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [inst : Field F] → {n : ℕ} → (H : Finset F) → SimpleGraph (Fin n → ↥H) → MvPolynomial (Fin (n + n)) F", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "DFunLike.coe", + "AlgHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "AddMonoidAlgebra.semiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "`alg` implements `V`: unfolding the algorithm reproduces `V`'s decision tree on every input and\nevery random string.\n\nThis ties the certificate to *this* verifier — its random-bit handling (`bitsOfFin`), its query\naddresses, and its decision rule all have to match. Proving some unrelated verifier efficient\nwould not discharge it. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Complexity.CostModel", + "name": "PCP.Verifier.ImplementedBy", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → PCP.VerifierAlg → Prop", + "type_dependencies": [ + "PCP.Verifier", + "PCP.VerifierAlg" + ], + "value_dependencies": [ + "PCP.Verifier", + "PCP.VerifierAlg", + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Eq", + "PCP.QueryTree", + "PCP.Verifier.queries", + "PCP.QueryTree.ofStep", + "PCP.bitsOfFin", + "List.nil", + "PCP.Verifier.run" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} {a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3},\n PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.difference a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.below", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → {a : ℕ} → PCP.QueryTree a → Sort (max 1 u)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.rec", + "Bool", + "PUnit", + "PProd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.HadamardDerivedOracle.queries.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : CommRing F] [inst_1 : Algebra (ZMod 2) F] {t r : ℕ} (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (P P_1 : Polynomial F) (e_P : P = P_1) (hP : P.natDegree ≤ r)\n (L L_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n L = L_1 →\n ∀ (R R_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n R = R_1 →\n PCP.Algebraic.HadamardDerivedOracle.queries ρ P hP L R =\n PCP.Algebraic.HadamardDerivedOracle.queries ρ_1 P_1 ⋯ L_1 R_1", + "type_dependencies": [ + "CommRing", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "List", + "PCP.Algebraic.HadamardDerivedOracle.queries", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n ¬PCP.Algebraic.ThreeColorParameterChoice.exponent N = 2 →\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬2 < PCP.Algebraic.ThreeColorParameterChoice.exponent N → False", + "type_dependencies": [ + "Nat", + "Not", + "Eq", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 168, + "is_class": false, + "kind": "theorem", + "line": 165, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial_eq_monomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.digitMonomial m c k =\n (MvPolynomial.monomial (PCP.Algebraic.SetMultilinear.digitExponents m c k)) 1", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "MvPolynomial.monomial", + "PCP.Algebraic.SetMultilinear.digitExponents", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.corrected.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (ζ : F) (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H s =\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H s.1)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c s.2.1) s.2.2.1.1 s.2.2.1.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses._unsafe_rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.addresses.match_1", + "Finset", + "Bool", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "PCP.QueryTree.addresses._unsafe_rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 75, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.exists_primitive_cube_root", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), ∃ ω, IsPrimitiveRoot ω 3", + "type_dependencies": [ + "Nat", + "Exists", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "View the same difference oracle on flattened coordinates. ", + "end_line": 71, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n (Fin (n + n) → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.GridCoordinateTransport.rows", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every individual variable has degree at most one. ", + "end_line": 198, + "is_class": false, + "kind": "theorem", + "line": 192, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.degreeOf_encode_le_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R)\n (ij : PCP.Algebraic.SetMultilinear.Variables m c),\n MvPolynomial.degreeOf ij ((PCP.Algebraic.SetMultilinear.encode m c) P) ≤ 1", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.SetMultilinear.Variables", + "LE.le", + "instLENat", + "MvPolynomial.degreeOf", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries),\n sizeOf { randomness := randomness, queries := queries, run := run } = 1 + sizeOf queries", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "SizeOf.sizeOf", + "PCP.Verifier", + "PCP.Verifier._sizeOf_inst", + "PCP.Verifier.mk", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "instSizeOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.read f H (Sum.inl p) = f p.1 p.2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Prod", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.index_add_one._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), ¬max 1 (Nat.clog 16 M) - 1 + 1 = max 1 (Nat.clog 16 M) → False", + "type_dependencies": [ + "Nat", + "Not", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "definition", + "line": 128, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.acceptance_pow_le_half", + "provenance": "lean", + "structural_dependencies": [], + "type": "(1 - PCP.Algebraic.ThreeColorBinaryVerifier.gap) ^ PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions ≤ 1 / 2", + "type_dependencies": [ + "LE.le", + "Rat", + "Rat.instLE", + "HPow.hPow", + "Nat", + "instHPow", + "Rat.instPowNat", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 126, + "is_class": false, + "kind": "constructor", + "line": 126, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 56, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n (PCP.Algebraic.SetMultilinear.encode m c) 1 = PCP.Algebraic.SetMultilinear.digitMonomial m c 0", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest_honestProof._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} {m c : ℕ} (P : MvPolynomial (Fin n) F) (MVal : MvPolynomial (Fin n ⊕ Fin n) F)\n (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F), ¬1 ≤ 3 → False", + "type_dependencies": [ + "Field", + "Nat", + "MvPolynomial", + "Fin", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 182, + "is_class": false, + "kind": "theorem", + "line": 176, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial_isSetMultilinear", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.IsSetMultilinear m c (PCP.Algebraic.SetMultilinear.digitMonomial m c k)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.SetMultilinear.IsSetMultilinear", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.expect_shared_fst", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (f : W × S → ℚ),\n (Finset.univ.expect fun s => f (s.1, s.2.1)) = Finset.univ.expect fun s => f s", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "PCP.Verifier.rec", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "SizeOf.sizeOf", + "instSizeOfNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An averaged rejection guarantee follows from genuine per-target corrector bounds. ", + "end_line": 194, + "is_class": false, + "kind": "theorem", + "line": 97, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.two_corrector_rejection_bound", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {X : Type u_1} {W : Type u_2} {S : Type u_3} [inst : Fintype X] [Nonempty X] [inst_2 : Fintype W] [inst_3 : Fintype S]\n [Nonempty S] (p P A B : X → W → ZMod 2) (a b : X → W → S → Option (ZMod 2)) {K ν ε : ℚ},\n 0 ≤ K →\n (∀ (x : X),\n (PCP.Algebraic.relativeDistance (fun ws => a x ws.1 ws.2) fun ws => some (A x ws.1)) ≤\n (K * PCP.Algebraic.AffineLineSampling.fraction fun ws => a x ws.1 ws.2 = none) + ν) →\n (∀ (x : X),\n (PCP.Algebraic.relativeDistance (fun ws => b x ws.1 ws.2) fun ws => some (B x ws.1)) ≤\n (K * PCP.Algebraic.AffineLineSampling.fraction fun ws => b x ws.1 ws.2 = none) + ν) →\n (PCP.Algebraic.relativeDistance (fun xw => p xw.1 xw.2) fun xw => P xw.1 xw.2) ≤ ε →\n (PCP.Algebraic.relativeDistance\n (fun xw => PCP.Algebraic.BinaryZeroOnGrid.checkBits (P xw.1 xw.2) (A xw.1 xw.2) (B xw.1 xw.2)) fun x =>\n (0, 0)) ≤\n ((1 + 2 * K) *\n PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck p a b) fun x =>\n some (0, 0)) +\n ε +\n 2 * ν", + "type_dependencies": [ + "Fintype", + "Nonempty", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Rat", + "LE.le", + "Rat.instLE", + "Rat.instOfNat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Option.instDecidableEq", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "Option.some", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "PCP.Algebraic.AffineLineSampling.fraction", + "Eq", + "Option.none", + "instDecidableEqProd", + "PCP.Algebraic.BinaryZeroOnGrid.checkBits", + "Prod.mk", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "The least admissible exponent; the witness is proved for every input size. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Nat.find", + "And", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "instDecidableAnd", + "Nat.decLe", + "_private.PCP.Algebraic.ThreeColorParameterChoice.0.PCP.Algebraic.ThreeColorParameterChoice.exists_exponent" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), ¬M ≤ 1 → ¬1 ≤ M → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → PCP.Machine.Sym → PCP.Machine.Sym → Sort u", + "type_dependencies": [ + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.Sym.casesOn", + "Bool", + "Eq" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym → ℕ", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.Sym.rec", + "Nat", + "Bool", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "SizeOf.sizeOf", + "Bool._sizeOf_inst" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)),\n 5 * ((H.card - 1) * n) < m ^ c →\n ∀ (P : MvPolynomial (Fin n) F),\n P.totalDegree ≤ (H.card - 1) * n →\n ∀ (MVal : MvPolynomial (Fin n ⊕ Fin n) F) (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n ¬P.totalDegree < m ^ c → False", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 135, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c t r : ℕ} (Q : (Fin n → F) → Polynomial F),\n (∀ (x : Fin n → F), (Q x).natDegree ≤ r) →\n ∀ (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r), (Q s.1).natDegree ≤ r", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Prod.fst", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] (c : ℕ) (ζ : F) (f : (σ → F) → F),\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f =\n PCP.Algebraic.WeightedConstraint.rejectionRate (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "Pi.instFintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (witnessBound : Polynomial ℕ)\n (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true)\n (witnessBound_1 : Polynomial ℕ) (check_1 : List Bool → List Bool → Bool) (check_polyTime_1 : P check_1)\n (spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true),\n ({ witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 }) =\n (witnessBound = witnessBound_1 ∧ check = check_1)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d) (addr_1 : ℕ) (onFalse_1 onTrue_1 : PCP.QueryTree d),\n (PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1) =\n (addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n {F' : Type u_2} → {n' m' c' t' : ℕ} → PCP.Algebraic.ThreeColorVerifier.Proof F' n' m' c' t' → Sort u", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → (c : ℕ) → F → Fin (c + 1) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 241, + "is_class": false, + "kind": "theorem", + "line": 235, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_validGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.validGridQuery q) =\n PCP.Algebraic.DerivedZeroOnGrid.read π.color π.validCert (PCP.Algebraic.ThreeColorVerifier.validAuxiliary π) q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery", + "PCP.Algebraic.DerivedZeroOnGrid.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 180, + "is_class": false, + "kind": "theorem", + "line": 161, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.distance_line_bits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [Field F] {m c t r : ℕ} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ]\n {A : Type u_3} [inst_3 : DecidableEq A]\n (k l : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ × F → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k (s.1, s.2.1) s.2.2.1.2) fun s => l (s.1, s.2.1) s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The combined verdict is exactly conjunction of the seven concrete verdicts. ", + "end_line": 316, + "is_class": false, + "kind": "theorem", + "line": 311, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.test_eq_true", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s = true ↔\n ∀ (i : Fin 7), PCP.Algebraic.ThreeColorVerifier.branchTest ρ nodes ζ H G π i (s i) = true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Iff", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "Bool.true", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses._sunfold", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.addresses.match_1", + "Finset", + "Bool", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "PCP.QueryTree.addresses" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 80, + "is_class": false, + "kind": "theorem", + "line": 76, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.totalDegree_edgeExtension_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)),\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree ≤ 2 * ((H.card - 1) * Fintype.card σ)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Fintype.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The auxiliary encodings of all genuine line restrictions. ", + "end_line": 111, + "is_class": false, + "kind": "definition", + "line": 108, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n [NeZero m] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n MvPolynomial σ F → PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.honestTable", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeTriple.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (t : List Bool × List Bool × List Bool),\n PCP.Machine.encodeTriple t =\n PCP.Machine.ofBits t.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.1 ++\n PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.2", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.encodeTriple", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 175, + "is_class": false, + "kind": "definition", + "line": 175, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeGridRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t : ℕ} → [Fintype F] → [DecidableEq F] → Fintype (PCP.Algebraic.DerivedZeroOnGrid.GridRandomness F n m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed._proof_1", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeCallSeedSumFin" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "definition", + "line": 42, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : NeZero m]\n (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (M M_1 : MvPolynomial (Fin n ⊕ Fin n) F),\n M = M_1 →\n ∀ (a a_1 : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n),\n a = a_1 →\n ∀ (a_2 a_3 : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n),\n a_2 = a_3 →\n ∀ (a_4 a_5 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c),\n a_4 = a_5 →\n ∀ (a_6 a_7 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n a_6 = a_7 →\n PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ M a a_2 a_4 a_6 =\n PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary ρ_1 M_1 a_1 a_3 a_5 a_7", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "MvPolynomial", + "Sum", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.honestAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Ceiling-logarithm selection increases cardinality by at most a factor sixteen. ", + "end_line": 153, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) ≤ 16 * max 1 M", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 135, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 7 →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "PCP.QueryTree.eval.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.expect_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : Fintype B] (k : A × B → ℚ),\n (Finset.univ.expect fun p => k p) = Finset.univ.expect fun a => Finset.univ.expect fun b => k (a, b)", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete honest proof, including the four auxiliary tables shared between tests. ", + "end_line": 36, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.honestProof", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [NeZero m] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n MvPolynomial (Fin n) F →\n MvPolynomial (Fin n ⊕ Fin n) F →\n MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.honestProof._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Correction queries are routed to the same physical certificate and line tables. ", + "end_line": 172, + "is_class": false, + "kind": "definition", + "line": 168, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} → PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "Prod.mk", + "PCP.Algebraic.ThreeColorVerifier.PairPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k k_1 : ℕ),\n k = k_1 → PCP.Algebraic.SetMultilinear.digitMonomial m c k = PCP.Algebraic.SetMultilinear.digitMonomial m c k_1", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 174, + "is_class": false, + "kind": "definition", + "line": 174, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeCallSeedSumFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] → Fintype (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instDecidableEqSum", + "instDecidableEqFin", + "instFintypeSum", + "Fin.fintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerPoint", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 320, + "is_class": false, + "kind": "theorem", + "line": 311, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate_nodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (ζ : F) (f : (σ → F) → F),\n PCP.Algebraic.FixedLagrangeConstraint.rejectionRate (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) f =\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries_length_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (s : PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t ((fun i => i) ⟨2, ⋯⟩)),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * 3 + 2 * c + 12 →\n ¬(PCP.Algebraic.EncodedLineLowDegreeTest.queries ⋯ ρ nodes ζ s).length ≤ 2 * c + 18 → False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Fin.mk", + "Nat.le_of_lt", + "Nat.le_refl", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "Decidable.byContradiction", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The bounded algebraic witness characterizes any finite graph that fits in the grid.\nThe embedding and padded graph are supplied by the stated cardinality bound. ", + "end_line": 191, + "is_class": false, + "kind": "theorem", + "line": 173, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates_on_grid", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ {V : Type u_3} [inst_5 : Fintype V] (G : SimpleGraph V) (H : Finset F),\n H.Nonempty →\n ∀ (hsize : Fintype.card V ≤ H.card ^ Fintype.card σ),\n have G' := PCP.Algebraic.GraphGridEmbedding.pad G (PCP.Algebraic.GraphGridEmbedding.gridEmbedding H hsize);\n G.Colorable 3 ↔\n ∃ P MVal MProp,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n MVal.totalDegree ≤ 3 * ((H.card - 1) * Fintype.card σ) ∧\n MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) ∧\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal ∧\n PCP.Algebraic.GridVanishing.IsCertificate H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G')\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P))\n MProp", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "SimpleGraph", + "Finset", + "Finset.Nonempty", + "LE.le", + "instLENat", + "Fintype.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Finset.card", + "PCP.Algebraic.GraphGridEmbedding.Grid", + "PCP.Algebraic.GraphGridEmbedding.pad", + "PCP.Algebraic.GraphGridEmbedding.gridEmbedding", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "And", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), a ^ m * a ^ n = a ^ (m + n)", + "type_dependencies": [ + "Monoid", + "Nat", + "Eq", + "HMul.hMul", + "instHMul", + "MulOne.toMul", + "MulOneClass.toMulOne", + "Monoid.toMulOneClass", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Both correction calls have the promised mean error even when they share\ntheir sampled direction and homogeneous label. ", + "end_line": 215, + "is_class": false, + "kind": "theorem", + "line": 182, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.correction_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (Q : (σ → F) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F),\n (∀ (b : σ → F), (Q b).totalDegree ≤ c) →\n ∀ (parameter : Fˣ → F),\n PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H parameter)\n (PCP.Algebraic.BinaryLocalCorrection.decodedAt ρ Q parameter) ≤\n ↑(c + 1) *\n Finset.univ.expect fun b =>\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ (H b) fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) (Q b))))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Units", + "Semiring.toMonoid", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "instFintypeProd", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "PCP.Algebraic.BinaryLocalCorrection.decodedAt", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (x : ℕ) (b : Bool) (x_1 : PCP.ProofOracle)\n (h_1 : (x : ℕ) → (b : Bool) → (x_2 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_2)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match x, PCP.QueryTree.leaf b, x_1 with\n | x, PCP.QueryTree.leaf b, x_2 => h_1 x b x_2\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_1 x b x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.eval.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = ↑(V.acceptingRandomness x π).card / 2 ^ V.randomness x.length", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Eq", + "Rat", + "PCP.Verifier.accProb", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.acceptingRandomness", + "Rat.instPowNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 0 → ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "Bool", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "Bool", + "PCP.QueryTree.leaf", + "PCP.QueryTree.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The seven concrete branch verdicts. ", + "end_line": 115, + "is_class": false, + "kind": "definition", + "line": 96, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n (i : Fin 7) → PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Fin.cases", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_3", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines", + "Fin.succ", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_4", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines", + "Fin.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "Decidable.decide", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_6", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary", + "Option.some", + "Prod.mk", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Option.instDecidableEq", + "instDecidableEqProd", + "ZMod.decidableEq", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_8", + "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "PCP.Algebraic.BinaryDifferenceConsistency.check", + "Prod.fst", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "Prod.snd", + "Fin.elim0" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_singleton", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (a : R) (i : σ),\n PCP.Algebraic.GridVanishing.coordinate {a} i = MvPolynomial.X i - MvPolynomial.C a", + "type_dependencies": [ + "CommRing", + "Eq", + "MvPolynomial", + "CommRing.toCommSemiring", + "PCP.Algebraic.GridVanishing.coordinate", + "Singleton.singleton", + "Finset", + "Finset.instSingleton", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type (max u_2 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A slightly looser size form that retains the first field's size explicitly. ", + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 155, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le_sixteen_max", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), Fintype.card (PCP.Algebraic.ThreeColorFields.Chosen M) ≤ 16 * max 16 M", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.Chosen", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "PCP.Algebraic.ThreeColorFields.index", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Fact 2.7, for ordinary total degree, including constant polynomials. ", + "end_line": 265, + "is_class": false, + "kind": "theorem", + "line": 251, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eq_zero_iff_exists_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F} [Finite σ],\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : (σ → F) → F),\n (∀ (u v : σ → F), PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v = 0) ↔\n ∃ P, P.totalDegree ≤ c ∧ ∀ (x : σ → F), (MvPolynomial.eval x) P = f x", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Finite", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Iff", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Exists", + "MvPolynomial", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} {witnessBound : Polynomial ℕ}\n {check : List Bool → List Bool → Bool} {check_polyTime : P check}\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true}\n {witnessBound_1 : Polynomial ℕ} {check_1 : List Bool → List Bool → Bool} {check_polyTime_1 : P check_1}\n {spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true},\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 } →\n witnessBound = witnessBound_1 ∧ check = check_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 35, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.eval_validPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F) (x : σ → F),\n (MvPolynomial.eval x) (PCP.Algebraic.ThreeColorGrid.validPolynomial P) = (MvPolynomial.eval x) P ^ 3 - 1", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "definition", + "line": 23, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {b b' : Bool} → PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b' → (b = b' → P) → P", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "id", + "PCP.Machine.Sym.noConfusion" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 31, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_ofBits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool), (PCP.Machine.ofBits x).length = x.length", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "Nat", + "List.length", + "PCP.Machine.Sym", + "PCP.Machine.ofBits" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "recursor", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Sort u} →\n ((color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t) →\n (validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t) →\n (properLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t) →\n motive\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines }) →\n (t : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) → motive t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.ReferenceNPConverse", + "name": "PCP.ReferenceNP.of_inNP._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (R : List Bool → List Bool → Bool) (x w : List Bool),\n (Complexity.pair x w ∈ PCP.Machine.ReferencePair.checkerLanguage R) = (R x w = true)", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "Membership.mem", + "Complexity.Language", + "Set.instMembership", + "PCP.Machine.ReferencePair.checkerLanguage", + "Complexity.pair", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.queries hr ρ nodes ζ s =\n List.map (fun p => Sum.inl (s.1.1, p)) (PCP.Algebraic.Hadamard.testQueries hr s.2.2.2.1) ++\n List.map (fun p => Sum.inr (s.1, p))\n (PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1 ρ nodes\n s.2.2.2.2) ++\n List.map (fun p => Sum.inr (s.1, p))\n (PCP.Algebraic.BinaryStandardLocalCorrection.queries c ζ ρ\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c s.2.1) s.2.2.1.1 s.2.2.1.2) ++\n [Sum.inl\n (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1,\n (PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2.2.1.2)]", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "List", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "HAppend.hAppend", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.SetMultilinear.Variables", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.Hadamard.testQueries", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "PCP.Algebraic.BinaryStandardLocalCorrection.queries", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "List.cons", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "List.nil" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "General point-versus-line soundness with explicit absolute constants,\nincluding degree zero and zero-dimensional spaces. ", + "end_line": 69, + "is_class": false, + "kind": "theorem", + "line": 56, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.PointLineTest.exists_close_of_small_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {d : ℕ},\n PCP.Algebraic.PointLineConstants.fieldFactor * d ^ 3 ≤ Fintype.card F →\n ∀ (f : (σ → F) → F) (table : PCP.Algebraic.PointLineTest.LineTable F σ d),\n PCP.Algebraic.PointLineTest.rejectionRate f table ≤ PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ d ∧\n (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤\n 2 * PCP.Algebraic.PointLineTest.rejectionRate f table", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.PointLineTest.LineTable", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Rat.instMul", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), ¬0 ≤ 1 → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 156, + "is_class": false, + "kind": "definition", + "line": 154, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1 →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.validQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Bundled actual query list for one certificate correction call. ", + "end_line": 71, + "is_class": false, + "kind": "definition", + "line": 66, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.callQueries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n (Fin t → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t →\n List (PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.BinaryLocalCorrection.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The binary dimension follows from the explicit coefficient equivalence. ", + "end_line": 55, + "is_class": false, + "kind": "theorem", + "line": 51, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.finrank_fieldFamily", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), Module.finrank (ZMod 2) (PCP.Algebraic.ThreeColorFields.FieldFamily k) = 4 * (k + 1)", + "type_dependencies": [ + "Nat", + "Eq", + "Module.finrank", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.BinaryMaterializedField.instModuleZModOfNatNatElement" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_smul", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ) (a : R)\n (P : MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R),\n (PCP.Algebraic.SetMultilinear.decode m c) (a • P) = Polynomial.C a * (PCP.Algebraic.SetMultilinear.decode m c) P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "HSMul.hSMul", + "instHSMul", + "Algebra.toSMul", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "Polynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ) (i : Fin (c + 1)), ↑i ≠ c → ¬↑i < c → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Ne", + "Fin.val", + "Not", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "An oracle verifier.\n\nOn an input `x` of length `n` it draws `randomness n` fair bits and then runs the decision tree\nselected by that random string, making at most `queries` *bit* queries into the proof. ", + "end_line": 91, + "is_class": false, + "kind": "inductive", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Verifier.mk", + "PCP.Verifier" + ], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instInhabitedSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "Inhabited PCP.Machine.Sym", + "type_dependencies": [ + "Inhabited", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Inhabited.mk", + "PCP.Machine.Sym", + "PCP.Machine.instInhabitedSym.default" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The final primary-oracle proximity factor. ", + "end_line": 50, + "is_class": false, + "kind": "definition", + "line": 49, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HAdd.hAdd", + "Rat", + "instHAdd", + "Rat.instAdd", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "recursor", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Verifier → Sort u} →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n (t : PCP.Verifier) → motive t", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "recursor", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n (t : PCP.NPCertificate P L) → motive t", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The coordinate polynomial `∏ a ∈ H, (X i - a)`. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → Finset R → σ → MvPolynomial σ R", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring" + ], + "value_dependencies": [ + "CommRing", + "Finset", + "Finset.prod", + "MvPolynomial", + "CommRing.toCommSemiring", + "CommRing.toCommMonoid", + "AddMonoidAlgebra.commRing", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 223, + "is_class": false, + "kind": "theorem", + "line": 195, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_univariate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : F → F),\n (∀ (u v : F),\n f u =\n PCP.Algebraic.WeightedConstraint.predict (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f u v) →\n ∃ P, P.natDegree ≤ c ∧ ∀ (x : F), Polynomial.eval x P = f x", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "PCP.Algebraic.WeightedConstraint.predict", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Semiring.toModule", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "Exists", + "Polynomial", + "And", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)) (P : MvPolynomial σ F),\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ →\n ∀ (MVal : MvPolynomial (σ ⊕ σ) F) (MProp : MvPolynomial ((σ ⊕ σ) ⊕ σ ⊕ σ) F),\n MProp.totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree +\n 3 * (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree ≤ 2 * ((H.card - 1) * Fintype.card σ) →\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree ≤ P.totalDegree →\n ¬MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) → False", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 214, + "is_class": false, + "kind": "theorem", + "line": 212, + "module": "PCP.Verifier.Definition", + "name": "PCP.finiteWitnessCheck_eq_true_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w = true ↔\n ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Iff", + "Eq", + "PCP.finiteWitnessCheck", + "Bool.true", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "PCP.oracleOfWitness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "**`PCP(O(log n), O(1)) ⊆ NP` for the concrete machine model.**\n\nAn efficiently implemented verifier — polynomial-time in the sense of `PCP/Complexity/Machine.lean`,\na step count on `Turing.FinTM2` — with a canonical logarithmic budget, a polynomial proof-length\nbound, perfect completeness and soundness `1/2` puts its language in NP for that same concrete\nclass. No cost model is a parameter, and no model-existence premise is assumed: the model comes\nfrom `Machine.exists_standardCostModel`, whose closure field is the certified finite-witness\nchecker of `PCP/Complexity/CheckerFinal.lean`. ", + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 25, + "module": "PCP.ReverseConcrete", + "name": "PCP.pcp_subset_np_concrete", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (L : PCP.Language) (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PCP.Machine.PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n (∀ (x : List Bool), L x → V.CompleteAt x) →\n (∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)) → PCP.InNP PCP.Machine.PolyTimeRel L", + "type_dependencies": [ + "PCP.Language", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.Machine.PolyTimeAlg", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.InNP", + "PCP.Machine.PolyTimeRel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 381, + "is_class": false, + "kind": "definition", + "line": 380, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeCallSeedOfDecidableEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n {σ : Type u_2} →\n [Fintype σ] → [DecidableEq σ] → Fintype (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Source-style full coefficient-space proximity costs at most a factor two per oracle. ", + "end_line": 356, + "is_class": false, + "kind": "theorem", + "line": 327, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_lower_bound_of_full_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n (PCP.Algebraic.relativeDistance (fun s => p' s.1 s.2) fun s =>\n (PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval s.1) P))) s.2) ≤\n δP →\n (PCP.Algebraic.relativeDistance (fun s => M' s.1 s.2) fun s =>\n (PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval s.1) M))) s.2) ≤\n δM →\n (1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 ≤\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) *\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p' M' A +\n 2 * δP +\n 4 * δM +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instDecidableEqSum", + "instFintypeSum", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The minimal exponent loses at most a factor four compared with the requested logarithm. ", + "end_line": 76, + "is_class": false, + "kind": "theorem", + "line": 57, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), PCP.Algebraic.ThreeColorParameterChoice.volume N ≤ 4 * max 8 (Nat.clog 2 N)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "PCP.Algebraic.ThreeColorParameterChoice.volume", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Perfect completeness with the strict outer degree required by the inner encoding. ", + "end_line": 134, + "is_class": false, + "kind": "theorem", + "line": 113, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : NeZero m]\n [CharP F 2] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree < m ^ c →\n ∀ (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P))))\n (PCP.Algebraic.EncodedLineLowDegreeTest.honestTable ρ P) s =\n true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The §7 witness consists of a coloring extension and two bounded certificates. ", + "end_line": 160, + "is_class": false, + "kind": "theorem", + "line": 134, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_certificates", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (σ → ↥H)),\n G.Colorable 3 ↔\n ∃ P MVal MProp,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n MVal.totalDegree ≤ 3 * ((H.card - 1) * Fintype.card σ) ∧\n MProp.totalDegree ≤ 5 * ((H.card - 1) * Fintype.card σ) ∧\n PCP.Algebraic.GridVanishing.IsCertificate H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) MVal ∧\n PCP.Algebraic.GridVanishing.IsCertificate H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P))\n MProp", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Fintype.card", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (ctorIdx : ℕ) →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ctorIdx = t_1.ctorIdx → PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType ctorIdx → motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElimType", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PULift.down", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "Eq.ndrec", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n {inst_3 : DecidableEq F} [inst_4 : DecidableEq F] (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (nodes nodes_1 : Fin (c + 1) → F),\n nodes = nodes_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (H H_1 : Finset F),\n H = H_1 →\n ∀ (p p_1 : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n p = p_1 →\n ∀\n (M M_1 :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n M = M_1 →\n ∀ (A A_1 : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n A = A_1 →\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p M A =\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ_1 nodes_1 ζ_1 H_1 p_1 M_1 A_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 24, + "is_class": false, + "kind": "theorem", + "line": 20, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "_private.PCP.Algebraic.ThreeColorParameterChoice.0.PCP.Algebraic.ThreeColorParameterChoice.exists_exponent", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), ∃ a, 2 ≤ a ∧ Nat.clog 2 N ≤ a * 2 ^ a", + "type_dependencies": [ + "Nat", + "Exists", + "And", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a)", + "type_dependencies": [ + "DecidablePred", + "Finset", + "Eq", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.filter", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.distance_expect", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : DecidableEq B] (k l : A → B),\n PCP.Algebraic.relativeDistance k l = Finset.univ.expect fun a => if k a ≠ l a then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "ite", + "Ne", + "instDecidableNot", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 23, + "is_class": false, + "kind": "constructor", + "line": 23, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Machine.Sym" + ], + "type": "Bool → PCP.Machine.Sym", + "type_dependencies": [ + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The only discrepancy from always returning the zero-parameter correction\nis actual rejection, exactly rather than merely as an upper bound. ", + "end_line": 135, + "is_class": false, + "kind": "theorem", + "line": 120, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.distance_sample_to_corrected", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a) fun s =>\n some (PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H (fun x => 0) s)) =\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "theorem", + "line": 29, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.exponent_ge_two", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), PCP.Machine.Sym.bit b = PCP.Machine.Sym.sep → False", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.properPolynomial.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (E Q : MvPolynomial σ F),\n PCP.Algebraic.ThreeColorGrid.properPolynomial E Q = E * PCP.Algebraic.ThreeColorGrid.validPolynomial Q", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.ThreeColorGrid.validPolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "An actual query to one of the eight physical tables. ", + "end_line": 136, + "is_class": false, + "kind": "inductive", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "constructor", + "line": 37, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n (PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), PCP.Machine.Sym.sep = PCP.Machine.Sym.bit b → False", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.bit", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.ctorElim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n (ctorIdx : ℕ) →\n {a : ℕ} → (t : PCP.QueryTree a) → ctorIdx = t.ctorIdx → PCP.QueryTree.ctorElimType ctorIdx → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "PCP.QueryTree.ctorElimType" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "PCP.QueryTree.ctorIdx", + "PCP.QueryTree.ctorElimType", + "PCP.QueryTree.casesOn", + "Bool", + "PULift.down", + "PCP.QueryTree.leaf", + "Eq.ndrec", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete list certifies a constant number of bit queries for fixed `c`. ", + "end_line": 368, + "is_class": false, + "kind": "theorem", + "line": 361, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n (PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s).length ≤ 20 * c + 107", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.splitter", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "PCP.QueryTree.addresses.match_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 201, + "is_class": false, + "kind": "theorem", + "line": 183, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.distance_point_bits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t r : ℕ} [inst_1 : Fintype F] [inst_2 : Fintype σ]\n [inst_3 : DecidableEq σ] {A : Type u_3} [inst_4 : DecidableEq A] (k l : (σ → F) → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1) s.2.2.1.2) fun s =>\n l (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1) s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "instFintypeProd", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.digit.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (k k_1 : ℕ),\n k = k_1 → ∀ (i i_1 : ℕ), i = i_1 → PCP.Algebraic.digit m k i = PCP.Algebraic.digit m k_1 i_1", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Fin", + "PCP.Algebraic.digit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 140, + "is_class": false, + "kind": "definition", + "line": 140, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Theorem 4.1 at inflated outer degree `c*m^c`, for the actual tester and arbitrary\nauxiliary answers. The only rejection restriction is the explicit final threshold.\nThe second distance is over homogeneous degree-one labels, not all affine ones. ", + "end_line": 359, + "is_class": false, + "kind": "theorem", + "line": 322, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.exists_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] [CharP F 2] [NeZero m],\n PCP.Algebraic.PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ≤\n PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ c * m ^ c ∧\n PCP.Algebraic.relativeDistance (fun p => f p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ ((MvPolynomial.eval x) P)) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P)))) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "Rat.instMul", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 204, + "is_class": false, + "kind": "definition", + "line": 204, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Fintype F] → {m c t : ℕ} → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Fintype", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Fintype", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Grid vanishing may be tested using coordinatewise subtypes. ", + "end_line": 88, + "is_class": false, + "kind": "theorem", + "line": 83, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.vanishesOn_iff_grid", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (H : Finset F) (P : MvPolynomial σ F),\n PCP.Algebraic.GridVanishing.VanishesOn H P ↔ ∀ (a : σ → ↥H), (MvPolynomial.eval fun i => ↑(a i)) P = 0", + "type_dependencies": [ + "Field", + "Finset", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Iff", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Subtype.val", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.evaluationPoint.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ) (x : R) (ij : PCP.Algebraic.SetMultilinear.Variables m c),\n PCP.Algebraic.SetMultilinear.evaluationPoint m c x ij = x ^ (↑ij.2 * m ^ ↑ij.1)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "PCP.Algebraic.SetMultilinear.Variables", + "Eq", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V))\n (PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg_1 : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R)\n (polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)),\n ({ PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 }) =\n (PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1)", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 205, + "is_class": false, + "kind": "definition", + "line": 205, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeCallSeedSumFin_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [Fintype F] →\n [DecidableEq F] →\n {n m c t : ℕ} → Fintype (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instDecidableEqSum", + "instDecidableEqFin", + "instFintypeSum", + "Fin.fintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The corrected comparison bit. ", + "end_line": 46, + "is_class": false, + "kind": "definition", + "line": 42, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n F →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Fixed graph outputs also have a concrete machine certificate, including the rejecting case. ", + "end_line": 164, + "is_class": false, + "kind": "theorem", + "line": 155, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.polyTimeMap_constant", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (s : List Bool), PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits fun x => s", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 75, + "is_class": false, + "kind": "theorem", + "line": 71, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_digitMonomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n (PCP.Algebraic.SetMultilinear.decode m c) (PCP.Algebraic.SetMultilinear.digitMonomial m c k) =\n Polynomial.X ^ (k % m ^ c)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Polynomial", + "CommSemiring.toSemiring", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.X", + "HMod.hMod", + "instHMod", + "Nat.instMod", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodeTriple._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (t : List Bool × List Bool × List Bool),\n ¬t.1.length + (t.2.1.length + (t.2.2.length + 1) + 1) = t.1.length + t.2.1.length + t.2.2.length + 2 → False", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Not", + "Eq", + "Nat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {t t' : PCP.Machine.Sym} → t = t' → PCP.Machine.Sym.noConfusionType P t t'", + "type_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "PCP.Machine.Sym.noConfusionType" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Eq", + "Eq.ndrec", + "PCP.Machine.Sym.noConfusionType", + "PCP.Machine.Sym.casesOn", + "Bool", + "Eq.refl" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.oracleOfWitness.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (w : List Bool) (j : ℕ), PCP.oracleOfWitness w j = w.getD j false", + "type_dependencies": [ + "List", + "Bool", + "Nat", + "Eq", + "PCP.oracleOfWitness", + "List.getD", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (u v : σ → F) (f g : (σ → F) → F),\n (∀ x ∈ PCP.Algebraic.GeneratorLowDegreeTest.queries c ζ u v, f x = g x) →\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v = PCP.Algebraic.GeneratorLowDegreeTest.check c ζ g u v", + "type_dependencies": [ + "Field", + "Nat", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.costPoly.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (k A C D : ℕ),\n PCP.Reduction.NPThreeColorRuntime.costPoly h q k A C D =\n Polynomial.C A * (2 * Polynomial.X + 1) ^ 2 +\n Polynomial.C C *\n (Polynomial.C A * (2 * Polynomial.X + 1) + PCP.Reduction.NPThreeColor.variablesPoly h q k +\n PCP.Reduction.NPThreeColor.constraintsPoly h q k +\n 1) ^\n 6 +\n Polynomial.C A * (2 * Polynomial.X + 1) +\n Polynomial.C D *\n (PCP.Reduction.NPThreeColor.variablesPoly h q k + PCP.Reduction.NPThreeColor.constraintsPoly h q k + 1) ^ 2 +\n 5", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "PCP.Reduction.NPThreeColorRuntime.costPoly", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatAtLeastTwo", + "Polynomial.instNatCast", + "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_1", + "Polynomial.X", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatNat", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_2" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instFintypeSym.match_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : PCP.Machine.Sym → Sort u_1) →\n (x : PCP.Machine.Sym) → ((a : Bool) → motive (PCP.Machine.Sym.bit a)) → (Unit → motive PCP.Machine.Sym.sep) → motive x", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "Unit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "Unit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 44, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.eval_coordinate_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ) (x : σ → R),\n x i ∈ H → (MvPolynomial.eval x) (PCP.Algebraic.GridVanishing.coordinate H i) = 0", + "type_dependencies": [ + "CommRing", + "Finset", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "CommRing.toCommSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.GridVanishing.coordinate", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (c k : ℕ),\n PCP.Algebraic.SetMultilinear.digitExponents m c k = ∑ i, Finsupp.single (i, PCP.Algebraic.digit m k ↑i) 1", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitExponents", + "Finset.sum", + "Fin", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "Finsupp.single", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Public bitstrings and the language program use the same zero/one values. ", + "end_line": 125, + "is_class": false, + "kind": "theorem", + "line": 120, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.code_ofBits", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool), PCP.Machine.LangSymbolBridge.code (PCP.Machine.ofBits x) = List.map Bool.toNat x", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "Nat", + "PCP.Machine.LangSymbolBridge.code", + "PCP.Machine.ofBits", + "List.map", + "Bool.toNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 193, + "is_class": false, + "kind": "theorem", + "line": 151, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : F → F),\n f 0 = 0 →\n (∀ (i : Fin (c + 1)), f (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i) = 0) →\n (∀ (v : F),\n PCP.Algebraic.WeightedConstraint.predict (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f 0 v =\n 0) →\n ∀ (x : F), f x = 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.WeightedConstraint.predict", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeTest.0.PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ}\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3)\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (h_1 : (p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p))\n (h_2 :\n (p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)),\n (match Sum.inr p with\n | Sum.inl p => h_1 p\n | Sum.inr p => h_2 p) =\n h_2 p", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inl", + "Sum.inr", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {F : Type u_2} →\n {n m c t : ℕ} →\n {t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t} →\n {F' : Type u_2} →\n {n' m' c' t' : ℕ} →\n {t'_1 : PCP.Algebraic.ThreeColorVerifier.Query F' n' m' c' t'} →\n F = F' →\n n = n' →\n m = m' →\n c = c' → t = t' → t_1 ≍ t'_1 → PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType P t_1 t'_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "HEq", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "HEq.refl", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 53, + "is_class": false, + "kind": "definition", + "line": 50, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} →\n (h : PCP.Machine.NPTableau.Checker R) →\n Polynomial ℕ →\n [DecidableEq h.tm.Λ] →\n [DecidableEq h.tm.σ] →\n [(k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)] →\n PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk →\n {k a : ℕ} → h.tm.K ≃ Fin k → PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a → List Bool → List Bool", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Reduction.NPTableauGraphLang.encode", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "PCP.Machine.NPCellConstraints.accepting_length_le" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness uses the two formal identities and imposes no shape restriction on `M`. ", + "end_line": 71, + "is_class": false, + "kind": "theorem", + "line": 61, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.IsCertificate.vanishesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] {H : Finset R} {p : MvPolynomial σ R} {M : MvPolynomial (σ ⊕ σ) R},\n PCP.Algebraic.GridVanishing.IsCertificate H p M → PCP.Algebraic.GridVanishing.VanishesOn H p", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.GridVanishing.VanishesOn" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The chosen grid has room for every vertex, not merely for the logarithm of its count. ", + "end_line": 55, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.size_le_grid_capacity", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n N ≤\n (PCP.Algebraic.ThreeColorParameters.grid (PCP.Algebraic.ThreeColorParameterChoice.exponent N)).card ^\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent N)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Finset.card", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorParameters.size" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instReprSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "Repr PCP.Machine.Sym", + "type_dependencies": [ + "Repr", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Repr.mk", + "PCP.Machine.Sym", + "PCP.Machine.instReprSym.repr" + ] + }, + { + "axioms": [], + "doc": "A \"proxy type\" equivalent to `PCP.Machine.Sym` that is constructed from `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum`. See `PCP.Machine.Sym.proxyTypeEquiv` for the equivalence. (Generated by the `proxy_equiv%` elaborator.)", + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.proxyType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "Sum", + "Bool", + "Unit" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 330, + "is_class": false, + "kind": "theorem", + "line": 322, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.exists_close", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ],\n 2 * c < Fintype.card F →\n ∀ {a : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes a →\n ∀ (f : (σ → F) → F) {δ : ℚ},\n PCP.Algebraic.FixedLagrangeConstraint.rejectionRate a f ≤ δ →\n δ < 1 / (2 * (↑c + 2) ^ 2) →\n ∃ P, P.totalDegree ≤ c ∧ (PCP.Algebraic.relativeDistance f fun x => (MvPolynomial.eval x) P) ≤ 2 * δ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "Rat", + "LE.le", + "Rat.instLE", + "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "Rat.instLT", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Pi.instFintype", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.checker_program_reduction._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Option (ZMod 2) → Option (ZMod 2) → Option (ZMod 2) → Sort u_1) (p m₀ mZ : ZMod 2)\n (h_1 : (p m₀ mZ : ZMod 2) → motive (some p) (some m₀) (some mZ))\n (h_2 : (x x_1 x_2 : Option (ZMod 2)) → motive x x_1 x_2),\n (match some p, some m₀, some mZ with\n | some p, some m₀, some mZ => h_1 p m₀ mZ\n | x, x_1, x_2 => h_2 x x_1 x_2) =\n h_1 p m₀ mZ", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.length_encodePair._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p : List Bool × List Bool), ¬p.1.length + (p.2.length + 1) = p.1.length + p.2.length + 1 → False", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "Not", + "Eq", + "Nat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "Prod.fst", + "Prod.snd", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → (n m c t : ℕ) → [SizeOf F] → SizeOf (PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "SizeOf.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.totalDegree_validPolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (P : MvPolynomial σ F),\n (PCP.Algebraic.ThreeColorGrid.validPolynomial P).totalDegree ≤ 3 * P.totalDegree", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.substitute Y = MvPolynomial.eval₂Hom MvPolynomial.C (Sum.elim MvPolynomial.X Y)", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.substitute", + "MvPolynomial.eval₂Hom", + "AddMonoidAlgebra.commSemiring", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "MvPolynomial.C", + "Sum.elim", + "MvPolynomial.X" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 113, + "is_class": false, + "kind": "theorem", + "line": 112, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.nodes_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes ⇑(PCP.Algebraic.ThreeColorFields.nodes k)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "DFunLike.coe", + "Function.Embedding", + "Fin", + "Function.instFunLikeEmbedding", + "PCP.Algebraic.ThreeColorFields.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every monomial contains exactly one variable from each block. The zero\npolynomial satisfies this condition because its support is empty. ", + "end_line": 174, + "is_class": false, + "kind": "definition", + "line": 171, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.IsSetMultilinear", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] → (m c : ℕ) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R → Prop", + "type_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial.support", + "Fin", + "Eq", + "Finset.sum", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "DFunLike.coe", + "Finsupp.instFunLike", + "Prod.mk", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (accept : Bool), sizeOf (PCP.QueryTree.leaf accept) = 1 + sizeOf d + sizeOf accept", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "SizeOf.sizeOf", + "PCP.QueryTree", + "PCP.QueryTree._sizeOf_inst", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "instSizeOfNat", + "Bool._sizeOf_inst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 130, + "is_class": false, + "kind": "definition", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 4 →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {P_1 : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {t : PCP.NPCertificate P_1 L} →\n {P' : (List Bool → List Bool → Bool) → Prop} →\n {L' : PCP.Language} →\n {t' : PCP.NPCertificate P' L'} → P_1 = P' → L = L' → t ≍ t' → PCP.NPCertificate.noConfusionType P t t'", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Eq", + "HEq", + "PCP.NPCertificate.noConfusionType" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.NPCertificate.noConfusionType", + "PCP.NPCertificate.casesOn", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Bool.true", + "Eq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The random strings on which `V` accepts `x` given proof `π`. ", + "end_line": 99, + "is_class": false, + "kind": "definition", + "line": 97, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.acceptingRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "(V : PCP.Verifier) → (x : List Bool) → PCP.ProofOracle → Finset (Fin (2 ^ V.randomness x.length))", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Finset", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Finset.filter", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Eq", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "Bool.true", + "instDecidableEqBool", + "Finset.univ", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.nodes._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ),\n Function.Injective (PCP.Algebraic.GeneratorLowDegreeTest.nodes 4 (PCP.Algebraic.ThreeColorFields.generator k))", + "type_dependencies": [ + "Nat", + "Function.Injective", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ) (i : Fin (c + 1)), ¬0 < ↑i + 1 + (n - (c + 1)) → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Not", + "LT.lt", + "instLTNat", + "Fin.val", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Query proof address `addr`, then continue in `onFalse` or `onTrue`. ", + "end_line": 37, + "is_class": false, + "kind": "constructor", + "line": 36, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query", + "provenance": "lean", + "structural_dependencies": [ + "PCP.QueryTree" + ], + "type": "{d : ℕ} → ℕ → PCP.QueryTree d → PCP.QueryTree d → PCP.QueryTree (d + 1)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 161, + "is_class": false, + "kind": "definition", + "line": 158, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3 →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine" + ] + }, + { + "axioms": [], + "doc": "An equivalence between the \"proxy type\" `PCP.Machine.Sym.proxyType` and `PCP.Machine.Sym`. The proxy type is a reducible definition that represents the inductive type using `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum` (and whatever other inductive types appear within the inductive type), and the intended use is to define typeclass instances uses pre-existing instances on these. (Generated by the `proxy_equiv%` elaborator.)", + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.proxyTypeEquiv", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool ⊕ Unit ≃ PCP.Machine.Sym", + "type_dependencies": [ + "Equiv", + "Sum", + "Bool", + "Unit", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Equiv.mk", + "Sum", + "Bool", + "Unit", + "PCP.Machine.Sym", + "PCP.Machine.instFintypeSym.match_3", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.instFintypeSym.match_5", + "Sum.inl", + "Sum.inr", + "Unit.unit", + "Sum.casesOn", + "Eq", + "Eq.ndrec", + "Eq.refl", + "Eq.symm", + "PCP.Machine.Sym.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] (c : ℕ) (ζ : F) (i : Fin (c + 1)),\n PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i = ζ ^ (↑i + 1)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Both uses of inner correction, distinguished by the selected parameter. ", + "end_line": 112, + "is_class": false, + "kind": "definition", + "line": 108, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) →\n (Fˣ → F) → PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All three checks must pass; the two tester seeds are independent. ", + "end_line": 57, + "is_class": false, + "kind": "definition", + "line": 48, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n 1 ≤ r →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool.and", + "PCP.Algebraic.Hadamard.test", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "Decidable.decide", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 256, + "is_class": false, + "kind": "theorem", + "line": 253, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_differenceCheckQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery q) =\n PCP.Algebraic.BinaryDifferenceConsistency.read π.color π.difference q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery", + "PCP.Algebraic.BinaryDifferenceConsistency.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 249, + "is_class": false, + "kind": "theorem", + "line": 244, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree ≤ c →\n ∀ (u v : σ → F), PCP.Algebraic.GeneratorLowDegreeTest.check c ζ (fun x => (MvPolynomial.eval x) P) u v = 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every language in the repository's concrete NP model has the certified graph reduction. ", + "end_line": 207, + "is_class": false, + "kind": "theorem", + "line": 201, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.of_inNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language},\n PCP.InNP PCP.Machine.PolyTimeRel L →\n ∃ f p,\n PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits f ∧\n ∀ (x : List Bool),\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧ (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "List", + "Bool", + "Polynomial", + "Nat", + "Nat.instSemiring", + "And", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x x_1 : PCP.Machine.Sym) → Decidable (x = x_1)", + "type_dependencies": [ + "PCP.Machine.Sym", + "Decidable", + "Eq" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.instDecidableEqSym.decEq.match_1", + "Decidable", + "Eq", + "Bool", + "dite", + "PCP.Machine.Sym.bit", + "instDecidableEqBool", + "Eq.ndrec", + "Decidable.isTrue", + "PCP.Machine.instDecidableEqSym.decEq._proof_1", + "Not", + "Decidable.isFalse", + "PCP.Machine.instDecidableEqSym.decEq._proof_2", + "PCP.Machine.Sym.sep", + "PCP.Machine.instDecidableEqSym.decEq._proof_3", + "PCP.Machine.instDecidableEqSym.decEq._proof_4", + "Unit", + "rfl" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d),\n sizeOf (PCP.QueryTree.query addr onFalse onTrue) = 1 + sizeOf d + sizeOf addr + sizeOf onFalse + sizeOf onTrue", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "SizeOf.sizeOf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree._sizeOf_inst", + "PCP.QueryTree.query", + "instSizeOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (a : Fin (c + 1) → F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.FixedLagrangeConstraint.check a f u v = PCP.Algebraic.LagrangeConstraint.check a f u v 0", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.FixedLagrangeConstraint.check", + "PCP.Algebraic.LagrangeConstraint.check", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness uses fresh primary randomness and the actual received certificate proof.\nThe replacement loss is explicitly multiplied by the existing grid-soundness coefficient. ", + "end_line": 277, + "is_class": false, + "kind": "theorem", + "line": 244, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate_lower_bound", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [NeZero m] [CharP F 2] {D : ℕ},\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r)\n {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (f : (Fin n → F) → F) (P : MvPolynomial (Fin n) F),\n (∀ (x : Fin n → F), Polynomial.eval (f x) (Q x) = (MvPolynomial.eval x) P) →\n ∀ (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ p f ≤ δP →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δM →\n (1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 ≤\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) *\n (PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ Q hQ nodes ζ H p M' A +\n 2 * δP) +\n 2 * δM +\n ↑D / ↑(Fintype.card F - 1)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Eq", + "Polynomial.eval", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "instFintypeSum", + "instDecidableEqSum", + "le_refl", + "Nat.instPreorder", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "instSubNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {P_1 : Sort u} →\n {witnessBound : Polynomial ℕ} →\n {check : List Bool → List Bool → Bool} →\n {check_polyTime : P check} →\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true} →\n {witnessBound' : Polynomial ℕ} →\n {check' : List Bool → List Bool → Bool} →\n {check_polyTime' : P check'} →\n {spec' :\n ∀ (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound' ∧ check' x w = true} →\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound', check := check', check_polyTime := check_polyTime',\n spec := spec' } →\n (witnessBound = witnessBound' → check = check' → P_1) → P_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate", + "PCP.NPCertificate.mk", + "id", + "PCP.NPCertificate.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Only the difference-table point is pulled back through the coordinate equivalence. ", + "end_line": 178, + "is_class": false, + "kind": "definition", + "line": 174, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "Function.comp", + "Sum", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "Prod.mk", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → Type (max u_2 0)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1) →\n ((x : Fin (n + n) ⊕ Fin (n + n) → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin (n + n) ⊕ Fin (n + n))) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [inst : Fintype F], 1 < Fintype.card F → Fintype.card F - 1 = 0 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Line, full-field parameter, correction direction and label, and both test seeds. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → ℕ → Type (max (max u_4 u_3) u_3)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A fixed positive repetition count, independent of every input and proof. ", + "end_line": 27, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "PCP.Algebraic.RationalRepetitionBound.repetitions", + "PCP.Algebraic.ThreeColorBinaryVerifier.gap" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n PCP.Algebraic.SetMultilinear.boundedEncode m c d = PCP.Algebraic.SetMultilinear.boundedEncode m c d", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Subtype", + "Polynomial", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.boundedEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "A decision tree over a Boolean proof oracle, of depth at most `d`.\n\n`leaf` may occur at any depth, so `QueryTree d` is \"at most `d` queries\", not \"exactly `d`\". ", + "end_line": 37, + "is_class": false, + "kind": "inductive", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree", + "provenance": "lean", + "structural_dependencies": [ + "PCP.QueryTree.leaf", + "PCP.QueryTree.query", + "PCP.QueryTree" + ], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validGridQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t 3) →\n ((x : Fin n → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((fst : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n) →\n (x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (fst, Sum.inl (x, q)))) →\n ((a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n) →\n (b : Fin n ⊕ Fin n → F) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr (a, Sum.inr (b, x, q)))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The bit comparison is tested even when either consistency check also fails. ", + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.comparison_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H) fun s =>\n f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2.2.1.2)) ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "ZMod.decidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.PolynomialLine.point", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness: a polynomial-time verifier algorithm is computable. This rules out a degenerate\nmodel that counts an arbitrary, even noncomputable, step function as efficient; such a model\nwould let a \"verifier\" decide the language outright. ", + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 89, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.polyTimeAlg_computable", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (self : PCP.CostModel) (alg : PCP.VerifierAlg), self.PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2", + "type_dependencies": [ + "PCP.CostModel", + "PCP.VerifierAlg", + "PCP.CostModel.PolyTimeAlg", + "Computable", + "Prod", + "List", + "Bool", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.list", + "Primcodable.bool", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "Eq", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → [SizeOf F] → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.rec", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n (PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The logarithmic parameter volume controlling later resource exponents. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest rejection is zero under exactly the finite sampling used by the tester. ", + "end_line": 164, + "is_class": false, + "kind": "theorem", + "line": 157, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : NeZero m]\n [CharP F 2] [inst_4 : Fintype F] [inst_5 : Fintype σ] [inst_6 : DecidableEq σ] (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (P : MvPolynomial σ F),\n P.totalDegree < m ^ c →\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) P))))\n (PCP.Algebraic.EncodedLineLowDegreeTest.honestTable ρ P) =\n 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LT.lt", + "instLTNat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Eq", + "Rat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.EncodedLineLowDegreeTest.honestTable", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same bound stated using the received point oracle's exact homogeneous distance. ", + "end_line": 331, + "is_class": false, + "kind": "theorem", + "line": 315, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {D : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a)\n fun s => some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2.2.1.2)) ≤\n (PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a +\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option.instDecidableEq", + "ZMod.decidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Prod.snd", + "Prod.fst", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.Hadamard.encode", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Equation (3.1): the point at which the encoded polynomial recovers `P(λ)`. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 62, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.evaluationPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → [CommSemiring R] → (m c : ℕ) → R → PCP.Algebraic.SetMultilinear.Variables m c → R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "PCP.Algebraic.SetMultilinear.Variables", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": "The decision tree used on input `x` and random string `r`. ", + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 91, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.run", + "provenance": "lean", + "structural_dependencies": [], + "type": "(self : PCP.Verifier) → (x : List Bool) → Fin (2 ^ self.randomness x.length) → PCP.QueryTree self.queries", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.queries" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "With small rejection, the actual all-parameter correction is an ordinary\ntotal-degree-bounded polynomial in every finite dimension. ", + "end_line": 54, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.PointLineTest.exists_polynomial_correction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {d : ℕ},\n 0 < d →\n PCP.Algebraic.PointLineConstants.fieldFactor * d ^ 3 ≤ Fintype.card F →\n ∀ (f : (σ → F) → F),\n PCP.Algebraic.PointLineTest.rejectionRate f (PCP.Algebraic.PointLineTest.decodedTable d f) ≤\n PCP.Algebraic.PointLineConstants.smallError →\n ∃ P,\n P.totalDegree ≤ d ∧\n ∀ (x : σ → F),\n (MvPolynomial.eval x) P =\n PCP.Algebraic.PointLineTest.correction (PCP.Algebraic.PointLineTest.decodedTable d f) x", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Fintype.card", + "Rat", + "Rat.instLE", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.PointLineTest.decodedTable", + "PCP.Algebraic.PointLineConstants.smallError", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "MvPolynomial.totalDegree", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.PointLineTest.correction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 219, + "is_class": false, + "kind": "theorem", + "line": 216, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_validQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.validQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.validCert π.validLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.validQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The sum of both local-correction losses and the two direct rejection losses. ", + "end_line": 28, + "is_class": false, + "kind": "definition", + "line": 26, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HAdd.hAdd", + "Rat", + "instHAdd", + "Rat.instAdd", + "OfNat.ofNat", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "instAddNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A colorable graph has zero rejection under the actual complete finite seed. ", + "end_line": 141, + "is_class": false, + "kind": "theorem", + "line": 129, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_rejectionRate_eq_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [NeZero m] [CharP F 2]\n [inst_4 : Fintype F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n G.Colorable 3 →\n 5 * ((H.card - 1) * n) < m ^ c →\n ∃ π, PCP.Algebraic.ThreeColorVerifier.rejectionRate ρ nodes ζ H G π = 0", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Fintype", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "SimpleGraph.Colorable", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Exists", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.rejectionRate", + "Classical.propDecidable", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "theorem", + "line": 34, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.le_volume", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), Nat.clog 2 N ≤ PCP.Algebraic.ThreeColorParameterChoice.volume N", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.volume" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval_congr._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x)\n (f :\n PCP.QueryTree.below (motive := fun x x_2 =>\n ∀ (x_3 x_4 : PCP.ProofOracle), (∀ a ∈ x_2.addresses, x_3 a = x_4 a) → x_2.eval x_3 = x_2.eval x_4) x_1)\n (x_2 x_3 : PCP.ProofOracle), (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → x_1.eval x_2 = x_1.eval x_3", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.eval" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.eval", + "PCP.QueryTree.eval_congr.match_1_1", + "PCP.QueryTree.leaf", + "rfl", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "of_eq_true", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "Eq.trans", + "Or", + "True", + "Finset.mem_insert._simp_1", + "congr", + "congrArg", + "eq_self", + "Finset.mem_union._simp_1", + "true_or", + "PProd", + "Eq.mpr", + "id", + "Iff.mpr", + "Not", + "Classical.or_iff_not_imp_left", + "False.elim", + "ite", + "Bool.true", + "instDecidableEqBool", + "congrFun'", + "ite_congr" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.splitter._sparseCasesOn_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "{α : Type u} →\n {motive : Option α → Sort u_1} →\n (t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t", + "type_dependencies": [ + "Option", + "Option.some", + "Nat.hasNotBit", + "Option.ctorIdx" + ], + "value_dependencies": [ + "Option", + "Option.some", + "Option.rec", + "Nat.hasNotBit", + "Option.ctorIdx", + "Option.none", + "Nat.ne_of_beq_eq_false", + "Nat.land", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Nat.shiftRight", + "Eq.refl", + "Bool", + "Bool.false" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.predecessor_volume_lt._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ},\n 2 < PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1 → False", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Not", + "LE.le", + "instLENat", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep.match_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : ℕ → List Bool → Sort u_1) →\n (x : ℕ) →\n (x_1 : List Bool) →\n ((as : List Bool) → motive 0 as) → ((n : ℕ) → (as : List Bool) → motive n.succ as) → motive x x_1", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "OfNat.ofNat", + "instOfNatNat", + "Nat.succ" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "OfNat.ofNat", + "instOfNatNat", + "Nat.succ", + "Nat.casesOn" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {a : ℕ} →\n {t : PCP.QueryTree a} → {a' : ℕ} → {t' : PCP.QueryTree a'} → a = a' → t ≍ t' → PCP.QueryTree.noConfusionType P t t'", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HEq", + "PCP.QueryTree.noConfusionType" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.QueryTree.noConfusionType", + "PCP.QueryTree.casesOn", + "Bool", + "Eq.refl", + "HEq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An alternative simple affine bound in the ceiling logarithm. ", + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 78, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le_log_add_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), PCP.Algebraic.ThreeColorParameterChoice.volume N ≤ 32 * (Nat.clog 2 N + 1)", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "PCP.Algebraic.ThreeColorParameterChoice.volume", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk", + "PCP.Verifier.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The image of `Y ^ k`: one selected variable from every block. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] →\n (m : ℕ) → [NeZero m] → (c : ℕ) → ℕ → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.prod", + "Fin", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "CommSemiring.toCommMonoid", + "AddMonoidAlgebra.commSemiring", + "Finsupp", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "MvPolynomial.X", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 60, + "is_class": false, + "kind": "theorem", + "line": 58, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_X_pow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n (PCP.Algebraic.SetMultilinear.encode m c) (Polynomial.X ^ k) = PCP.Algebraic.SetMultilinear.digitMonomial m c k", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.X", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Query dependence of the actual randomized verifier. ", + "end_line": 133, + "is_class": false, + "kind": "theorem", + "line": 111, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r)\n (p p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (M M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A A' : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n (∀ q ∈ PCP.Algebraic.DerivedZeroOnGrid.queries ρ Q hQ nodes ζ H s,\n PCP.Algebraic.DerivedZeroOnGrid.read p M A q = PCP.Algebraic.DerivedZeroOnGrid.read p' M' A' q) →\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H p M A s =\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H p' M' A' s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "Eq", + "PCP.Algebraic.DerivedZeroOnGrid.read", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 63, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.edgeValue_eq_eval", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (x : Fin (n + n) → F),\n PCP.Algebraic.ThreeColorVerifier.edgeValue H G x =\n (MvPolynomial.eval x) (PCP.Algebraic.ThreeColorVerifier.edgePolynomial H G)", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorVerifier.edgePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (3 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.ofBits.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool), PCP.Machine.ofBits x = List.map PCP.Machine.Sym.bit x", + "type_dependencies": [ + "List", + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.ofBits", + "List.map", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 142, + "is_class": false, + "kind": "definition", + "line": 142, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t r : ℕ} →\n [Fintype F] →\n Fintype (PCP.Algebraic.Hadamard.TestRandomness t r × PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 56, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Total degree is additive on nonzero factors over a domain. ", + "end_line": 71, + "is_class": false, + "kind": "theorem", + "line": 66, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.totalDegree_mul_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] {p q : MvPolynomial σ R},\n p ≠ 0 → q ≠ 0 → (p * q).totalDegree = p.totalDegree + q.totalDegree", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "MvPolynomial", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "Eq", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.size_le_volume._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬0 < PCP.Algebraic.ThreeColorParameterChoice.exponent N → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Not", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.acceptingRandomness.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.acceptingRandomness x π = {r | (V.run x r).eval π = true}", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Eq", + "Finset", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.Verifier.acceptingRandomness", + "Finset.filter", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "Bool.true", + "instDecidableEqBool", + "Finset.univ", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The exact coordinate flattening used only by the proper-constraint branch. ", + "end_line": 48, + "is_class": false, + "kind": "definition", + "line": 47, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.flatten", + "provenance": "lean", + "structural_dependencies": [], + "type": "(n : ℕ) → Fin n ⊕ Fin n ≃ Fin (n + n)", + "type_dependencies": [ + "Nat", + "Equiv", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "finSumFinEquiv" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "Eq", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 32, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 ≤ PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c", + "type_dependencies": [ + "Nat", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.finiteWitnessCheck.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w =\n decide (∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true)", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Eq", + "PCP.finiteWitnessCheck", + "Decidable.decide", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "PCP.oracleOfWitness", + "Bool.true", + "Nat.decidableForallFin", + "instDecidableEqBool" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b : Bool), sizeOf (PCP.Machine.Sym.bit b) = 1 + sizeOf b", + "type_dependencies": [ + "Bool", + "Eq", + "Nat", + "SizeOf.sizeOf", + "PCP.Machine.Sym", + "PCP.Machine.Sym._sizeOf_inst", + "PCP.Machine.Sym.bit", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Bool._sizeOf_inst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "(4 + 1).AtLeastTwo", + "type_dependencies": [ + "Nat.AtLeastTwo", + "HAdd.hAdd", + "Nat", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true", + "PCP.NPCertificate.mk", + "PCP.NPCertificate.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.sizePoly.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) (k D : ℕ),\n PCP.Reduction.NPThreeColorRuntime.sizePoly h q k D =\n Polynomial.C D *\n (PCP.Reduction.NPThreeColor.variablesPoly h q k + PCP.Reduction.NPThreeColor.constraintsPoly h q k + 1) ^ 2", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Eq", + "PCP.Reduction.NPThreeColorRuntime.sizePoly", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`NP ⊆ PCP(O(log n), O(1))`, with one polynomial-time verifier for each language.\nAll constants and the proof-length polynomial are independent of the input. ", + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 23, + "module": "PCP.Theorem", + "name": "PCP.np_subset_pcp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (L : PCP.Language),\n PCP.InNP PCP.Machine.PolyTimeRel L →\n ∃ V alg a b q p,\n PCP.Machine.PolyTimeAlg alg ∧\n V.ImplementedBy alg ∧\n V.queries = q ∧\n V.CanonicalRandomness a b ∧\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) ∧\n (∀ (x : List Bool), L x → V.CompleteAt x) ∧ ∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)", + "type_dependencies": [ + "PCP.Language", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Exists", + "PCP.Verifier", + "PCP.VerifierAlg", + "Nat", + "Polynomial", + "Nat.instSemiring", + "And", + "PCP.Machine.PolyTimeAlg", + "PCP.Verifier.ImplementedBy", + "Eq", + "PCP.Verifier.queries", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A uniform cost model: what \"polynomial time\" means for witness-checking relations and for\nverifier algorithms, together with the coherence and closure properties any genuine model has.\n\nThe field docstrings explain why each field is present. **The machine model is no longer a choice**:\n`PCP/Complexity/Machine.lean` fixes it as `Turing.TM2ComputableInPolyTime`. Showing those concrete\npredicates satisfy this interface was obligation NP-1, now discharged: the two coherence fields in\n`PCP/Complexity/Bridge.lean`, the closure field below in `PCP/Complexity/StandardModel.lean`.\nNote the known cost of that choice: *some* certified composition or subroutine result is needed for\nthe closure field, and mathlib's `comp` is an open `proof_wanted` at the pinned revision. That\nupstream theorem is one route; a specialised call-and-return construction for these fixed encodings\nis another, and is the one that was built. ", + "end_line": 108, + "is_class": false, + "kind": "inductive", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel", + "provenance": "lean", + "structural_dependencies": [ + "PCP.CostModel.mk", + "PCP.CostModel" + ], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "All seven branches must accept. ", + "end_line": 121, + "is_class": false, + "kind": "definition", + "line": 117, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.test", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.Sample F n m c t → Bool", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Bool" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.FiniteConjunction.test", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.branchTest" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "definition", + "line": 49, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.correct", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → ℕ → F → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat" + ], + "value_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.WeightedConstraint.predict", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ] + }, + { + "axioms": [], + "doc": "The depth-`d` decision tree generated by unfolding a step function, starting from the answers\n`as` received so far.\n\nIf the step function has not halted within its `d`-query budget the tree rejects: an algorithm\nclaiming a `q`-query verifier must halt within `q` queries, and `ImplementedBy` below is what\nforces that to match the verifier's actual behaviour. ", + "end_line": 47, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Nat.brecOn", + "PCP.QueryTree", + "PCP.QueryTree.ofStep._f" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 77, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "_private.PCP.Algebraic.EncodedLineLowDegreeSoundness.0.PCP.Algebraic.EncodedLineLowDegreeTest.expect_sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} {m c t r : ℕ} [inst : Fintype F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ]\n (k : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r → ℚ),\n (Finset.univ.expect fun s => k s) =\n Finset.univ.expect fun uv =>\n Finset.univ.expect fun z => Finset.univ.expect fun vw => Finset.univ.expect fun hi => k (uv, z, vw, hi)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "instFintypeProd", + "Pi.instFintype", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed_1", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every branch's list is mapped to physical proof-table locations. ", + "end_line": 201, + "is_class": false, + "kind": "definition", + "line": 184, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n (i : Fin 7) →\n PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i →\n List (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Fin.cases", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Fin.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_1", + "List.map", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.ThreeColorVerifier.colorQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_3", + "Fin.succ", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_2", + "Sum", + "PCP.Algebraic.ThreeColorVerifier.validQuery", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_4", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_3", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_4", + "PCP.Algebraic.ThreeColorVerifier.properQuery", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.ThreeColorVerifier.validGridQuery", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_6", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_8", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery", + "PCP.Algebraic.BinaryDifferenceConsistency.queries", + "Prod.fst", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "Prod", + "Prod.snd", + "Fin.elim0" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator_goodNodes._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ),\n 16 ≤ Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) →\n ¬2 * 4 < Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) → False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "Not", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "No branch loses its normalized marginal through an empty independent seed. ", + "end_line": 399, + "is_class": false, + "kind": "theorem", + "line": 397, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchSeedNonempty", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c t : ℕ} (i : Fin 7),\n Nonempty (PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i)", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Nonempty", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 387, + "is_class": false, + "kind": "theorem", + "line": 386, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instNonemptyCallSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t : ℕ} {σ : Type u_2},\n Nonempty (PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F σ m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The normalized rejection of one concrete branch on its own seed. ", + "end_line": 411, + "is_class": false, + "kind": "definition", + "line": 407, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) → PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Fin 7 → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "instDecidableEqBool", + "PCP.Algebraic.ThreeColorVerifier.branchTest", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 377, + "is_class": false, + "kind": "definition", + "line": 376, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeProdTestRandomnessInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t : ℕ} →\n [Fintype F] →\n {r : ℕ} →\n Fintype (PCP.Algebraic.Hadamard.TestRandomness t r × PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "Prod", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 203, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Fintype F] → {m c : ℕ} → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Fintype", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Fintype", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 51, + "is_class": false, + "kind": "theorem", + "line": 50, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_vanishesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ),\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.GridVanishing.coordinate H i)", + "type_dependencies": [ + "CommRing", + "Finset", + "PCP.Algebraic.GridVanishing.VanishesOn", + "PCP.Algebraic.GridVanishing.coordinate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every address the tree could query, along any branch. ", + "end_line": 49, + "is_class": false, + "kind": "definition", + "line": 46, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses", + "provenance": "lean", + "structural_dependencies": [], + "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.brecOn", + "Finset", + "PCP.QueryTree.addresses._f" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Concrete NP certificates reduce to the actual encoded graph language in polynomial time. ", + "end_line": 199, + "is_class": false, + "kind": "theorem", + "line": 192, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.of_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : PCP.Language} (cert : PCP.NPCertificate PCP.Machine.PolyTimeRel L),\n ∃ f p,\n PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits f ∧\n ∀ (x : List Bool),\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧ (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "PCP.Language", + "PCP.NPCertificate", + "PCP.Machine.PolyTimeRel", + "Exists", + "List", + "Bool", + "Polynomial", + "Nat", + "Nat.instSemiring", + "And", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One actual verifier has all mathematical resource and probability properties,\nincluding the standard soundness target. Efficiency and NP transfer are not asserted. ", + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 70, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verification_guarantees", + "provenance": "lean", + "structural_dependencies": [], + "type": "0 < PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions ∧\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.queries =\n PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 187 ∧\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CanonicalRandomness\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000)\n (PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions * 32000000) ∧\n (∀ (x : List Bool),\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.ReadsBelow x\n (Polynomial.eval x.length PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound)) ∧\n (∀ (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CompleteAt x) ∧\n ∀ (x : List Bool),\n ¬(PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.SoundAt x (1 / 2)", + "type_dependencies": [ + "And", + "LT.lt", + "Nat", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions", + "Eq", + "PCP.Verifier.queries", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "Nat.instSemiring", + "List.length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Embedding the primary-color low-degree test's queries. ", + "end_line": 152, + "is_class": false, + "kind": "definition", + "line": 149, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.colorQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.colorQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.eval_properPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (E Q : MvPolynomial σ F) (x : σ → F),\n (MvPolynomial.eval x) (PCP.Algebraic.ThreeColorGrid.properPolynomial E Q) =\n (MvPolynomial.eval x) E * ((MvPolynomial.eval x) Q ^ 3 - 1)", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Machine.TableauNumericIndex.variableCount.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k T B : ℕ),\n PCP.Machine.TableauNumericIndex.variableCount k T B = (T + 1) * PCP.Machine.TableauNumericIndex.sites k B + 1", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Machine.TableauNumericIndex.variableCount", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Machine.TableauNumericIndex.sites" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (f : PCP.QueryTree.below x_1), x_1.addresses.card < 2 ^ x", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", + "Bool", + "PCP.QueryTree.leaf", + "of_eq_true", + "Preorder.toLT", + "PartialOrder.toPreorder", + "Nat.instPartialOrder", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "MulZeroOneClass.toMulZeroClass", + "MonoidWithZero.toMulZeroOneClass", + "Nat.instMonoidWithZero", + "MonoidWithZero.toMonoid", + "pow_pos._simp_1", + "LinearOrderedCommMonoidWithZero.toPosMulStrictMono", + "Nat.instLinearOrderedCommMonoidWithZero", + "Nat.instZeroLEOneClass", + "SemilatticeInf.toPartialOrder", + "Lattice.toSemilatticeInf", + "DistribLattice.toLattice", + "instDistribLatticeOfLinearOrder", + "Nat.instLinearOrder", + "instOfNatAtLeastTwo", + "AddMonoidWithOne.toNatCast", + "Nat.instAddMonoidWithOne", + "Nat.instAtLeastTwoHAddOfNat", + "Nat.instNeZeroSucc", + "Eq.trans", + "LE.le", + "Preorder.toLE", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "True", + "Order.lt_two_iff._simp_1", + "Nat.instSuccAddOrder", + "Nat.instNoMaxOrder", + "zero_le._simp_1", + "LinearOrderedCommMonoidWithZero.toIsBotZeroClass", + "Nat.succ", + "PCP.QueryTree.query", + "PProd", + "instLENat", + "Insert.insert", + "Finset", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le.trans", + "Nat.instPreorder", + "Finset.card_insert_le", + "Finset.card_union_le", + "Decidable.byContradiction", + "Nat.decLe", + "Not", + "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", + "id", + "Eq", + "Mathlib.Tactic.Ring.of_eq", + "Distrib.toAdd", + "instDistribOfSemiring", + "CommSemiring.toSemiring", + "Nat.instCommSemiring", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "Semiring.toMonoid", + "Nat.rawCast", + "AddCommMonoidWithOne.toAddMonoidWithOne", + "NonAssocSemiring.toAddCommMonoidWithOne", + "Semiring.toNonAssocSemiring", + "instMulZeroClassOfSemiring", + "instMulNat", + "Mathlib.Tactic.Ring.Common.pow_congr", + "Mathlib.Tactic.Ring.cast_pos", + "Mathlib.Meta.NormNum.isNat_ofNat", + "Eq.refl", + "Mathlib.Tactic.Ring.Common.add_congr", + "Mathlib.Tactic.Ring.Common.atom_pf", + "rfl", + "Eq.mpr", + "congrArg", + "Eq.symm", + "Mathlib.Tactic.Ring.Common.add_pf_add_gt", + "Mathlib.Tactic.Ring.Common.add_pf_add_zero", + "Mathlib.Tactic.Ring.Common.pow_add", + "Mathlib.Tactic.Ring.Common.pow_one_cast_of_isNat", + "Mathlib.Meta.NormNum.IsNat.mk", + "Mathlib.Tactic.Ring.Common.single_pow", + "Mathlib.Tactic.Ring.Common.pow_prod_atom", + "Mathlib.Tactic.Ring.Common.pow_zero", + "Mathlib.Tactic.Ring.Common.add_mul", + "Mathlib.Tactic.Ring.Common.mul_add", + "Mathlib.Tactic.Ring.Common.mul_pf_left", + "Mathlib.Meta.NormNum.IsNat.to_raw_eq", + "Mathlib.Meta.NormNum.isNat_mul", + "Mathlib.Meta.NormNum.IsNat.of_raw", + "Mathlib.Tactic.Ring.Common.mul_zero", + "Mathlib.Tactic.Ring.Common.zero_mul", + "Mathlib.Tactic.Ring.Common.mul_pf_right", + "Mathlib.Tactic.Ring.Common.add_pf_add_overlap", + "Mathlib.Tactic.Ring.Common.add_overlap_pf", + "Mathlib.Meta.NormNum.isNat_add", + "Mathlib.Tactic.Ring.Common.add_pf_zero_add", + "Nat.decLt", + "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R)", + "type_dependencies": [ + "CommSemiring", + "RingHomCompTriple", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The edge constraint, using the difference table's polynomial. ", + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [inst : Field F] → MvPolynomial σ F → MvPolynomial σ F → MvPolynomial σ F", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.ThreeColorGrid.validPolynomial" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Below the grid size, the only polynomial vanishing on the grid is zero. ", + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 82, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.eq_zero_of_totalDegree_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R) (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p → p.totalDegree < H.card → p = 0", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "MvPolynomial", + "PCP.Algebraic.GridVanishing.VanishesOn", + "LT.lt", + "Nat", + "instLTNat", + "MvPolynomial.totalDegree", + "Finset.card", + "Eq", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : PCP.Machine.Sym → PCP.Machine.Sym → Sort u_1) →\n (x x_1 : PCP.Machine.Sym) →\n ((a b : Bool) → motive (PCP.Machine.Sym.bit a) (PCP.Machine.Sym.bit b)) →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b) PCP.Machine.Sym.sep) →\n ((b : Bool) → motive PCP.Machine.Sym.sep (PCP.Machine.Sym.bit b)) →\n (Unit → motive PCP.Machine.Sym.sep PCP.Machine.Sym.sep) → motive x x_1", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "Unit" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "Unit", + "PCP.Machine.Sym.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.color" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A certificate that `L` is in NP relative to a notion `P` of polynomial-time checkability: a\npolynomial witness bound and a witness-checking relation that `P` accepts.\n\n`P` is a plain parameter here, and that is safe *because nothing is proved by quantifying over it*.\n`InNP` is a definition, not a theorem. The two consumers each pin it down:\n\n* `pcp_subset_np` instantiates `P := M.PolyTimeRel` for a `CostModel` `M`, whose closure field is\n what makes the conclusion non-vacuous;\n* `np_subset_pcp` instantiates `P := PCP.Machine.PolyTimeRel`, the concrete machine definition.\n\nNeither quantifies over an arbitrary `P`. The distinction matters:\na *theorem* over an unconstrained interface is refutable by choosing a degenerate instance; a\n*definition* parameterised by one is just a definition. ", + "end_line": 39, + "is_class": false, + "kind": "inductive", + "line": 17, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate", + "provenance": "lean", + "structural_dependencies": [ + "PCP.NPCertificate.mk", + "PCP.NPCertificate" + ], + "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Type", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instNonemptyInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F] {m c t : ℕ}, Nonempty (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n PCP.Algebraic.SetMultilinear.encode m c =\n Polynomial.lsum fun k => LinearMap.id.smulRight (PCP.Algebraic.SetMultilinear.digitMonomial m c k)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.lsum", + "LinearMap.smulRight", + "PCP.Algebraic.SetMultilinear.encode._proof_1", + "LinearMap.id", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → Sort u_3) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r) →\n ((p : (σ → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl p)) →\n ((p :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ ×\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c ×\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr p)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "OfNat.ofNat", + "instOfNatNat", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual verifier uses a freshly self-corrected derived primary bit. ", + "end_line": 59, + "is_class": false, + "kind": "definition", + "line": 50, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t r : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Q : (Fin n → F) → Polynomial F) →\n (∀ (x : Fin n → F), (Q x).natDegree ≤ r) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n ((Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t →\n PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r → Option (ZMod 2 × ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Option", + "Prod" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "Field.toCommRing", + "Prod.fst", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le._proof_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n PCP.Algebraic.ThreeColorParameterChoice.exponent N = PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1 + 1 →\n ¬PCP.Algebraic.ThreeColorParameterChoice.exponent N * 2 ≤\n 4 * (PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1) →\n False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Not", + "HMul.hMul", + "instHMul", + "instMulNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.correct.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.correct c ζ f u v =\n PCP.Algebraic.WeightedConstraint.predict (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ)\n (PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ) f u v", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.correct", + "PCP.Algebraic.WeightedConstraint.predict", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries_length_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n (PCP.Algebraic.BinaryLowDegreeTest.queries ⋯ ρ nodes s.2.2.2.2).length ≤ max (2 * 1 + 4) (c + 2) →\n ¬2 * r + 4 +\n (PCP.Algebraic.BinaryLowDegreeTest.queries PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1 ρ nodes\n s.2.2.2.2).length +\n (c + 1) +\n (0 + 1) ≤\n 2 * r + 2 * c + 12 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "LE.le", + "instLENat", + "List.length", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLowDegreeTest.queries", + "le_refl", + "Nat.instPreorder", + "Prod.snd", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Max.max", + "Nat.instMax", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same equality oriented from the concrete certificate definition. ", + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Complexity.ReferenceNPConverse", + "name": "PCP.ReferenceNP.inNP_iff_mem", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : Complexity.Language}, PCP.InNP PCP.Machine.PolyTimeRel L ↔ L ∈ Complexity.NP", + "type_dependencies": [ + "Complexity.Language", + "Iff", + "PCP.InNP", + "PCP.Machine.PolyTimeRel", + "Membership.mem", + "Set", + "Set.instMembership", + "Complexity.NP" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (color : PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t)\n (validLines differenceLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t)\n (properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t)\n (color_1 :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (validCert_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (difference_1 :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (properCert_1 :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (colorLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t)\n (validLines_1 differenceLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t)\n (properLines_1 : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t),\n ({ color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines } =\n { color := color_1, validCert := validCert_1, difference := difference_1, properCert := properCert_1,\n colorLines := colorLines_1, validLines := validLines_1, differenceLines := differenceLines_1,\n properLines := properLines_1 }) =\n (color = color_1 ∧\n validCert = validCert_1 ∧\n difference = difference_1 ∧\n properCert = properCert_1 ∧\n colorLines = colorLines_1 ∧\n validLines = validLines_1 ∧ differenceLines = differenceLines_1 ∧ properLines = properLines_1)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Arbitrary point-dependent weights, including zero, are supported by the cubic transfer. ", + "end_line": 226, + "is_class": false, + "kind": "theorem", + "line": 214, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.weightedCubic_rejection_transfer", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (E : (Fin n → F) → F) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) (f : (Fin n → F) → F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ (E x * (f x ^ 3 - 1))))) M A ≤\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ (fun x => PCP.Algebraic.HadamardDerivedOracle.weightedCubic (E x)) ⋯\n nodes ζ H p M A +\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ p f", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Rat.instAdd", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_weightedCubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 87, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.eval_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (Q : σ → MvPolynomial σ R) (x y : σ → R),\n (MvPolynomial.eval (Sum.elim x y)) (PCP.Algebraic.GridVanishing.certificate Q) =\n ∑ i, (MvPolynomial.eval x) (Q i) * y i", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum.elim", + "PCP.Algebraic.GridVanishing.certificate", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R}\n {polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)}\n {PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg_1 : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R}\n {polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)},\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 } →\n PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 66, + "is_class": false, + "kind": "theorem", + "line": 64, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.distance_expect", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {A : Type u_3} {B : Type u_4} [inst : Fintype A] [inst_1 : DecidableEq B] (k l : A → B),\n PCP.Algebraic.relativeDistance k l = Finset.univ.expect fun a => if k a ≠ l a then 1 else 0", + "type_dependencies": [ + "Fintype", + "DecidableEq", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "ite", + "Ne", + "instDecidableNot", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Corollary 2.10, with the necessary nonempty-alphabet hypothesis. ", + "end_line": 130, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R),\n H.Nonempty →\n ∀ (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p ↔\n ∃ M, M.totalDegree ≤ p.totalDegree ∧ PCP.Algebraic.GridVanishing.IsCertificate H p M", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Iff", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Exists", + "Sum", + "And", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.GridVanishing.IsCertificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A canonical budget *is* the closed-form function of the two constants.\n\nNamed for what it says. It is an equality of functions, not a proposition of type\n`Computable V.randomness`. None is needed downstream: the closed form is evidently computable, and\nthe verifier's efficiency is certified separately through `Verifier.ImplementedBy` and the machine\npredicates of `PCP/Complexity/Machine.lean`. ", + "end_line": 167, + "is_class": false, + "kind": "theorem", + "line": 160, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CanonicalRandomness.eq_closedForm", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.randomness = fun n => a * Nat.clog 2 (n + 2) + b", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "Eq", + "PCP.Verifier.randomness", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Nat.clog", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.callQueries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n)\n (w : Fin t → ZMod 2) (s : PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed F (Fin n ⊕ Fin n) m c t),\n PCP.Algebraic.DerivedZeroOnGrid.callQueries ρ nodes ζ a w s =\n PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ a s.1 s.2.1 s.2.2.1 w s.2.2.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Semiring.toMonoid", + "Eq", + "List", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "PCP.Algebraic.DerivedZeroOnGrid.callQueries", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "Prod.fst", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 38, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 158, + "is_class": false, + "kind": "theorem", + "line": 157, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.CanonicalRandomness.logRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.LogRandomness a b", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.LogRandomness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 173, + "is_class": false, + "kind": "definition", + "line": 173, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Claim 3.2: evaluating the encoding at the power point recovers `P(x)`. ", + "end_line": 107, + "is_class": false, + "kind": "theorem", + "line": 100, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c →\n ∀ (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n ((PCP.Algebraic.SetMultilinear.encode m c) P) =\n Polynomial.eval x P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "LinearMap", + "RingHom.id", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Setting the certificate variables to zero does not increase total degree. ", + "end_line": 138, + "is_class": false, + "kind": "theorem", + "line": 133, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.totalDegree_substitute_zero_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] (M : MvPolynomial (σ ⊕ σ) R),\n ((PCP.Algebraic.GridVanishing.substitute fun x => 0) M).totalDegree ≤ M.totalDegree", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "MvPolynomial", + "Sum", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d addr : ℕ} {onFalse onTrue : PCP.QueryTree d} {addr_1 : ℕ} {onFalse_1 onTrue_1 : PCP.QueryTree d},\n PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1 →\n addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.brecOn.eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {motive : (a : ℕ) → PCP.QueryTree a → Sort u} {a : ℕ} (t : PCP.QueryTree a)\n (F_1 : (a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t),\n PCP.QueryTree.brecOn t F_1 = F_1 a t (PCP.QueryTree.brecOn.go t F_1).2", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "Eq", + "PCP.QueryTree.brecOn", + "PProd", + "PCP.QueryTree.brecOn.go" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H =\n PCP.Algebraic.relativeDistance (PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ f H) fun x => true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Eq", + "Rat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample", + "instDecidableEqBool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_chosen_le._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), ¬M ≤ 1 → ¬1 < M → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "LT.lt", + "instLTNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), 8 ≤ max 8 (Nat.clog 2 N) → ¬2 * 2 ^ 2 ≤ 4 * max 8 (Nat.clog 2 N) → False", + "type_dependencies": [ + "Nat", + "LE.le", + "Preorder.toLE", + "PartialOrder.toPreorder", + "LinearOrder.toPartialOrder", + "Nat.instLinearOrder", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "LinearOrder.toMax", + "Nat.clog", + "Not", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Nat.instMax", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} {a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.validCert a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {randomness : ℕ → ℕ} {queries : ℕ} {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries}\n {randomness_1 : ℕ → ℕ} {queries_1 : ℕ}\n {run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1},\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 } →\n randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "And", + "HEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check_eq_interpolation", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v =\n PCP.Algebraic.LagrangeConstraint.check (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) f u v 0", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "PCP.Algebraic.LagrangeConstraint.check", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → [SizeOf F] → PCP.Algebraic.ThreeColorVerifier.Query F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.rec", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "SizeOf.sizeOf", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (6 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each concrete NP checker has an unconditional polynomial-time graph reduction. ", + "end_line": 190, + "is_class": false, + "kind": "theorem", + "line": 167, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.checker_reduction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ),\n ∃ f p,\n PCP.Machine.PolyTimeMap PCP.Machine.ofBits PCP.Machine.ofBits f ∧\n ∀ (x : List Bool),\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔\n ∃ w, w.length ≤ Polynomial.eval x.length q ∧ R x w = true) ∧\n (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Exists", + "And", + "PCP.Machine.PolyTimeMap", + "PCP.Machine.ofBits", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 106, + "is_class": false, + "kind": "theorem", + "line": 92, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.distance_sample_origin", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] {A : Type u_3} [inst_5 : DecidableEq A]\n (k l : (σ → F) → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k s.1 s.2.2.1.2) fun s => l s.1 s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v = f u - PCP.Algebraic.GeneratorLowDegreeTest.correct c ζ f u v", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.check", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "PCP.Algebraic.GeneratorLowDegreeTest.correct" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "definition", + "line": 131, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.read.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t r : ℕ} →\n (motive : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t r → Sort u_2) →\n (x : PCP.Algebraic.DerivedZeroOnGrid.Query F n m c t r) →\n ((q : (Fin n → F) × PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r) → motive (Sum.inl q)) →\n ((q :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n ×\n PCP.Algebraic.BinaryLocalCorrection.Query F (Fin n ⊕ Fin n) m c t) →\n motive (Sum.inr q)) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 45, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.properLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries_length_le._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n (PCP.Algebraic.BinaryZeroOnGridCorrection.queries ρ nodes ζ H (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)).length ≤\n 6 * c + 19 →\n ¬(PCP.Algebraic.BinaryZeroOnGridCorrection.queries ρ nodes ζ H\n (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)).length +\n 1 ≤\n 6 * c + 20 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "LE.le", + "instLENat", + "List.length", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "PCP.Algebraic.BinaryZeroOnGridCorrection.queries", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "HMul.hMul", + "instHMul", + "instMulNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 41, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (c : ℕ) (ζ : F) (u v : σ → F),\n PCP.Algebraic.GeneratorLowDegreeTest.queries c ζ u v =\n u :: List.ofFn fun i => PCP.Algebraic.PolynomialLine.point u v (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i)", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "List", + "PCP.Algebraic.GeneratorLowDegreeTest.queries", + "List.cons", + "List.ofFn", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.PolynomialLine.point", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t →\n {F' : Type u_2} → {n' m' c' t' : ℕ} → PCP.Algebraic.ThreeColorVerifier.Query F' n' m' c' t' → Sort u", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "dite", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Nat.decEq", + "PCP.Algebraic.ThreeColorVerifier.Query.color.elim", + "HEq", + "Not", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.difference.elim", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert.elim", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.elim", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine.elim" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate_nodes._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} (ζ : F) (f : (σ → F) → F) (u v : σ → F),\n PCP.Algebraic.LagrangeConstraint.check (PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ) f u v 0 =\n PCP.Algebraic.GeneratorLowDegreeTest.check c ζ f u v", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "PCP.Algebraic.LagrangeConstraint.check", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.GeneratorLowDegreeTest.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval.eq_def", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 : PCP.ProofOracle),\n x_1.eval x_2 =\n match x, x_1, x_2 with\n | x, PCP.QueryTree.leaf b, x_3 => b\n | .(d + 1), PCP.QueryTree.query a f t, π => if π a = true then t.eval π else f.eval π", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Eq", + "Bool", + "PCP.QueryTree.eval", + "PCP.QueryTree.eval.match_1", + "ite", + "Bool.true", + "instDecidableEqBool" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.correctedAt.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (ζ : F) (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t)\n (parameter : Fˣ → F) (s : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n PCP.Algebraic.BinaryLocalCorrection.correctedAt ρ ζ H parameter s =\n PCP.Algebraic.BinaryStandardLocalCorrection.correct c ζ ρ (H s.1)\n (PCP.Algebraic.SetMultilinear.evaluationPoint m c (parameter s.2.1)) s.2.2.1.1 s.2.2.1.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.correctedAt", + "PCP.Algebraic.BinaryStandardLocalCorrection.correct", + "PCP.Algebraic.SetMultilinear.Variables", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual correction error averaged over every seed, for an arbitrary chosen inner table. ", + "end_line": 232, + "is_class": false, + "kind": "theorem", + "line": 206, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.correction_error_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] [CharP F 2] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (Q :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F),\n (∀ (uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ), (Q uv).totalDegree ≤ c) →\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H) fun s =>\n (PCP.Algebraic.Hadamard.linearEncode\n (ρ (Polynomial.eval s.2.1 ((PCP.Algebraic.SetMultilinear.decode m c) (Q s.1)))))\n s.2.2.1.2) ≤\n ↑(c + 1) *\n Finset.univ.expect fun uv =>\n PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ (H uv) fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) (Q uv))))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "ZMod.decidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Nat.cast", + "Rat.instNatCast", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "Fin.fintype", + "instDecidableEqProd", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "PCP.Algebraic.Hadamard.encode", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.expect_sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (k : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → ℚ),\n (Finset.univ.expect fun s => k s) =\n Finset.univ.expect fun b =>\n Finset.univ.expect fun z => Finset.univ.expect fun vw => Finset.univ.expect fun s => k (b, z, vw, s)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Search the coordinate-induced field order for the first nontrivial cube root. ", + "end_line": 86, + "is_class": false, + "kind": "definition", + "line": 83, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.cubeRoot", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → PCP.Algebraic.ThreeColorFields.FieldFamily k", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorFields.FieldFamily" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.FiniteRootSearch.root", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Equiv.decidableEq", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.ThreeColorFields.fieldCode", + "instDecidableEqFin" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} {a_2 : PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3},\n PCP.Algebraic.ThreeColorVerifier.Query.color a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.color a_2 a_3 →\n a = a_2 ∧ a_1 = a_3", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeAnswer.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((a : ℕ) → motive (Sum.inr a)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 128, + "is_class": false, + "kind": "constructor", + "line": 128, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The noncentral weights sum to one, so with `η₀ = -1` and `0^0 = 1` the weighted sum of the\nconstant monomial vanishes. The forward direction of Fact 2.7 is proved through uniqueness of\nLagrange interpolation instead and does not use this identity; it is retained for\n`PCP/Audit/GeneratorLowDegree.lean`. ", + "end_line": 109, + "is_class": false, + "kind": "theorem", + "line": 103, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.sum_weights", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) → ∑ i, PCP.Algebraic.GeneratorLowDegreeTest.weights c ζ i = 1", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "Finset.sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Semiring.toAddCommMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Finset.univ", + "Fin.fintype", + "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Only the first `N` proof bits matter when `V.ReadsBelow x N`. ", + "end_line": 128, + "is_class": false, + "kind": "theorem", + "line": 121, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_congr_of_readsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) {N : ℕ},\n V.ReadsBelow x N → ∀ {π π' : PCP.ProofOracle}, (∀ a < N, π a = π' a) → V.accProb x π = V.accProb x π'", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Nat", + "PCP.Verifier.ReadsBelow", + "PCP.ProofOracle", + "LT.lt", + "instLTNat", + "Eq", + "Rat", + "PCP.Verifier.accProb" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 54, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.fraction_shared_snd", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (E : W × S → Prop),\n (PCP.Algebraic.AffineLineSampling.fraction fun s => E (s.1, s.2.2)) = PCP.Algebraic.AffineLineSampling.fraction E", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Eq", + "Rat", + "PCP.Algebraic.AffineLineSampling.fraction", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m c : ℕ),\n PCP.Algebraic.SetMultilinear.decode m c =\n MvPolynomial.eval₂Hom Polynomial.C fun ij => Polynomial.X ^ (↑ij.2 * m ^ ↑ij.1)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "Eq", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "PCP.Algebraic.SetMultilinear.decode", + "MvPolynomial.eval₂Hom", + "Polynomial.commSemiring", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.X", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "definition", + "line": 133, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 6 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 226, + "is_class": false, + "kind": "theorem", + "line": 222, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_differenceQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.differenceQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.difference π.differenceLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.differenceQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A bound linear in the inner degree and primary Hadamard degree. ", + "end_line": 78, + "is_class": false, + "kind": "theorem", + "line": 71, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n (PCP.Algebraic.EncodedLineLowDegreeTest.queries hr ρ nodes ζ s).length ≤ 2 * r + 2 * c + 12", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "List.length", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "recursor", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → (t : PCP.Machine.Sym) → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.honestProof._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "definition", + "line": 127, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.difference a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.sizePoly", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : List Bool → List Bool → Bool} → PCP.Machine.NPTableau.Checker R → Polynomial ℕ → ℕ → ℕ → Polynomial ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "HMul.hMul", + "instHMul", + "Polynomial.instMul", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "HAdd.hAdd", + "instHAdd", + "Polynomial.instAdd", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "OfNat.ofNat", + "One.toOfNat1", + "Polynomial.instOne", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) (a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.difference a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.mk.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (color : PCP.Algebraic.ThreeColorVerifier.Vertex F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2)\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t)\n (validLines differenceLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t)\n (properLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t),\n sizeOf\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines } =\n 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Proof._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Definition 3.1's constant total-degree bound. ", + "end_line": 151, + "is_class": false, + "kind": "theorem", + "line": 148, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.totalDegree_encode_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n ((PCP.Algebraic.SetMultilinear.encode m c) P).totalDegree ≤ c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ) (b : PCP.Algebraic.BinaryMaterializedField.Element (4 * (k + 1))),\n b ∈\n Finset.map { toFun := ⇑(PCP.Algebraic.BinaryMaterializedField.coefficientEquiv (4 * (k + 1))).symm, inj' := ⋯ }\n Finset.univ", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryMaterializedField.Element", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.map", + "Fin", + "ZMod", + "Function.Embedding.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.BinaryMaterializedField.coefficientEquiv", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_1", + "Finset.univ", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryMaterializedField.instFintypeElement._proof_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Each branch has its genuine finite uniform sample space. ", + "end_line": 395, + "is_class": false, + "kind": "definition", + "line": 391, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchSeedFintype", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t : ℕ} →\n [Fintype F] → [DecidableEq F] → (i : Fin 7) → Fintype (PCP.Algebraic.ThreeColorVerifier.BranchSeed F n m c t i)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Fin.cases", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "id", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.instOfNat", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_1", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.ThreeColorVerifier.instFintypeSampleOfDecidableEq", + "Fin.fintype", + "instDecidableEqFin", + "Fin.succ", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_2", + "Sum", + "instFintypeSum", + "instDecidableEqSum", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_3", + "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_4", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "PCP.Algebraic.ThreeColorVerifier.instFintypeTestSample", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_9", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "ZMod", + "instFintypeProd", + "Pi.instFintype", + "ZMod.fintype", + "Fin.elim0" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Forget only the newly drawn primary-correction seed. ", + "end_line": 38, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {n m c t r : ℕ} →\n PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r →\n PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample" + ], + "value_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Prod.mk", + "Fin", + "Prod", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual derived-grid verifier uses at most `6c+20` bit queries. ", + "end_line": 102, + "is_class": false, + "kind": "theorem", + "line": 95, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries_length_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n (PCP.Algebraic.DerivedZeroOnGrid.queries ρ Q hQ nodes ζ H s).length ≤ 6 * c + 20", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "List.length", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "HMul.hMul", + "instHMul", + "instMulNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u →\n {P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n PCP.NPCertificate P L →\n {P' : (List Bool → List Bool → Bool) → Prop} → {L' : PCP.Language} → PCP.NPCertificate P' L' → Sort u", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "PCP.NPCertificate.casesOn", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Iff", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq", + "Bool.true" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 155, + "is_class": false, + "kind": "theorem", + "line": 153, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.totalDegree_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c → P ≠ 0 → ((PCP.Algebraic.SetMultilinear.encode m c) P).totalDegree = c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "Polynomial.instZero", + "Eq", + "MvPolynomial.totalDegree", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym → ℕ", + "type_dependencies": [ + "PCP.Machine.Sym", + "Nat" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "PCP.Machine.Sym.casesOn", + "Nat", + "Bool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Recovery proves injectivity on the bounded-degree domain, even over finite fields. ", + "end_line": 121, + "is_class": false, + "kind": "theorem", + "line": 115, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_injective_on", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n Set.InjOn ⇑(PCP.Algebraic.SetMultilinear.encode m c) {P | P.natDegree < m ^ c}", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Set.InjOn", + "Polynomial", + "CommSemiring.toSemiring", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode", + "Set.ofPred", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n [Fintype F] → [Fintype σ] → [DecidableEq σ] → Fintype (PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "instFintypeProd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed_1._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The verifier performs every listed branch, so its complete list concatenates all seven. ", + "end_line": 207, + "is_class": false, + "kind": "definition", + "line": 203, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.queries", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n (H : Finset F) →\n SimpleGraph (Fin n → ↥H) →\n PCP.Algebraic.ThreeColorVerifier.Sample F n m c t →\n List (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "List", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "List.flatten", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List.ofFn", + "List", + "PCP.Algebraic.ThreeColorVerifier.branchQueries" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The reverse inclusion follows by guessing the bounded proof prefix and\nchecking all logarithmically many random bits. The concrete machine model\nsatisfies the cost-model closure properties in `PCP.Complexity.StandardModel`. ", + "end_line": 72, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Theorem", + "name": "PCP.pcp_subset_np", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : PCP.CostModel) (L : PCP.Language) (V : PCP.Verifier) (a b : ℕ) (p : Polynomial ℕ),\n M.Efficient V →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n (∀ (x : List Bool), L x → V.CompleteAt x) →\n (∀ (x : List Bool), ¬L x → V.SoundAt x (1 / 2)) → PCP.InNP M.PolyTimeRel L", + "type_dependencies": [ + "PCP.CostModel", + "PCP.Language", + "PCP.Verifier", + "Nat", + "Polynomial", + "Nat.instSemiring", + "PCP.CostModel.Efficient", + "PCP.Verifier.CanonicalRandomness", + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.Verifier.CompleteAt", + "Not", + "PCP.Verifier.SoundAt", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.InNP", + "PCP.CostModel.PolyTimeRel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 429, + "is_class": false, + "kind": "theorem", + "line": 425, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 0 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.color π.colorLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Fin.fintype", + "instDecidableEqFin", + "Decidable.byContradiction", + "LE.le", + "instLENat", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym.decEq._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (a : Bool), PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit a", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.eq_def", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x),\n x_1.addresses =\n match x, x_1 with\n | x, PCP.QueryTree.leaf accept => ∅\n | .(d + 1), PCP.QueryTree.query a f t => insert a (f.addresses ∪ t.addresses)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "Finset", + "PCP.QueryTree.addresses", + "PCP.QueryTree.addresses.match_1", + "Bool", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 127, + "is_class": false, + "kind": "definition", + "line": 127, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.difference.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 2 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.difference" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Lemma 2.9: a bounded family of multiples of the coordinate vanishing polynomials. ", + "end_line": 148, + "is_class": false, + "kind": "theorem", + "line": 133, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_decomposition", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] [inst_3 : Fintype σ] (H : Finset R)\n (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p ↔\n ∃ Q,\n (∀ (i : σ), (Q i).totalDegree ≤ p.totalDegree - H.card) ∧\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Fintype", + "Finset", + "MvPolynomial", + "Iff", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Exists", + "And", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A uniform decoding constant, incorporating the proved soundness threshold. ", + "end_line": 30, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HMul.hMul", + "Rat", + "instHMul", + "Rat.instMul", + "OfNat.ofNat", + "Rat.instOfNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (a_2 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.validCert a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 123, + "is_class": false, + "kind": "theorem", + "line": 113, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.eval_zero_eq_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} {a : Fin (c + 1) → F},\n Function.Injective a →\n ∀ (P : Polynomial F),\n P.natDegree ≤ c →\n Polynomial.eval 0 P = ∑ i, PCP.Algebraic.LagrangeConstraint.weight a 0 i * Polynomial.eval (a i) P", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "Polynomial.eval", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "Finset.sum", + "Semiring.toAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "HMul.hMul", + "instHMul", + "Distrib.toMul", + "instDistribOfSemiring", + "PCP.Algebraic.LagrangeConstraint.weight" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 105, + "is_class": false, + "kind": "theorem", + "line": 103, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator_goodNodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), PCP.Algebraic.StandardLocalCorrection.GoodNodes 4 (PCP.Algebraic.ThreeColorFields.generator k)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 166, + "is_class": false, + "kind": "definition", + "line": 163, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin (n + n) ⊕ Fin (n + n)) m c t 1 →\n PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.properQuery.match_1", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p m₀ mZ : Option (ZMod 2)),\n (∀ (p_1 m₀_1 mZ_1 : ZMod 2), p = some p_1 → m₀ = some m₀_1 → mZ = some mZ_1 → False) →\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck p m₀ mZ = none", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Option.some", + "False", + "Prod", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → ℕ", + "type_dependencies": [ + "PCP.Verifier", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (x : ℕ) (accept : Bool)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match x, PCP.QueryTree.leaf accept with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_1 x accept", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Eq", + "PCP.QueryTree.addresses.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ), ¬n ≤ c + 1 → ¬c + 1 + (n - (c + 1)) = n → False", + "type_dependencies": [ + "Nat", + "Fintype", + "Not", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 85, + "is_class": false, + "kind": "definition", + "line": 85, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {randomness : ℕ → ℕ} →\n {queries : ℕ} →\n {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries} →\n {randomness' : ℕ → ℕ} →\n {queries' : ℕ} →\n {run' : (x : List Bool) → Fin (2 ^ randomness' x.length) → PCP.QueryTree queries'} →\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness', queries := queries', run := run' } →\n (randomness = randomness' → queries = queries' → run ≍ run' → P) → P", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "HEq" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "HEq", + "id", + "PCP.Verifier.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 1) →\n ((x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin n ⊕ Fin n)) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 138, + "is_class": false, + "kind": "theorem", + "line": 125, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.polynomial_predict", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} {a : Fin (c + 1) → F},\n Function.Injective a →\n ∀ (P : Polynomial F),\n P.natDegree ≤ c →\n ∀ (u v : F),\n Polynomial.eval u P =\n PCP.Algebraic.WeightedConstraint.predict a (PCP.Algebraic.LagrangeConstraint.weight a 0)\n (fun x => Polynomial.eval x P) u v", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Function.Injective", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Eq", + "Polynomial.eval", + "PCP.Algebraic.WeightedConstraint.predict", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Semiring.toModule", + "Fin.fintype", + "PCP.Algebraic.LagrangeConstraint.weight", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries_length_eq._proof_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n ¬2 +\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1)\n s.2.1.2.1.1 s.2.1.2.1.2.1 s.2.1.2.1.2.2.1 s.2.1.1 s.2.1.2.1.2.2.2).length +\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)\n s.2.1.2.2.1 s.2.1.2.2.2.1 s.2.1.2.2.2.2.1 s.2.1.1 s.2.1.2.2.2.2.2).length =\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1)\n s.2.1.2.1.1 s.2.1.2.1.2.1 s.2.1.2.1.2.2.1 s.2.1.1 s.2.1.2.1.2.2.2).length +\n (PCP.Algebraic.BinaryLocalCorrection.queries ρ nodes ζ\n (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1) s.2.1.2.2.1 s.2.1.2.2.2.1 s.2.1.2.2.2.2.1 s.2.1.1\n s.2.1.2.2.2.2.2).length +\n 1 +\n 1 →\n False", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Not", + "Eq", + "List.length", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "PCP.Algebraic.BinaryLocalCorrection.queries", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "Prod.fst", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 79, + "is_class": false, + "kind": "definition", + "line": 79, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.mk.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R} →\n {polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)} →\n {PolyTimeRel' : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg' : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable' : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel' R → Computable₂ R} →\n {polyTimeAlg_computable' :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg' alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck' :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg' alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel' (PCP.finiteWitnessCheck V)} →\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel', PolyTimeAlg := PolyTimeAlg',\n polyTimeRel_computable := polyTimeRel_computable',\n polyTimeAlg_computable := polyTimeAlg_computable',\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck' } →\n (PolyTimeRel = PolyTimeRel' → PolyTimeAlg = PolyTimeAlg' → P) → P", + "type_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq", + "PCP.CostModel", + "PCP.CostModel.mk", + "id", + "PCP.CostModel.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Vanishing at every point of the Cartesian grid, including zero-dimensional grids. ", + "end_line": 31, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.VanishesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → Finset R → MvPolynomial σ R → Prop", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring" + ], + "value_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.colorQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3) →\n ((x : Fin n → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin n)) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 107, + "is_class": false, + "kind": "theorem", + "line": 106, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_nonneg", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), 0 ≤ V.accProb x π", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "LE.le", + "Rat", + "Rat.instLE", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Verifier.accProb" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 223, + "is_class": false, + "kind": "theorem", + "line": 214, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_boundedEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c →\n ∀ (P : ↥(Polynomial.degreeLE R ↑d)) (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n ((PCP.Algebraic.SetMultilinear.boundedEncode m c d) P) =\n Polynomial.eval x ↑P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "LinearMap", + "RingHom.id", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.boundedEncode", + "Polynomial.eval", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A fresh independent coefficient seed is drawn after the original grid sample. ", + "end_line": 34, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Prod", + "Fin", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every coloring has a low-degree extension satisfying both grid constraints. ", + "end_line": 132, + "is_class": false, + "kind": "theorem", + "line": 116, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_constraints", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F) (G : SimpleGraph (σ → ↥H)),\n G.Colorable 3 ↔\n ∃ P,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) ∧\n PCP.Algebraic.GridVanishing.VanishesOn H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P))", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Iff", + "SimpleGraph.Colorable", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Fintype.card", + "PCP.Algebraic.GridVanishing.VanishesOn", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "Sum", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 94, + "is_class": false, + "kind": "definition", + "line": 93, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Sample", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Monoid", + "Nat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`V` is efficiently implementable in the model `M`. ", + "end_line": 115, + "is_class": false, + "kind": "definition", + "line": 114, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.Efficient", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → PCP.Verifier → Prop", + "type_dependencies": [ + "PCP.CostModel", + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.CostModel", + "PCP.Verifier", + "Exists", + "PCP.VerifierAlg", + "And", + "PCP.CostModel.PolyTimeAlg", + "PCP.Verifier.ImplementedBy" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F] (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1) = 1", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 62, + "is_class": false, + "kind": "theorem", + "line": 57, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] (H : Finset R) (i : σ),\n PCP.Algebraic.GridVanishing.coordinate H i ≠ 0", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finset", + "Ne", + "MvPolynomial", + "PCP.Algebraic.GridVanishing.coordinate", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "definition", + "line": 131, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 5 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "definition", + "line": 133, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n {a' : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n} →\n {a'_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c} →\n {a'_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1} →\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a' a'_1 a'_2 →\n (a ≍ a' → a_1 ≍ a'_1 → a_2 ≍ a'_2 → P) → P", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "HEq" + ], + "value_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual rejection of the concrete procedure, including either failed check. ", + "end_line": 41, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n [Fintype F] →\n [DecidableEq F] →\n [Fintype σ] →\n [DecidableEq σ] →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n ((σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) → (σ → F) → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "PCP.Algebraic.AffineLineSampling.fraction", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_2", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Eq", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.none" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 81, + "is_class": false, + "kind": "theorem", + "line": 77, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.eval_digitMonomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ) (x : R),\n (MvPolynomial.eval (PCP.Algebraic.SetMultilinear.evaluationPoint m c x))\n (PCP.Algebraic.SetMultilinear.digitMonomial m c k) =\n x ^ (k % m ^ c)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.SetMultilinear.evaluationPoint", + "PCP.Algebraic.SetMultilinear.digitMonomial", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "HMod.hMod", + "instHMod", + "Nat.instMod", + "Nat.instMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 33, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_rename", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R) (p : MvPolynomial σ R),\n (PCP.Algebraic.GridVanishing.substitute Y) ((MvPolynomial.rename Sum.inl) p) = p", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "AlgHom", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "AddMonoidAlgebra.algebra", + "Algebra.id", + "AlgHom.funLike", + "MvPolynomial.rename", + "Sum.inl" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 379, + "is_class": false, + "kind": "definition", + "line": 378, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeSampleOfDecidableEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {m c t : ℕ} →\n [Fintype F] →\n {σ : Type u_2} →\n [Fintype σ] → [DecidableEq σ] → {r : ℕ} → Fintype (PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "instFintypeProd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "PCP.Algebraic.ThreeColorVerifier.instFintypeInnerPoint", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "PCP.Algebraic.ThreeColorVerifier.instFintypeProdTestRandomnessInnerSeed" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_ne_zero._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)", + "type_dependencies": [ + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 50, + "is_class": false, + "kind": "theorem", + "line": 49, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (f : List Bool → Bool ⊕ ℕ) (as : List Bool),\n PCP.QueryTree.ofStep f 0 as =\n match f as with\n | Sum.inl b => PCP.QueryTree.leaf b\n | Sum.inr val => PCP.QueryTree.leaf false", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "Eq", + "PCP.QueryTree", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.ofStep", + "PCP.QueryTree.ofStep.match_1", + "PCP.QueryTree.leaf", + "Bool.false" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness only needs the decoded difference identity and the two grid equations;\nit imposes no interpolation-degree restriction on the decoded coloring. ", + "end_line": 171, + "is_class": false, + "kind": "theorem", + "line": 162, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.colorable_of_vanishing", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n [CharP F 2] {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F) (G : SimpleGraph (σ → ↥H)) (P : MvPolynomial σ F) (Q : MvPolynomial (σ ⊕ σ) F),\n Q = PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P →\n PCP.Algebraic.GridVanishing.VanishesOn H (PCP.Algebraic.ThreeColorGrid.validPolynomial P) →\n PCP.Algebraic.GridVanishing.VanishesOn H\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G) Q) →\n G.Colorable 3", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "PCP.Algebraic.GridVanishing.VanishesOn", + "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "SimpleGraph.Colorable" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.queries ρ Q hQ nodes ζ H s =\n List.map (fun q => Sum.inl (s.1, q))\n (PCP.Algebraic.HadamardDerivedOracle.queries ρ (Q s.1) ⋯\n ((PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.DerivedZeroOnGrid.check._proof_2) s.2.1.1) s.2.2) ++\n List.map (fun q => Sum.inr (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1, q))\n (PCP.Algebraic.DerivedZeroOnGrid.callQueries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1) s.2.1.1\n s.2.1.2.1) ++\n List.map (fun q => Sum.inr (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1, q))\n (PCP.Algebraic.DerivedZeroOnGrid.callQueries ρ nodes ζ (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)\n s.2.1.1 s.2.1.2.2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Eq", + "List", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "HAppend.hAppend", + "Sum", + "Prod", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "instHAppendOfAppend", + "List.instAppend", + "List.map", + "Sum.inl", + "Prod.mk", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.HadamardDerivedOracle.queries", + "Field.toCommRing", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "Sum.inr", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "PCP.Algebraic.DerivedZeroOnGrid.callQueries", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", + "type_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ], + "value_dependencies": [ + "PCP.Verifier", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk", + "PCP.Verifier.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "definition", + "line": 43, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → Fintype (PCP.Algebraic.ThreeColorFields.FieldFamily k)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.ThreeColorFields.FieldFamily" + ], + "value_dependencies": [ + "Nat", + "Fintype.mk", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "Finset.map", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "ZMod", + "PCP.Algebraic.BinaryMaterializedField.Element", + "Function.Embedding.mk", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.BinaryMaterializedField.coefficientEquiv", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_1", + "Finset.univ", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryMaterializedField.instFintypeElement._proof_1", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_2" + ] + }, + { + "axioms": [], + "doc": "Choose the least positive power of sixteen reaching the requested threshold. ", + "end_line": 116, + "is_class": false, + "kind": "definition", + "line": 115, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.index", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 120, + "is_class": false, + "kind": "theorem", + "line": 118, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.index_add_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), PCP.Algebraic.ThreeColorFields.index M + 1 = max 1 (Nat.clog 16 M)", + "type_dependencies": [ + "Nat", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.index", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate_lower_bound._simp_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", + "type_dependencies": [ + "Fintype", + "Eq", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "Finset.univ", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGrid.optionCheck._sparseCasesOn_1.else_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))\n («else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck._sparseCasesOn_1 t some «else» = «else» h", + "type_dependencies": [ + "Option", + "Option.some", + "Nat.hasNotBit", + "Option.ctorIdx", + "Eq", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck._sparseCasesOn_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A colorable grid graph supplies an actual eight-table proof accepted on every seed. ", + "end_line": 124, + "is_class": false, + "kind": "theorem", + "line": 100, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [NeZero m] [CharP F 2]\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n Function.Injective nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {ω : F},\n IsPrimitiveRoot ω 3 →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (G : SimpleGraph (Fin n → ↥H)),\n G.Colorable 3 →\n 5 * ((H.card - 1) * n) < m ^ c →\n ∃ π,\n ∀ (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s = true", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Function.Injective", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "Finset", + "Finset.Nonempty", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "SimpleGraph.Colorable", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Exists", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "Eq", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The concrete `FinTM2` certificate class is exactly ComplexityLib's NP.\nNeither direction requires a supplied machine simulation or cost premise. ", + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 32, + "module": "PCP.Complexity.ReferenceNPConverse", + "name": "PCP.ReferenceNP.mem_iff_inNP", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {L : Complexity.Language}, L ∈ Complexity.NP ↔ PCP.InNP PCP.Machine.PolyTimeRel L", + "type_dependencies": [ + "Complexity.Language", + "Iff", + "Membership.mem", + "Set", + "Set.instMembership", + "Complexity.NP", + "PCP.InNP", + "PCP.Machine.PolyTimeRel" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The algorithm's actual encoded graph is colorable exactly for bounded-witness acceptance. ", + "end_line": 60, + "is_class": false, + "kind": "theorem", + "line": 55, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.decode_colorable_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (x : List Bool),\n (PCP.Algebraic.ThreeColorEncoding.graph (PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x)).Colorable 3 ↔\n ∃ w, w.length ≤ Polynomial.eval x.length q ∧ R x w = true", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "Iff", + "SimpleGraph.Colorable", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Reduction.NPThreeColorRuntime.encode", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "instOfNatNat", + "Exists", + "And", + "LE.le", + "instLENat", + "List.length", + "Polynomial.eval", + "Eq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype F] {inst_2 : DecidableEq F} [inst_3 : DecidableEq F]\n [inst_4 : Fintype σ] {inst_5 : DecidableEq σ} [inst_6 : DecidableEq σ] (c c_1 : ℕ),\n c = c_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (f f_1 : (σ → F) → F),\n f = f_1 →\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c ζ f =\n PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate c_1 ζ_1 f_1", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Eq", + "Rat", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 231, + "is_class": false, + "kind": "theorem", + "line": 225, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode_injective", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c → Function.Injective ⇑(PCP.Algebraic.SetMultilinear.boundedEncode m c d)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Function.Injective", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.boundedEncode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {F : Type u_2} →\n {n m c t : ℕ} →\n {t_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t} →\n {F' : Type u_2} →\n {n' m' c' t' : ℕ} →\n {t'_1 : PCP.Algebraic.ThreeColorVerifier.Proof F' n' m' c' t'} →\n F = F' →\n n = n' →\n m = m' →\n c = c' → t = t' → t_1 ≍ t'_1 → PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType P t_1 t'_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "HEq", + "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "HEq", + "Eq.ndrec", + "PCP.Algebraic.ThreeColorVerifier.Proof.noConfusionType", + "PCP.Algebraic.ThreeColorVerifier.Proof.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HEq.refl", + "eq_of_heq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 44, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.smallError_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), PCP.Algebraic.GeneratorLowDegreeTest.smallError c < 1 / (2 * (↑c + 2) ^ 2)", + "type_dependencies": [ + "Nat", + "LT.lt", + "Rat", + "Rat.instLT", + "PCP.Algebraic.GeneratorLowDegreeTest.smallError", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 302, + "is_class": false, + "kind": "definition", + "line": 301, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.check", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [Field F] → {c : ℕ} → (Fin (c + 1) → F) → ((σ → F) → F) → (σ → F) → (σ → F) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.LagrangeConstraint.check", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The auxiliary oracle explicitly uses degree-one Hadamard labels. ", + "end_line": 32, + "is_class": false, + "kind": "definition", + "line": 31, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → ℕ → ℕ → ℕ → Type (max u_4 u_3)", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.exists_program._proof_1_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (P : PCP.Lang.Prog) (A C D : ℕ)\n (x : List Bool),\n PCP.Lang.listSize\n ((PCP.Reduction.NPTableauGraphLang.program h hs eK eA).run\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q) x)) ≤\n D *\n (Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1) ^\n 2 →\n P.cost (List.map Bool.toNat x) ≤ A * (2 * x.length + 1) ^ 2 →\n PCP.Lang.listSize\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q) x) ≤\n A * (2 * x.length + 1) →\n (PCP.Reduction.NPTableauGraphLang.program h hs eK eA).cost\n (PCP.Machine.NPTableauSource.input (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q) x) ≤\n C *\n (A * (2 * x.length + 1) + Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1) ^\n 6 →\n ¬P.cost (List.map Bool.toNat x) +\n (PCP.Reduction.NPTableauGraphLang.program h hs eK eA).cost\n (PCP.Machine.NPTableauSource.input\n (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q))\n (Polynomial.eval x.length q) x) +\n PCP.Lang.listSize\n (PCP.Machine.NPTableauSource.input\n (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q)\n x) +\n PCP.Lang.listSize\n ((PCP.Reduction.NPTableauGraphLang.program h hs eK eA).run\n (PCP.Machine.NPTableauSource.input\n (Polynomial.eval x.length (PCP.Machine.NPTableau.timePoly h q))\n (Polynomial.eval x.length (PCP.Machine.NPTableau.spacePoly h q)) (Polynomial.eval x.length q)\n x)) +\n 5 ≤\n A * (2 * x.length + 1) ^ 2 +\n C *\n (A * (2 * x.length + 1) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1) ^\n 6 +\n A * (2 * x.length + 1) +\n D *\n (Polynomial.eval x.length (PCP.Reduction.NPThreeColor.variablesPoly h q k) +\n Polynomial.eval x.length (PCP.Reduction.NPThreeColor.constraintsPoly h q k) +\n 1) ^\n 2 +\n 5 →\n False", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Lang.Prog", + "LE.le", + "instLENat", + "PCP.Lang.listSize", + "PCP.Lang.Prog.run", + "PCP.Reduction.NPTableauGraphLang.program", + "PCP.Machine.NPTableauSource.input", + "Polynomial.eval", + "List.length", + "PCP.Machine.NPTableau.timePoly", + "PCP.Machine.NPTableau.spacePoly", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Reduction.NPThreeColor.variablesPoly", + "PCP.Reduction.NPThreeColor.constraintsPoly", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Lang.Prog.cost", + "List.map", + "Bool.toNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 126, + "is_class": false, + "kind": "definition", + "line": 126, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validCert.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 1 →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "theorem", + "line": 31, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.expect_pair", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {U : Type u_5} {V : Type u_6} [inst : Fintype U] [inst_1 : Fintype V] (f : U × V → ℚ),\n (Finset.univ.expect fun uv => f uv) = Finset.univ.expect fun u => Finset.univ.expect fun v => f (u, v)", + "type_dependencies": [ + "Fintype", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 39, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGridCorrection.expect_shared_snd", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {W : Type u_2} {S : Type u_3} [inst : Fintype W] [inst_1 : Fintype S] [Nonempty S] (f : W × S → ℚ),\n (Finset.univ.expect fun s => f (s.1, s.2.2)) = Finset.univ.expect fun s => f s", + "type_dependencies": [ + "Fintype", + "Nonempty", + "Prod", + "Rat", + "Eq", + "Finset.expect", + "Rat.addCommMonoid", + "Algebra.toModule", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Field.toSemifield", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "instFintypeProd", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An explicit rejection lower bound, with a provably positive denominator. ", + "end_line": 325, + "is_class": false, + "kind": "theorem", + "line": 300, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_ge", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : DecidableEq F]\n [CharP F 2] {n m c t D : ℕ} [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (H : Finset F),\n H.Nonempty →\n ∀ (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F),\n P.totalDegree ≤ D →\n M.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ¬PCP.Algebraic.GridVanishing.VanishesOn H P →\n ∀ (p' : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (M' :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t) {δP δM : ℚ},\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ p' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) P)))) ≤\n δP →\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance ⋯ M' fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ ((MvPolynomial.eval x) M)))) ≤\n δM →\n ((1 - ↑(D * H.card) / ↑(Fintype.card F)) / 2 - δP - 2 * δM -\n ↑D / ↑(Fintype.card F - 1)) /\n (1 + 2 * PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c) ≤\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H p' M' A", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Not", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Field.toCommRing", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "Fin.fintype", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "instFintypeSum", + "instDecidableEqSum", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "HSub.hSub", + "instHSub", + "Rat.instSub", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "Finset.card", + "Rat.instMul", + "instSubNat", + "Rat.instAdd", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The decision depends only on the stated finite query list. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 86, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)\n (f g : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H K : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n (∀ p ∈ PCP.Algebraic.EncodedLineLowDegreeTest.queries hr ρ nodes ζ s,\n PCP.Algebraic.EncodedLineLowDegreeTest.read f H p = PCP.Algebraic.EncodedLineLowDegreeTest.read g K p) →\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ f H s =\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ g K s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Membership.mem", + "List", + "List.instMembership", + "PCP.Algebraic.EncodedLineLowDegreeTest.queries", + "Eq", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Every basis image is homogeneous of degree `c`, including the image of `1`. ", + "end_line": 138, + "is_class": false, + "kind": "theorem", + "line": 132, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitMonomial_isHomogeneous", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c k : ℕ),\n (PCP.Algebraic.SetMultilinear.digitMonomial m c k).IsHomogeneous c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "MvPolynomial.IsHomogeneous", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitMonomial" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)) (x : Fin (n + n) → F),\n (PCP.Algebraic.HadamardDerivedOracle.weightedCubic (PCP.Algebraic.ThreeColorVerifier.edgeValue H G x)).natDegree ≤ 3", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "constructor", + "line": 135, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Primary Hadamard rejection is a marginal of the actual conjunction tester. ", + "end_line": 111, + "is_class": false, + "kind": "theorem", + "line": 80, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.primary_rejection_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F)\n (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n PCP.Algebraic.Hadamard.averageRejectionRate hr f ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat", + "Rat.instLE", + "PCP.Algebraic.Hadamard.averageRejectionRate", + "Pi.instFintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "A physical query is answered by precisely its tagged received table. ", + "end_line": 147, + "is_class": false, + "kind": "definition", + "line": 138, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → PCP.Algebraic.ThreeColorVerifier.Query F n m c t → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Query", + "ZMod", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.read.match_1", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A closed, non-strict rejection threshold convenient for downstream decoding. ", + "end_line": 40, + "is_class": false, + "kind": "definition", + "line": 39, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.smallError", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℚ", + "type_dependencies": [ + "Nat", + "Rat" + ], + "value_dependencies": [ + "Nat", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "OfNat.ofNat", + "Rat.instOfNat", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Rat.monoid", + "HAdd.hAdd", + "instHAdd", + "Rat.instAdd", + "Nat.cast", + "Rat.instNatCast", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 74, + "is_class": false, + "kind": "theorem", + "line": 67, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.eval_edgeExtension", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [inst_3 : DecidableEq F]\n (H : Finset F) (G : SimpleGraph (σ → ↥H)) (a b : σ → ↥H),\n (MvPolynomial.eval (Sum.elim (fun i => ↑(a i)) fun i => ↑(b i))) (PCP.Algebraic.ThreeColorGrid.edgeExtension H G) =\n if G.Adj a b then 1 else 0", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Sum.elim", + "Subtype.val", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "ite", + "SimpleGraph.Adj", + "Classical.propDecidable", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : ℕ) (accept : Bool), (PCP.QueryTree.leaf accept).addresses = ∅", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "Finset", + "PCP.QueryTree.addresses", + "PCP.QueryTree.leaf", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) →\n ((color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t) →\n (validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t) →\n (properLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t) →\n motive\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines }) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "An unused uniform scalar preserves the fixed-width seed encoding without changing rejection. ", + "end_line": 309, + "is_class": false, + "kind": "definition", + "line": 306, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [Field F] →\n {c : ℕ} → [Fintype F] → [DecidableEq F] → [Fintype σ] → [DecidableEq σ] → (Fin (c + 1) → F) → ((σ → F) → F) → ℚ", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Rat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.FixedLagrangeConstraint.check", + "Prod.fst", + "Prod.snd", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (b b_1 : Bool), (PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1) = (b = b_1)", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "The proof oracle determined by a finite witness: address `j` holds `w[j]`, and `false` at every\naddress beyond `w`. Padding with `false` is harmless exactly because a verifier satisfying\n`Verifier.ReadsBelow x N` never looks past address `N`. ", + "end_line": 201, + "is_class": false, + "kind": "definition", + "line": 198, + "module": "PCP.Verifier.Definition", + "name": "PCP.oracleOfWitness", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool → PCP.ProofOracle", + "type_dependencies": [ + "List", + "Bool", + "PCP.ProofOracle" + ], + "value_dependencies": [ + "List", + "Bool", + "Nat", + "List.getD", + "Bool.false" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The precise block condition in Definition 3.1, stronger than a total-degree bound. ", + "end_line": 190, + "is_class": false, + "kind": "theorem", + "line": 184, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_isSetMultilinear", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n PCP.Algebraic.SetMultilinear.IsSetMultilinear m c ((PCP.Algebraic.SetMultilinear.encode m c) P)", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.SetMultilinear.IsSetMultilinear", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval_congr.match_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀\n (motive :\n (x : ℕ) → (x_1 : PCP.QueryTree x) → (x_2 x_3 : PCP.ProofOracle) → (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → Prop)\n (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 x_3 : PCP.ProofOracle) (x_4 : ∀ a ∈ x_1.addresses, x_2 a = x_3 a),\n (∀ (x : ℕ) (accept : Bool) (x_5 x_6 : PCP.ProofOracle)\n (x_7 : ∀ a ∈ (PCP.QueryTree.leaf accept).addresses, x_5 a = x_6 a),\n motive x (PCP.QueryTree.leaf accept) x_5 x_6 x_7) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d) (π π' : PCP.ProofOracle)\n (h : ∀ a_1 ∈ (PCP.QueryTree.query a f t).addresses, π a_1 = π' a_1),\n motive (d + 1) (PCP.QueryTree.query a f t) π π' h) →\n motive x x_1 x_2 x_3 x_4", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.ProofOracle", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "Eq", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.casesOn", + "HEq", + "Eq.ndrec", + "Eq.symm", + "eq_of_heq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "One direct bit and two independently seeded optional bits, with a shared label. ", + "end_line": 95, + "is_class": false, + "kind": "definition", + "line": 92, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.twoCallCheck", + "provenance": "lean", + "structural_dependencies": [], + "type": "{X : Type u_1} →\n {W : Type u_2} →\n {S : Type u_3} →\n (X → W → ZMod 2) →\n (X → W → S → Option (ZMod 2)) → (X → W → S → Option (ZMod 2)) → X × W × S × S → Option (ZMod 2 × ZMod 2)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Prod" + ], + "value_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option", + "Prod", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "Prod.fst", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.weights", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → (c : ℕ) → F → Fin (c + 1) → F", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.LagrangeConstraint.weight", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Packaging the coefficient polynomials preserves the original degree bound. ", + "end_line": 115, + "is_class": false, + "kind": "theorem", + "line": 98, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.totalDegree_certificate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] [IsDomain R] (H : Finset R),\n H.Nonempty →\n ∀ (Q : σ → MvPolynomial σ R) (d : ℕ),\n (∀ (i : σ), Q i ≠ 0 → (Q i).totalDegree + H.card ≤ d) →\n (PCP.Algebraic.GridVanishing.certificate Q).totalDegree ≤ d", + "type_dependencies": [ + "CommRing", + "Fintype", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Nat", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "MvPolynomial.totalDegree", + "Finset.card", + "Sum", + "PCP.Algebraic.GridVanishing.certificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 125, + "is_class": false, + "kind": "definition", + "line": 125, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {P : Sort u} →\n {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n {a' : PCP.Algebraic.ThreeColorVerifier.Vertex F n} →\n {a'_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3} →\n PCP.Algebraic.ThreeColorVerifier.Query.color a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.color a' a'_1 →\n (a ≍ a' → a_1 ≍ a'_1 → P) → P", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "HEq" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "HEq", + "id", + "PCP.Algebraic.ThreeColorVerifier.Query.noConfusion", + "Eq.refl", + "heq_of_eq" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 1", + "type_dependencies": [ + "LE.le", + "Nat", + "Preorder.toLE", + "Nat.instPreorder", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d),\n f.addresses.card < 2 ^ d →\n t.addresses.card < 2 ^ d →\n (insert a (f.addresses ∪ t.addresses)).card ≤ 1 + (f.addresses.card + t.addresses.card) →\n ¬(insert a (f.addresses ∪ t.addresses)).card < 2 ^ (d + 1) → False", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "LT.lt", + "instLTNat", + "Finset.card", + "PCP.QueryTree.addresses", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "Insert.insert", + "Finset", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] (a : Fin (c + 1) → F) (f : (σ → F) → F),\n PCP.Algebraic.FixedLagrangeConstraint.rejectionRate a f =\n PCP.Algebraic.relativeDistance (fun s => PCP.Algebraic.FixedLagrangeConstraint.check a f s.1.1 s.1.2) fun x => 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.FixedLagrangeConstraint.check", + "Prod.fst", + "Prod.snd", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The relation defines `L`. ", + "end_line": 38, + "is_class": false, + "kind": "theorem", + "line": 38, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L) (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length self.witnessBound ∧ self.check x w = true", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Iff", + "Exists", + "And", + "LE.le", + "Nat", + "instLENat", + "List.length", + "Polynomial.eval", + "Nat.instSemiring", + "PCP.NPCertificate.witnessBound", + "Eq", + "PCP.NPCertificate.check", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.eval_zero_eq_sum._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} (P : Polynomial F), P.natDegree ≤ c → ¬P.natDegree < c + 1 → False", + "type_dependencies": [ + "Field", + "Nat", + "Polynomial", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "Not", + "LT.lt", + "instLTNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Substitute polynomials for the second block, keeping the first block formal. ", + "end_line": 31, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n {σ : Type u_2} → [inst : CommRing R] → (σ → MvPolynomial σ R) → MvPolynomial (σ ⊕ σ) R →+* MvPolynomial σ R", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid" + ], + "value_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "MvPolynomial.eval₂Hom", + "Sum", + "AddMonoidAlgebra.commSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "MvPolynomial.C", + "Sum.elim", + "MvPolynomial.X" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The actual formal line table extracted from decoded inner polynomials. ", + "end_line": 241, + "is_class": false, + "kind": "definition", + "line": 236, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.decodedTable", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n {m c : ℕ} →\n [NeZero m] →\n (Q :\n PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ →\n MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F) →\n (∀ (uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F σ), (Q uv).totalDegree ≤ c) →\n PCP.Algebraic.PointLineTest.LineTable F σ (c * m ^ c)", + "type_dependencies": [ + "Field", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.PointLineTest.LineTable", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid" + ], + "value_dependencies": [ + "Field", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Prod", + "Subtype.mk", + "Polynomial", + "CommSemiring.toSemiring", + "Polynomial.natDegree", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "PCP.Algebraic.EncodedLineLowDegreeTest.decodedTable._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Branch order: color, valid certificate, difference, proper certificate,\nvalid grid, proper grid, difference consistency. ", + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 82, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.BranchSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → [Monoid F] → ℕ → ℕ → ℕ → ℕ → Fin 7 → Type u_2", + "type_dependencies": [ + "Monoid", + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Monoid", + "Nat", + "Matrix.vecCons", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "ZMod", + "Matrix.vecEmpty" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The field construction is available at the chosen exponent for every graph size. ", + "end_line": 94, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.choice_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N ∧\n N ≤\n (PCP.Algebraic.ThreeColorParameters.grid (PCP.Algebraic.ThreeColorParameterChoice.exponent N)).card ^\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent N) ∧\n PCP.Algebraic.ThreeColorParameterChoice.volume N ≤ 4 * max 8 (Nat.clog 2 N)", + "type_dependencies": [ + "Nat", + "And", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Finset.card", + "PCP.Algebraic.ThreeColorParameters.Field", + "PCP.Algebraic.ThreeColorParameters.grid", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.volume", + "HMul.hMul", + "instHMul", + "instMulNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le._proof_1_4", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n 2 ≤ PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n ¬PCP.Algebraic.ThreeColorParameterChoice.exponent N = PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1 + 1 →\n False", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "Not", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The coloring membership cubic can be substituted without making a fixed random oracle. ", + "end_line": 212, + "is_class": false, + "kind": "theorem", + "line": 200, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.cubic_rejection_transfer", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) (f : (Fin n → F) → F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ (f x ^ 3 - 1)))) M A ≤\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ (fun x => PCP.Algebraic.HadamardDerivedOracle.cubic) ⋯ nodes ζ H p M\n A +\n 2 * PCP.Algebraic.HadamardDerivedOracle.fullDistance ρ p f", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "One.toOfNat1", + "AddMonoidWithOne.toOne", + "AddGroupWithOne.toAddMonoidWithOne", + "Rat.instAdd", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_cubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "HMul.hMul", + "instHMul", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.HadamardDerivedOracle.fullDistance", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ], + "value_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk", + "PCP.CostModel.rec" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n ⊕ Fin n) m c t 3) →\n ((x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((uv : PCP.Algebraic.EncodedLineLowDegreeTest.Lines F (Fin n ⊕ Fin n)) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (uv, x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Sum", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{a : ℕ} → PCP.QueryTree a → ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.casesOn", + "Bool" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → PCP.Verifier → PCP.Verifier → Sort u", + "type_dependencies": [ + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.Verifier", + "PCP.Verifier.casesOn", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "SizeOf PCP.CostModel", + "type_dependencies": [ + "SizeOf", + "PCP.CostModel" + ], + "value_dependencies": [ + "SizeOf.mk", + "PCP.CostModel", + "PCP.CostModel._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t)\n (s : PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t) (b : ZMod 2),\n PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit ρ nodes ζ H M A s b =\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck (some b)\n (PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M (A (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1))\n (PCP.Algebraic.BinaryZeroOnGrid.zeroPoint s.1) s.2.1 s.2.2.1)\n (PCP.Algebraic.BinaryZeroOnGridCorrection.call ρ nodes ζ M\n (A (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)) (PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint H s.1)\n s.2.1 s.2.2.2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "Sum", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "Prod.fst", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} [inst_2 : Fintype F]\n {inst_3 : DecidableEq F} [inst_4 : DecidableEq F] (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (Q Q_1 : (Fin n → F) → Polynomial F) (e_Q : Q = Q_1) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r)\n (nodes nodes_1 : Fin (c + 1) → F),\n nodes = nodes_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (H H_1 : Finset F),\n H = H_1 →\n ∀ (p p_1 : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n p = p_1 →\n ∀\n (M M_1 :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n M = M_1 →\n ∀ (A A_1 : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t),\n A = A_1 →\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ Q hQ nodes ζ H p M A =\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ_1 Q_1 ⋯ nodes_1 ζ_1 H_1 p_1 M_1 A_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "Rat", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "Eq.ndrec" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (1 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 207, + "is_class": false, + "kind": "definition", + "line": 206, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeSampleSumFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [Fintype F] →\n [DecidableEq F] → {n m c t : ℕ} → Fintype (PCP.Algebraic.BinaryLocalCorrection.Sample F (Fin n ⊕ Fin n) m c t)", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Sum", + "Fin", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instDecidableEqSum", + "instDecidableEqFin", + "instFintypeSum", + "Fin.fintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerPoint_1", + "ZMod.fintype", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1._proof_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.instFintypeInnerSeed_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Evaluate public adjacency at the original two vertex blocks. ", + "end_line": 60, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → {n : ℕ} → (H : Finset F) → SimpleGraph (Fin n → ↥H) → (Fin (n + n) → F) → F", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "Sum", + "Semifield.toCommSemiring", + "Field.toSemifield", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Function.comp", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "PCP.Algebraic.ThreeColorVerifier.flatten", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "`V` reads only proof addresses below `N` on input `x`, whatever the randomness and whatever\nthe oracle answers. This is how \"a proof of polynomial length\" is expressed. ", + "end_line": 119, + "is_class": false, + "kind": "definition", + "line": 116, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.ReadsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → ℕ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Nat" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "Membership.mem", + "Finset", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.QueryTree.addresses", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "LT.lt", + "instLTNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Encoding an ordinary finite graph gives the intended soundness statement. ", + "end_line": 68, + "is_class": false, + "kind": "theorem", + "line": 65, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.soundAt_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (G : SimpleGraph (Fin N)) [inst : DecidableRel G.Adj],\n ¬G.Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.SoundAt (PCP.Algebraic.ThreeColorEncoding.encode G) (1 / 2)", + "type_dependencies": [ + "Nat", + "SimpleGraph", + "Fin", + "DecidableRel", + "SimpleGraph.Adj", + "Not", + "SimpleGraph.Colorable", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.SoundAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "PCP.Algebraic.ThreeColorEncoding.encode", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The precise field cardinality, starting at sixteen. ", + "end_line": 49, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.card_fieldFamily", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) = 16 ^ (k + 1)", + "type_dependencies": [ + "Nat", + "Eq", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.bit.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {b b_1 : Bool}, PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1 → b = b_1", + "type_dependencies": [ + "Bool", + "Eq", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "recursor", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.CostModel → Sort u} →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n (t : PCP.CostModel) → motive t", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "PCP.CostModel.mk" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A finite family can be decoded simultaneously, with both normalized global\ndistances bounded by the average actual row rejection. Empty families are allowed. ", + "end_line": 176, + "is_class": false, + "kind": "theorem", + "line": 146, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.exists_polynomials_of_average_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {c t r : ℕ} {I : Type u_3} [inst_5 : Fintype I],\n 2 * c < Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (a : Fin (c + 1) → F),\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes a →\n ∀ (H : I → (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n ∃ Q,\n (∀ (i : I), (Q i).totalDegree ≤ c) ∧\n ((PCP.Algebraic.relativeDistance (fun p => H p.1 p.2.1 p.2.2) fun p =>\n (PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval p.2.1) (Q p.1)))) p.2.2) ≤\n PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c *\n Finset.univ.expect fun i => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a (H i)) ∧\n (PCP.Algebraic.relativeDistance\n (fun p => H p.1 p.2.1 ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2.2)) fun p =>\n (PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval p.2.1) (Q p.1))))\n ((PCP.Algebraic.Hadamard.homogeneousIndex hr) p.2.2)) ≤\n PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant c *\n Finset.univ.expect fun i => PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a (H i)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant", + "Finset.expect", + "Rat.addCommMonoid", + "NNRat", + "instCommSemiringNNRat", + "Rat.semiring", + "DivisionSemiring.toNNRatAlgebra", + "Semifield.toDivisionSemiring", + "Rat.instField", + "Rat.instCharZero", + "Finset.univ", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.Hadamard.homogeneousIndex" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 41, + "is_class": false, + "kind": "theorem", + "line": 40, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), NeZero (4 * (k + 1))", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 125, + "is_class": false, + "kind": "definition", + "line": 125, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.elim", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n t_1.ctorIdx = 0 →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.Query.ctorElim", + "Eq.symm", + "PULift.up" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 125, + "is_class": false, + "kind": "constructor", + "line": 125, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldCode._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "RingHomInvPair (RingHom.id (ZMod 2)) (RingHom.id (ZMod 2))", + "type_dependencies": [ + "RingHomInvPair", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPTableauGraphLang.program.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) {inst : DecidableEq h.tm.Λ}\n [inst_1 : DecidableEq h.tm.Λ] {inst_2 : DecidableEq h.tm.σ} [inst_3 : DecidableEq h.tm.σ]\n {inst_4 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)}\n [inst_5 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK eK_1 : h.tm.K ≃ Fin k),\n eK = eK_1 →\n ∀ (eA eA_1 : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n eA = eA_1 →\n PCP.Reduction.NPTableauGraphLang.program h hs eK eA = PCP.Reduction.NPTableauGraphLang.program h hs eK_1 eA_1", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Nat", + "Equiv", + "Fin", + "Eq", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Lang.Prog", + "PCP.Reduction.NPTableauGraphLang.program" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 97, + "is_class": false, + "kind": "theorem", + "line": 91, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.vanishesOn_of_eq_sum", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (H : Finset R) (p : MvPolynomial σ R)\n (Q : σ → MvPolynomial σ R),\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i → PCP.Algebraic.GridVanishing.VanishesOn H p", + "type_dependencies": [ + "CommRing", + "Fintype", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate", + "PCP.Algebraic.GridVanishing.VanishesOn" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The complete verifier is determined by its stated physical oracle reads. ", + "end_line": 309, + "is_class": false, + "kind": "theorem", + "line": 300, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.test_congr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (π π' : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) (s : PCP.Algebraic.ThreeColorVerifier.Sample F n m c t),\n (∀ q ∈ PCP.Algebraic.ThreeColorVerifier.queries ρ nodes ζ H G s,\n PCP.Algebraic.ThreeColorVerifier.read π q = PCP.Algebraic.ThreeColorVerifier.read π' q) →\n PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π s = PCP.Algebraic.ThreeColorVerifier.test ρ nodes ζ H G π' s", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Sample", + "Semiring.toMonoid", + "PCP.Algebraic.ThreeColorVerifier.Query", + "List", + "List.instMembership", + "PCP.Algebraic.ThreeColorVerifier.queries", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.read", + "Bool", + "PCP.Algebraic.ThreeColorVerifier.test" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "provenance": "lean", + "structural_dependencies": [], + "type": "(F : Type u_2) → (n m c t : ℕ) → [SizeOf F] → SizeOf (PCP.Algebraic.ThreeColorVerifier.Query F n m c t)", + "type_dependencies": [ + "Nat", + "SizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "SizeOf", + "SizeOf.mk", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), Function.Injective ⇑(PCP.Algebraic.BinaryMaterializedField.coefficientEquiv (4 * (k + 1))).symm", + "type_dependencies": [ + "Nat", + "Function.Injective", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "ZMod", + "PCP.Algebraic.BinaryMaterializedField.Element", + "DFunLike.coe", + "Equiv", + "EquivLike.toFunLike", + "Equiv.instEquivLike", + "Equiv.symm", + "PCP.Algebraic.BinaryMaterializedField.coefficientEquiv" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 29, + "is_class": false, + "kind": "definition", + "line": 29, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_3 → Type u_4 → Type (max u_3 u_4)", + "type_dependencies": [], + "value_dependencies": [ + "Prod" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Standard constant soundness for every proof oracle. ", + "end_line": 58, + "is_class": false, + "kind": "theorem", + "line": 53, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.soundAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n ¬(PCP.Algebraic.ThreeColorEncoding.graph x).Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.SoundAt x (1 / 2)", + "type_dependencies": [ + "List", + "Bool", + "Not", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "PCP.Verifier.SoundAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "HDiv.hDiv", + "Rat", + "instHDiv", + "Rat.instDiv", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((val : ℕ) → motive (Sum.inr val)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Nat", + "Sum.inl", + "Sum.inr", + "Sum.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Two reads replace exactly one primary read, with no changes to the certificate calls. ", + "end_line": 93, + "is_class": false, + "kind": "theorem", + "line": 85, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.queries_length_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n (PCP.Algebraic.DerivedZeroOnGrid.queries ρ Q hQ nodes ζ H s).length =\n (PCP.Algebraic.BinaryZeroOnGridCorrection.queries ρ nodes ζ H (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)).length +\n 1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Eq", + "List.length", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "PCP.Algebraic.DerivedZeroOnGrid.queries", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Query", + "PCP.Algebraic.BinaryZeroOnGridCorrection.queries", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 146, + "is_class": false, + "kind": "theorem", + "line": 140, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode_isHomogeneous", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n ((PCP.Algebraic.SetMultilinear.encode m c) P).IsHomogeneous c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "MvPolynomial.IsHomogeneous", + "PCP.Algebraic.SetMultilinear.Variables", + "DFunLike.coe", + "LinearMap", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "MvPolynomial", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The verifier's binary linear coordinates read the stored array coefficients. ", + "end_line": 60, + "is_class": false, + "kind": "definition", + "line": 57, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.coordinates", + "provenance": "lean", + "structural_dependencies": [], + "type": "(k : ℕ) → PCP.Algebraic.ThreeColorFields.FieldFamily k ≃ₗ[ZMod 2] Fin (4 * (k + 1)) → ZMod 2", + "type_dependencies": [ + "Nat", + "LinearEquiv", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "Fin", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Semiring.toAddCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instField", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "Pi.addCommMonoid", + "PCP.Algebraic.BinaryMaterializedField.instModuleZModOfNatNatElement", + "Pi.Function.module", + "Semiring.toModule" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryMaterializedField.coordinates", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 172, + "is_class": false, + "kind": "definition", + "line": 172, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Pi.instFintype", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Fin", + "instDecidableEqFin", + "instFintypeProd", + "Fin.fintype" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instFintypeSym.match_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "(motive : Bool ⊕ Unit → Sort u_1) →\n (x : Bool ⊕ Unit) → ((a : Bool) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x", + "type_dependencies": [ + "Sum", + "Bool", + "Unit", + "Sum.inl", + "Sum.inr", + "PUnit.unit" + ], + "value_dependencies": [ + "Sum", + "Bool", + "Unit", + "Sum.inl", + "Sum.inr", + "PUnit.unit", + "Sum.casesOn", + "PUnit.casesOn", + "Unit.unit" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} → {n m c t : ℕ} → PCP.Algebraic.ThreeColorVerifier.Query F n m c t → ℕ", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The local corrector uses the same valid-certificate line table as its outer test. ", + "end_line": 75, + "is_class": false, + "kind": "definition", + "line": 73, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.validAuxiliary", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "Prod.mk", + "Sum", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (p_2 m₀_2 mZ_2 : ZMod 2),\n PCP.Algebraic.BinaryZeroOnGrid.optionCheck (some p_2) (some m₀_2) (some mZ_2) =\n some (PCP.Algebraic.BinaryZeroOnGrid.checkBits p_2 m₀_2 mZ_2)", + "type_dependencies": [ + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "PCP.Algebraic.BinaryZeroOnGrid.checkBits" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A degree-sensitive form of Lemma 2.9, retaining the bound before subtraction. ", + "end_line": 131, + "is_class": false, + "kind": "theorem", + "line": 99, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.exists_decomposition", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] [inst_3 : Fintype σ] (H : Finset R)\n (p : MvPolynomial σ R),\n PCP.Algebraic.GridVanishing.VanishesOn H p →\n ∃ Q,\n (∀ (i : σ), Q i ≠ 0 → (Q i).totalDegree + H.card ≤ p.totalDegree) ∧\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Fintype", + "Finset", + "MvPolynomial", + "PCP.Algebraic.GridVanishing.VanishesOn", + "Exists", + "And", + "Ne", + "OfNat.ofNat", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp", + "Nat", + "Nat.instMulZeroClass", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "MvPolynomial.totalDegree", + "Finset.card", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "PCP.Algebraic.GridVanishing.coordinate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Acceptance probability is exactly `1` precisely when *every* random string accepts. This is\nthe bridge between the probabilistic statement of perfect completeness and the finite, decidable\ncondition used by the NP witness checker below. ", + "end_line": 188, + "is_class": false, + "kind": "theorem", + "line": 169, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_eq_one_iff", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = 1 ↔ ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval π = true", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "Iff", + "Eq", + "Rat", + "PCP.Verifier.accProb", + "OfNat.ofNat", + "Rat.instOfNat", + "Fin", + "HPow.hPow", + "Nat", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "instOfNatNat", + "PCP.Verifier.randomness", + "List.length", + "PCP.QueryTree.eval", + "PCP.Verifier.queries", + "PCP.Verifier.run", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The vertex constraint applied to the coloring polynomial. ", + "end_line": 29, + "is_class": false, + "kind": "definition", + "line": 28, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.validPolynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {σ : Type u_2} → [inst : Field F] → MvPolynomial σ F → MvPolynomial σ F", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "AddMonoidAlgebra.semiring", + "CommSemiring.toSemiring", + "OfNat.ofNat", + "instOfNatNat", + "One.toOfNat1", + "AddMonoidAlgebra.zero", + "Finsupp.instZero" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 91, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {t t' : PCP.Verifier} → t = t' → PCP.Verifier.noConfusionType P t t'", + "type_dependencies": [ + "PCP.Verifier", + "Eq", + "PCP.Verifier.noConfusionType" + ], + "value_dependencies": [ + "PCP.Verifier", + "Eq", + "Eq.ndrec", + "PCP.Verifier.noConfusionType", + "PCP.Verifier.casesOn", + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "HEq", + "Eq.refl", + "HEq.refl" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The same canonical verifier repeated a fixed number of times on the same proof. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier", + "type_dependencies": [ + "PCP.Verifier" + ], + "value_dependencies": [ + "PCP.Verifier.repeat", + "PCP.Algebraic.ThreeColorCanonicalVerifier.verifier", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (m : ℕ) [inst : NeZero m] (c k k_1 : ℕ),\n k = k_1 → PCP.Algebraic.SetMultilinear.digitExponents m c k = PCP.Algebraic.SetMultilinear.digitExponents m c k_1", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.SetMultilinear.digitExponents" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} (accept accept_1 : Bool), (PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1) = (accept = accept_1)", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "PCP.QueryTree", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (H : Finset R) (i : σ),\n PCP.Algebraic.GridVanishing.coordinate H i = ∏ a ∈ H, (MvPolynomial.X i - MvPolynomial.C a)", + "type_dependencies": [ + "CommRing", + "Finset", + "Eq", + "MvPolynomial", + "CommRing.toCommSemiring", + "PCP.Algebraic.GridVanishing.coordinate", + "Finset.prod", + "CommRing.toCommMonoid", + "AddMonoidAlgebra.commRing", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "AddGroupWithOne.toAddGroup", + "Ring.toAddGroupWithOne", + "AddMonoidAlgebra.ring", + "CommRing.toRing", + "Finsupp.instAddMonoid", + "Nat.instAddMonoid", + "MvPolynomial.X", + "DFunLike.coe", + "RingHom", + "Semiring.toNonAssocSemiring", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "RingHom.instFunLike", + "MvPolynomial.C" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instNonemptyTestRandomness", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {t r : ℕ}, Nonempty (PCP.Algebraic.Hadamard.TestRandomness t r)", + "type_dependencies": [ + "Nat", + "Nonempty", + "PCP.Algebraic.Hadamard.TestRandomness" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 48, + "is_class": false, + "kind": "theorem", + "line": 46, + "module": "PCP.Algebraic.ThreeColorGrid", + "name": "PCP.Algebraic.ThreeColorGrid.totalDegree_properPolynomial_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] (E Q : MvPolynomial σ F),\n (PCP.Algebraic.ThreeColorGrid.properPolynomial E Q).totalDegree ≤ E.totalDegree + 3 * Q.totalDegree", + "type_dependencies": [ + "Field", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 83, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_zero_certificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (Q : σ → MvPolynomial σ R),\n (PCP.Algebraic.GridVanishing.substitute fun x => 0) (PCP.Algebraic.GridVanishing.certificate Q) = 0", + "type_dependencies": [ + "CommRing", + "Fintype", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "PCP.Algebraic.GridVanishing.certificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_6", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} (x : Fin n → F), PCP.Algebraic.HadamardDerivedOracle.cubic.natDegree ≤ 3", + "type_dependencies": [ + "Field", + "Nat", + "Fin", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (p : (Fin n → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t)\n (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H p M A s =\n PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit ρ nodes ζ H M A (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)\n (PCP.Algebraic.HadamardDerivedOracle.answer ρ (Q s.1) ⋯ (p s.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex PCP.Algebraic.DerivedZeroOnGrid.check._proof_2) s.2.1.1) s.2.2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "PCP.Algebraic.HadamardDerivedOracle.answer", + "Field.toCommRing", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_1", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "PCP.Algebraic.DerivedZeroOnGrid.check._proof_2", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueries._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (4 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 213, + "is_class": false, + "kind": "theorem", + "line": 210, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_colorQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.EncodedLineLowDegreeTest.Query F (Fin n) m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.colorQuery q) =\n PCP.Algebraic.EncodedLineLowDegreeTest.read π.color π.colorLines q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.colorQuery", + "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.colorLines" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.QueryTree.ofStep._unsafe_rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", + "type_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat", + "PCP.QueryTree.ofStep.match_3", + "PCP.QueryTree", + "PCP.QueryTree.ofStep.match_1", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.leaf", + "Bool.false", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.QueryTree.query", + "PCP.QueryTree.ofStep._unsafe_rec", + "HAppend.hAppend", + "instHAppendOfAppend", + "List.instAppend", + "List.cons", + "List.nil", + "Bool.true" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 222, + "is_class": false, + "kind": "theorem", + "line": 221, + "module": "PCP.Verifier.Definition", + "name": "PCP.length_witness_of_oracle", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (π : PCP.ProofOracle) (N : ℕ), (List.map π (List.range N)).length = N", + "type_dependencies": [ + "PCP.ProofOracle", + "Nat", + "Eq", + "List.length", + "Bool", + "List.map", + "List.range" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 108, + "is_class": false, + "kind": "definition", + "line": 68, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} → {t t' : PCP.CostModel} → t = t' → PCP.CostModel.noConfusionType P t t'", + "type_dependencies": [ + "PCP.CostModel", + "Eq", + "PCP.CostModel.noConfusionType" + ], + "value_dependencies": [ + "PCP.CostModel", + "Eq", + "Eq.ndrec", + "PCP.CostModel.noConfusionType", + "PCP.CostModel.casesOn", + "List", + "Bool", + "PCP.VerifierAlg", + "Computable₂", + "Primcodable.list", + "Primcodable.bool", + "Computable", + "Prod", + "Sum", + "Nat", + "Primcodable.prod", + "Primcodable.sum", + "Primcodable.ofDenumerable", + "Denumerable.nat", + "Prod.fst", + "Prod.snd", + "PCP.Verifier", + "Polynomial", + "Nat.instSemiring", + "PCP.Verifier.ImplementedBy", + "PCP.Verifier.CanonicalRandomness", + "PCP.Verifier.ReadsBelow", + "Polynomial.eval", + "List.length", + "PCP.finiteWitnessCheck", + "Eq.refl" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.validLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_5", + "provenance": "lean", + "structural_dependencies": [], + "type": "NeZero (2 + 1)", + "type_dependencies": [ + "NeZero", + "Nat", + "Zero.ofOfNat0", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The formerly open point-versus-line proposition, now proved in every dimension. ", + "end_line": 85, + "is_class": false, + "kind": "theorem", + "line": 79, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.pointLineSoundness_largeField", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (m c : ℕ),\n PCP.Algebraic.PointLineConstants.fieldFactor * c ^ 3 ≤ Fintype.card F →\n PCP.Algebraic.PointLineSoundness F m c PCP.Algebraic.PointLineConstants.smallError", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "LE.le", + "instLENat", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.PointLineConstants.fieldFactor", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", "PCP.Algebraic.PointLineSoundness", - "PCP.Algebraic.SetMultilinear", - "PCP.Algebraic.ThreeColorAmplifiedVerifier", - "PCP.Algebraic.ThreeColorFields", - "PCP.Algebraic.ThreeColorGrid", - "PCP.Algebraic.ThreeColorParameterChoice", - "PCP.Algebraic.ThreeColorVerifier", - "PCP.Algebraic.ThreeColorVerifierCompleteness", - "PCP.Algebraic.VanishingCertificate", - "PCP.Complexity.CostModel", - "PCP.Complexity.Machine", - "PCP.Complexity.NP", - "PCP.Complexity.ReferenceNPConverse", - "PCP.Complexity.ThreeColorRuntime", - "PCP.Reduction.NPThreeColorRuntime", - "PCP.ReverseConcrete", - "PCP.Theorem", - "PCP.Verifier.Definition" - ], - "lean_version": "4.35.0-rc2", - "provenance": { - "kind": "source-read", - "text": "The reading-guide interface retains extracted records from matching pinned source. The forward theorem retains statement compilation. Other selected declarations are source excerpts. Proof dependencies and axiom reports depend on the record's provenance." - }, - "declarations": [ - { - "axioms": [], - "doc": null, - "end_line": 33, - "is_class": false, - "kind": "theorem", - "line": 25, - "module": "PCP.Theorem", - "name": "PCP.np_subset_pcp", - "provenance": "statement-compiled", - "structural_dependencies": [], - "type": "theorem np_subset_pcp (L : Language) (hL : InNP Machine.PolyTimeRel L) :\n ∃ (V : Verifier) (alg : VerifierAlg) (a b q : ℕ) (p : Polynomial ℕ),\n Machine.PolyTimeAlg alg ∧\n V.ImplementedBy alg ∧\n V.queries = q ∧\n V.CanonicalRandomness a b ∧\n (∀ x : List Bool, V.ReadsBelow x (p.eval x.length)) ∧\n (∀ x : List Bool, L x → V.CompleteAt x) ∧\n (∀ x : List Bool, ¬ L x → V.SoundAt x (1 / 2))", - "type_dependencies": [ - "And", - "Bool", - "Eq", - "Exists", - "HDiv.hDiv", - "List", - "List.length", - "Nat", - "Nat.instSemiring", - "Not", - "OfNat.ofNat", - "PCP.InNP", - "PCP.Language", - "PCP.Machine.PolyTimeAlg", - "PCP.Machine.PolyTimeRel", - "PCP.Verifier", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.CompleteAt", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.ReadsBelow", - "PCP.Verifier.SoundAt", - "PCP.Verifier.queries", - "PCP.VerifierAlg", - "Polynomial", - "Polynomial.eval", - "Rat", - "Rat.instDiv", - "Rat.instOfNat", - "instHDiv" - ], - "value_dependencies": [] - }, - { - "name": "PCP.Algebraic.ThreeColorGrid.constraints_iff_satisfies", - "module": "PCP.Algebraic.ThreeColorGrid", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem constraints_iff_satisfies (H : Finset F)\n (G : SimpleGraph (σ → H)) (P : MvPolynomial σ F) :\n (VanishesOn H (validPolynomial P) ∧\n VanishesOn H (properPolynomial (edgeExtension H G) (differencePolynomial P))) ↔\n Satisfies G (fun a => eval (fun i => (a i : F)) P)\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F]\nvariable [Fintype σ] [DecidableEq σ] [DecidableEq F]", - "line": 91, - "end_line": 114, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.SetMultilinear.eval_encode", - "module": "PCP.Algebraic.SetMultilinear", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem eval_encode (P : Polynomial R) (hP : P.natDegree < m ^ c) (x : R) :\n MvPolynomial.eval (evaluationPoint m c x) (encode m c P) = P.eval x\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {R : Type*} [CommSemiring R]\nvariable (m : ℕ) [NeZero m] (c : ℕ)", - "line": 101, - "end_line": 107, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_close", - "module": "PCP.Algebraic.GeneratorLowDegreeTest", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_close (hq : 2 * c < Fintype.card F)\n (hζ : IsPrimitiveRoot ζ (Fintype.card F - 1)) (f : (σ → F) → F)\n {δ : ℚ} (hrej : rejectionRate c ζ f ≤ δ) (hδ : δ < 1 / (2 * (c + 2 : ℚ) ^ 2)) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ c ∧\n relativeDistance f (fun x => MvPolynomial.eval x P) ≤ 2 * δ\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] {c : ℕ}\nvariable [Fintype F] {ζ : F}\nvariable [Fintype F] {ζ : F}\nvariable [DecidableEq F] [Fintype σ] [DecidableEq σ]", - "line": 274, - "end_line": 292, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryLocalRowDecoding.exists_polynomial_distance_le", - "module": "PCP.Algebraic.BinaryLocalRowDecoding", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_polynomial_distance_le\n (hq : 2 * c < Fintype.card F)\n (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (a : Fin (c + 1) → F) (ha : GeneratorLowDegreeTest.IsGeneratorNodes a)\n (H : (σ → F) → Coefficients t r → ZMod 2) :\n ∃ Q : MvPolynomial σ F, Q.totalDegree ≤ c ∧\n relativeDistance (fun p : (σ → F) × Coefficients t r => H p.1 p.2)\n (encodeFunction r (fun x => ρ (MvPolynomial.eval x Q))) ≤\n decodingConstant c * rejectionRate hr ρ a H ∧\n BinaryLagrangeConstraint.homogeneousDistance hr H\n (fun x => encode r (ρ (MvPolynomial.eval x Q))) ≤\n decodingConstant c * rejectionRate hr ρ a H\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Algebra (ZMod 2) F]\nvariable [Fintype F] [Fintype σ] [DecidableEq σ] {c t r : ℕ}", - "line": 108, - "end_line": 144, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.EncodedLineLowDegreeTest.exists_close", - "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_close\n (hq : PointLineConstants.fieldFactor * (c * m ^ c) ^ 3 ≤ Fintype.card F)\n (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ)\n (f : (σ → F) → Coefficients t r → ZMod 2) (H : Auxiliary F σ m c t)\n (hsmall : lineErrorConstant c * rejectionRate hr ρ nodes ζ f H ≤\n PointLineConstants.smallError) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ c * m ^ c ∧\n relativeDistance (fun p : (σ → F) × Coefficients t r => f p.1 p.2)\n (encodeFunction r (fun x => ρ (MvPolynomial.eval x P))) ≤\n soundnessConstant c * rejectionRate hr ρ nodes ζ f H ∧\n BinaryLagrangeConstraint.homogeneousDistance hr f\n (fun x => encode r (ρ (MvPolynomial.eval x P))) ≤\n soundnessConstant c * rejectionRate hr ρ nodes ζ f H\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Algebra (ZMod 2) F] {m c t r : ℕ}\nvariable [Fintype F] [DecidableEq F] [Fintype σ] [DecidableEq σ]\nvariable [CharP F 2]\nvariable [NeZero m]", - "line": 325, - "end_line": 359, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le", - "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem failure_le\n (hq : 2 * c < Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ)\n {D : ℕ} (P : MvPolynomial σ F) (hP : P.totalDegree ≤ D)\n (hdecode : c * m ^ c ≤ D)\n (f : (σ → F) → Coefficients t 1 → ZMod 2)\n (H : (σ → F) → RowOracle F m c t) {δ : ℚ}\n (hnear : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) f\n (fun x => encode 1 (ρ (MvPolynomial.eval x P))) ≤ δ) (a : σ → F) :\n relativeDistance (sample ρ nodes ζ f H a)\n (fun s : Sample F σ m c t => some (linearEncode (ρ (MvPolynomial.eval a P)) s.2.2.1.2)) ≤\n soundnessConstant c * rejectionRate ρ nodes ζ f H a + δ +\n (D : ℚ) / (2 * (Fintype.card F - 1 : ℕ))\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Algebra (ZMod 2) F] {m c t : ℕ}\nvariable [Fintype F] [DecidableEq F] [Fintype σ] [DecidableEq σ]\nvariable [CharP F 2]\nvariable [NeZero m]", - "line": 222, - "end_line": 313, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_ge", - "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem rejectionRate_ge\n (hq : 2 * c < Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) (H : Finset F) (hH : H.Nonempty)\n (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F)\n (hP : P.totalDegree ≤ D) (hM : M.totalDegree ≤ D)\n (hdecode : c * m ^ c ≤ D) (hnot : ¬ GridVanishing.VanishesOn H P)\n (p' : (Fin n → F) → Coefficients t 1 → ZMod 2)\n (M' : CertificatePoint F n → Coefficients t 1 → ZMod 2)\n (A : Auxiliary F n m c t) {δP δM : ℚ}\n (hp : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) p'\n (fun x => encode 1 (ρ (eval x P))) ≤ δP)\n (hm : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) M'\n (fun x => encode 1 (ρ (eval x M))) ≤ δM) :\n ((1 - ((D * H.card : ℕ) : ℚ) / Fintype.card F) / 2 - δP - 2 * δM -\n (D : ℚ) / (Fintype.card F - 1 : ℕ)) /\n (1 + 2 * BinaryLocalCorrection.soundnessConstant c) ≤\n rejectionRate ρ nodes ζ H p' M' A\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {X W S A : Type*} [Fintype X] [Fintype W] [Fintype S] [Nonempty S]\nvariable [DecidableEq A]\nvariable {X W S : Type*} [Fintype X] [Nonempty X] [Fintype W]\nvariable [Fintype S] [Nonempty S]\nvariable {F : Type*} [Field F] [Algebra (ZMod 2) F] [Fintype F] [DecidableEq F]\nvariable [CharP F 2] {n m c t D : ℕ} [NeZero m]", - "line": 301, - "end_line": 325, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorFields.chosen_parameters", - "module": "PCP.Algebraic.ThreeColorFields", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem chosen_parameters (M : ℕ) :\n M ≤ Fintype.card (Chosen M) ∧ Fintype.card (Chosen M) ≤ 16 * max 1 M ∧\n Function.Injective (nodes (index M)) ∧\n StandardLocalCorrection.GoodNodes 4 (generator (index M)) ∧\n IsPrimitiveRoot (cubeRoot (index M)) 3\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 171, - "end_line": 177, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Reduction.NPThreeColorRuntime.of_inNP_program", - "module": "PCP.Reduction.NPThreeColorRuntime", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem of_inNP_program {L : PCP.Language} (hL : PCP.InNP PolyTimeRel L) :\n ∃ (f : List Bool → List Bool) (p : Polynomial ℕ) (P : Prog) (C d : ℕ),\n ∀ x : List Bool,\n P.run (x.map Bool.toNat) = (f x).map Bool.toNat ∧\n P.cost (x.map Bool.toNat) ≤ C * (x.length + 1) ^ d ∧\n ((Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔ L x) ∧\n (f x).length ≤ p.eval x.length\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {R : List Bool → List Bool → Bool} (h : Checker R) (q : Polynomial ℕ)\nvariable [DecidableEq h.tm.Λ] [DecidableEq h.tm.σ]\nvariable [DecidableEq h.tm.Λ] [DecidableEq h.tm.σ]", - "line": 257, - "end_line": 265, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_rejectionRate_eq_zero", - "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_proof_rejectionRate_eq_zero (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : Function.Injective nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) {ω : F} (hω : IsPrimitiveRoot ω 3)\n (H : Finset F) (hH : H.Nonempty) (G : SimpleGraph (Fin n → H)) (hG : G.Colorable 3)\n (hdegree : 5 * ((H.card - 1) * n) < m ^ c) :\n ∃ π : Proof F n m c t, rejectionRate ρ nodes ζ H G π = 0\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F : Type*} [Field F] [Algebra (ZMod 2) F] {n m c t : ℕ}\nvariable [NeZero m]\nvariable [CharP F 2]\nvariable [Fintype F]", - "line": 130, - "end_line": 141, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.verification_guarantees", - "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem verification_guarantees :\n 0 < repetitions ∧ verifier.queries = repetitions * 187 ∧\n verifier.CanonicalRandomness (repetitions * 32000000) (repetitions * 32000000) ∧\n (∀ x, verifier.ReadsBelow x (ThreeColorCanonicalVerifier.proofBound.eval x.length)) ∧\n (∀ x, (ThreeColorEncoding.graph x).Colorable 3 → verifier.CompleteAt x) ∧\n (∀ x, ¬ (ThreeColorEncoding.graph x).Colorable 3 → verifier.SoundAt x (1 / 2))\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 72, - "end_line": 78, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.pcp_subset_np_concrete", - "module": "PCP.ReverseConcrete", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem pcp_subset_np_concrete (L : Language) (V : Verifier) (alg : VerifierAlg) (a b : ℕ)\n (p : Polynomial ℕ) (halg : Machine.PolyTimeAlg alg) (himpl : V.ImplementedBy alg)\n (hrand : V.CanonicalRandomness a b)\n (hlen : ∀ x : List Bool, V.ReadsBelow x (p.eval x.length))\n (hcomplete : ∀ x : List Bool, L x → V.CompleteAt x)\n (hsound : ∀ x : List Bool, ¬ L x → V.SoundAt x (1 / 2)) :\n InNP Machine.PolyTimeRel L\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 33, - "end_line": 43, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_certificate", - "module": "PCP.Algebraic.VanishingCertificate", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem vanishesOn_iff_exists_certificate [Finite σ] (H : Finset R) (hH : H.Nonempty)\n (p : MvPolynomial σ R) :\n VanishesOn H p ↔ ∃ M : MvPolynomial (σ ⊕ σ) R,\n M.totalDegree ≤ p.totalDegree ∧ IsCertificate H p M\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {R σ : Type*} [CommRing R]\nvariable [Fintype σ]\nvariable [IsDomain R]", - "line": 119, - "end_line": 132, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.PointLineTest.exists_close_of_small_rejection", - "module": "PCP.Algebraic.PointLineSoundness", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem exists_close_of_small_rejection\n (hq : fieldFactor * d ^ 3 ≤ Fintype.card F) (f : (σ → F) → F)\n (table : LineTable F σ d) (hδ : rejectionRate f table ≤ smallError) :\n ∃ P : MvPolynomial σ F, P.totalDegree ≤ d ∧\n relativeDistance f (fun x => MvPolynomial.eval x P) ≤ 2 * rejectionRate f table\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {F σ : Type*} [Field F] [Fintype F] [DecidableEq F]\nvariable [Fintype σ] [DecidableEq σ] {d : ℕ}", - "line": 58, - "end_line": 69, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "axioms": [ - "propext" - ], - "doc": "Reading the first `N` bits of an oracle back out reproduces it below `N`. ", - "end_line": 219, - "is_class": false, - "kind": "theorem", - "line": 216, - "module": "PCP.Verifier.Definition", - "name": "PCP.oracleOfWitness_prefix", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (π : PCP.ProofOracle) (N : ℕ) {j : ℕ}, j < N → PCP.oracleOfWitness (List.map π (List.range N)) j = π j", - "type_dependencies": [ - "PCP.ProofOracle", - "Nat", - "LT.lt", - "instLTNat", - "Eq", - "Bool", - "PCP.oracleOfWitness", - "List.map", - "List.range" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk", - "PCP.Verifier.rec" - ] - }, - { - "axioms": [], - "doc": "A proof oracle is an infinite Boolean string; `π a` is the bit at address `a`. ", - "end_line": 28, - "is_class": false, - "kind": "definition", - "line": 27, - "module": "PCP.Verifier.Definition", - "name": "PCP.ProofOracle", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "Nat", - "Bool" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodePair.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (p : List Bool × List Bool),\n PCP.Machine.encodePair p = PCP.Machine.ofBits p.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits p.2", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.encodePair", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "Logarithmic randomness as an upper bound: at most `a * ⌈log₂ (n + 2)⌉ + b` fair bits on\ninputs of length `n`.\n\n**This is too weak to be an efficiency hypothesis on its own.** An upper bound does not make\n`randomness` computable, and `Verifier.randomness` is an unrestricted function `ℕ → ℕ`. Take\n`randomness n = if f n then 1 else 0` for arbitrary `f`: the\nbound `LogRandomness 0 1` holds, yet the budget smuggles in an arbitrary Boolean function of the\ninput length, which an algorithm recovers just by measuring the length of the random string it is\nhanded. Use `CanonicalRandomness` wherever efficiency is at stake. ", - "end_line": 146, - "is_class": false, - "kind": "definition", - "line": 136, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.LogRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ → ℕ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "LE.le", - "instLENat", - "PCP.Verifier.randomness", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "HMul.hMul", - "instHMul", - "instMulNat", - "Nat.clog", - "OfNat.ofNat", - "instOfNatNat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.ofBits.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : List Bool), PCP.Machine.ofBits x = List.map PCP.Machine.Sym.bit x", - "type_dependencies": [ - "List", - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.ofBits", - "List.map", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.acceptingRandomness.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.acceptingRandomness x π = {r | (V.run x r).eval π = true}", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Eq", - "Finset", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.Verifier.acceptingRandomness", - "Finset.filter", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "Bool.true", - "instDecidableEqBool", - "Finset.univ", - "Fin.fintype" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "Eq", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 79, - "is_class": false, - "kind": "constructor", - "line": 79, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk", - "provenance": "lean", - "structural_dependencies": [ - "PCP.CostModel" - ], - "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.finiteWitnessCheck.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w =\n decide (∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true)", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Eq", - "PCP.finiteWitnessCheck", - "Decidable.decide", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "PCP.oracleOfWitness", - "Bool.true", - "Nat.decidableForallFin", - "instDecidableEqBool" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b : Bool), sizeOf (PCP.Machine.Sym.bit b) = 1 + sizeOf b", - "type_dependencies": [ - "Bool", - "Eq", - "Nat", - "SizeOf.sizeOf", - "PCP.Machine.Sym", - "PCP.Machine.Sym._sizeOf_inst", - "PCP.Machine.Sym.bit", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "Bool._sizeOf_inst" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk", - "PCP.NPCertificate.rec" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A verifier algorithm is polynomial-time when some `FinTM2` machine computes its step function\nwithin a polynomial number of steps in the encoded input length. ", - "end_line": 73, - "is_class": false, - "kind": "definition", - "line": 69, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.PolyTimeAlg", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.VerifierAlg → Prop", - "type_dependencies": [ - "PCP.VerifierAlg" - ], - "value_dependencies": [ - "PCP.VerifierAlg", - "Nonempty", - "Turing.TM2ComputableInPolyTime", - "Prod", - "List", - "Bool", - "Sum", - "Nat", - "PCP.Machine.Sym", - "PCP.Machine.encodeTriple", - "PCP.Machine.encodeAnswer", - "Prod.fst", - "Prod.snd" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A uniform cost model: what \"polynomial time\" means for witness-checking relations and for\nverifier algorithms, together with the coherence and closure properties any genuine model has.\n\nThe field docstrings explain why each field is present. **The machine model is no longer a choice**:\n`PCP/Complexity/Machine.lean` fixes it as `Turing.TM2ComputableInPolyTime`. Showing those concrete\npredicates satisfy this interface was obligation NP-1, now discharged: the two coherence fields in\n`PCP/Complexity/Bridge.lean`, the closure field below in `PCP/Complexity/StandardModel.lean`.\nNote the known cost of that choice: *some* certified composition or subroutine result is needed for\nthe closure field, and mathlib's `comp` is an open `proof_wanted` at the pinned revision. That\nupstream theorem is one route; a specialised call-and-return construction for these fixed encodings\nis another, and is the one that was built. ", - "end_line": 108, - "is_class": false, - "kind": "inductive", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel", - "provenance": "lean", - "structural_dependencies": [ - "PCP.CostModel.mk", - "PCP.CostModel" - ], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] → [(a : List Bool) → SizeOf (L a)] → PCP.NPCertificate P L → ℕ", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "PCP.NPCertificate", - "Nat" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "PCP.NPCertificate", - "PCP.NPCertificate.rec", - "Nat", - "Polynomial", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "SizeOf.sizeOf", - "Polynomial._sizeOf_inst", - "instSizeOfNat" - ] - }, - { - "axioms": [], - "doc": "The depth-`d` decision tree generated by unfolding a step function, starting from the answers\n`as` received so far.\n\nIf the step function has not halted within its `d`-query budget the tree rejects: an algorithm\nclaiming a `q`-query verifier must halt within `q` queries, and `ImplementedBy` below is what\nforces that to match the verifier's actual behaviour. ", - "end_line": 47, - "is_class": false, - "kind": "definition", - "line": 35, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Nat.brecOn", - "PCP.QueryTree", - "PCP.QueryTree.ofStep._f" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "If the oracles agree on every address the tree can reach, the tree cannot tell them apart. ", - "end_line": 77, - "is_class": false, - "kind": "theorem", - "line": 67, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval_congr", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (T : PCP.QueryTree d) {π π' : PCP.ProofOracle}, (∀ a ∈ T.addresses, π a = π' a) → T.eval π = T.eval π'", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.eval" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.brecOn.go", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t ×' PCP.QueryTree.below t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PProd" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.QueryTree.rec", - "PProd", - "Bool", - "PProd.mk", - "PCP.QueryTree.leaf", - "PUnit", - "PUnit.unit", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 36, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 1 →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Polynomial bound on witness length. ", - "end_line": 32, - "is_class": false, - "kind": "definition", - "line": 32, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.witnessBound", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → Polynomial ℕ", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ] - }, - { - "axioms": [], - "doc": "A language over the binary alphabet: inputs are bit strings. ", - "end_line": 15, - "is_class": false, - "kind": "definition", - "line": 14, - "module": "PCP.Complexity.NP", - "name": "PCP.Language", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "List", - "Bool" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Every address the tree could query, along any branch. ", - "end_line": 49, - "is_class": false, - "kind": "definition", - "line": 46, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.brecOn", - "Finset", - "PCP.QueryTree.addresses._f" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (d : ℕ) (f t : PCP.QueryTree d),\n (f.addresses ∪ t.addresses).card ≤ f.addresses.card + t.addresses.card →\n ¬(f.addresses ∪ t.addresses).card + 1 ≤ 1 + (f.addresses.card + t.addresses.card) → False", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "LE.le", - "instLENat", - "Finset.card", - "Union.union", - "Finset", - "Finset.instUnion", - "instDecidableEqNat", - "PCP.QueryTree.addresses", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Not", - "Preorder.toLE", - "Nat.instPreorder", - "OfNat.ofNat", - "instOfNatNat", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (f : PCP.QueryTree.below x_1), x_1.addresses.card < 2 ^ x", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", - "Bool", - "PCP.QueryTree.leaf", - "of_eq_true", - "Preorder.toLT", - "PartialOrder.toPreorder", - "Nat.instPartialOrder", - "Zero.toOfNat0", - "MulZeroClass.toZero", - "MulZeroOneClass.toMulZeroClass", - "MonoidWithZero.toMulZeroOneClass", - "Nat.instMonoidWithZero", - "MonoidWithZero.toMonoid", - "pow_pos._simp_1", - "LinearOrderedCommMonoidWithZero.toPosMulStrictMono", - "Nat.instLinearOrderedCommMonoidWithZero", - "Nat.instZeroLEOneClass", - "SemilatticeInf.toPartialOrder", - "Lattice.toSemilatticeInf", - "DistribLattice.toLattice", - "instDistribLatticeOfLinearOrder", - "Nat.instLinearOrder", - "instOfNatAtLeastTwo", - "AddMonoidWithOne.toNatCast", - "Nat.instAddMonoidWithOne", - "Nat.instAtLeastTwoHAddOfNat", - "Nat.instNeZeroSucc", - "Eq.trans", - "LE.le", - "Preorder.toLE", - "One.toOfNat1", - "AddMonoidWithOne.toOne", - "True", - "Order.lt_two_iff._simp_1", - "Nat.instSuccAddOrder", - "Nat.instNoMaxOrder", - "zero_le._simp_1", - "LinearOrderedCommMonoidWithZero.toIsBotZeroClass", - "Nat.succ", - "PCP.QueryTree.query", - "PProd", - "instLENat", - "Insert.insert", - "Finset", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "LE.le.trans", - "Nat.instPreorder", - "Finset.card_insert_le", - "Finset.card_union_le", - "Decidable.byContradiction", - "Nat.decLe", - "Not", - "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_6", - "id", - "Eq", - "Mathlib.Tactic.Ring.of_eq", - "Distrib.toAdd", - "instDistribOfSemiring", - "CommSemiring.toSemiring", - "Nat.instCommSemiring", - "HMul.hMul", - "instHMul", - "Distrib.toMul", - "Semiring.toMonoid", - "Nat.rawCast", - "AddCommMonoidWithOne.toAddMonoidWithOne", - "NonAssocSemiring.toAddCommMonoidWithOne", - "Semiring.toNonAssocSemiring", - "instMulZeroClassOfSemiring", - "instMulNat", - "Mathlib.Tactic.Ring.Common.pow_congr", - "Mathlib.Tactic.Ring.cast_pos", - "Mathlib.Meta.NormNum.isNat_ofNat", - "Eq.refl", - "Mathlib.Tactic.Ring.Common.add_congr", - "Mathlib.Tactic.Ring.Common.atom_pf", - "rfl", - "Eq.mpr", - "congrArg", - "Eq.symm", - "Mathlib.Tactic.Ring.Common.add_pf_add_gt", - "Mathlib.Tactic.Ring.Common.add_pf_add_zero", - "Mathlib.Tactic.Ring.Common.pow_add", - "Mathlib.Tactic.Ring.Common.pow_one_cast_of_isNat", - "Mathlib.Meta.NormNum.IsNat.mk", - "Mathlib.Tactic.Ring.Common.single_pow", - "Mathlib.Tactic.Ring.Common.pow_prod_atom", - "Mathlib.Tactic.Ring.Common.pow_zero", - "Mathlib.Tactic.Ring.Common.add_mul", - "Mathlib.Tactic.Ring.Common.mul_add", - "Mathlib.Tactic.Ring.Common.mul_pf_left", - "Mathlib.Meta.NormNum.IsNat.to_raw_eq", - "Mathlib.Meta.NormNum.isNat_mul", - "Mathlib.Meta.NormNum.IsNat.of_raw", - "Mathlib.Tactic.Ring.Common.mul_zero", - "Mathlib.Tactic.Ring.Common.zero_mul", - "Mathlib.Tactic.Ring.Common.mul_pf_right", - "Mathlib.Tactic.Ring.Common.add_pf_add_overlap", - "Mathlib.Tactic.Ring.Common.add_overlap_pf", - "Mathlib.Meta.NormNum.isNat_add", - "Mathlib.Tactic.Ring.Common.add_pf_zero_add", - "Nat.decLt", - "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instReprSym.repr", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym → ℕ → Format", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "Std.Format" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "PCP.Machine.instFintypeSym.match_5", - "Std.Format", - "Bool", - "Repr.addAppParen", - "Std.Format.group", - "Std.Format.nest", - "ite", - "Int", - "GE.ge", - "instLENat", - "OfNat.ofNat", - "instOfNatNat", - "Nat.decLe", - "instOfNat", - "HAppend.hAppend", - "instHAppendOfAppend", - "Std.Format.instAppend", - "Std.Format.text", - "Std.Format.line", - "reprArg", - "instReprBool", - "Std.Format.FlattenBehavior.allOrNone", - "Unit" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : PCP.Machine.Sym → PCP.Machine.Sym → Sort u_1) →\n (x x_1 : PCP.Machine.Sym) →\n ((a b : Bool) → motive (PCP.Machine.Sym.bit a) (PCP.Machine.Sym.bit b)) →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b) PCP.Machine.Sym.sep) →\n ((b : Bool) → motive PCP.Machine.Sym.sep (PCP.Machine.Sym.bit b)) →\n (Unit → motive PCP.Machine.Sym.sep PCP.Machine.Sym.sep) → motive x x_1", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "Unit" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "Unit", - "PCP.Machine.Sym.casesOn", - "Unit.unit" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A certificate that `L` is in NP relative to a notion `P` of polynomial-time checkability: a\npolynomial witness bound and a witness-checking relation that `P` accepts.\n\n`P` is a plain parameter here, and that is safe *because nothing is proved by quantifying over it*.\n`InNP` is a definition, not a theorem. The two consumers each pin it down:\n\n* `pcp_subset_np` instantiates `P := M.PolyTimeRel` for a `CostModel` `M`, whose closure field is\n what makes the conclusion non-vacuous;\n* `np_subset_pcp` instantiates `P := PCP.Machine.PolyTimeRel`, the concrete machine definition.\n\nNeither quantifies over an arbitrary `P`. The distinction matters:\na *theorem* over an unconstrained interface is refutable by choosing a degenerate instance; a\n*definition* parameterised by one is just a definition. ", - "end_line": 39, - "is_class": false, - "kind": "inductive", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate", - "provenance": "lean", - "structural_dependencies": [ - "PCP.NPCertificate.mk", - "PCP.NPCertificate" - ], - "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Type", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → ℕ", - "type_dependencies": [ - "PCP.CostModel", - "Nat" - ], - "value_dependencies": [ - "PCP.CostModel", - "PCP.CostModel.rec", - "Nat", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "OfNat.ofNat", - "instOfNatNat" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Verifier algorithms running in polynomial time. ", - "end_line": 83, - "is_class": false, - "kind": "definition", - "line": 83, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.PolyTimeAlg", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → PCP.VerifierAlg → Prop", - "type_dependencies": [ - "PCP.CostModel", - "PCP.VerifierAlg" - ], - "value_dependencies": [ - "PCP.CostModel" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n (t : PCP.NPCertificate P L) →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n motive t", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk", - "PCP.NPCertificate.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval._sunfold", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "PCP.QueryTree.eval.match_1", - "Bool", - "ite", - "Eq", - "Bool.true", - "instDecidableEqBool", - "PCP.QueryTree.eval" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "The `k`-bit binary expansion of a random string index, least significant bit first. ", - "end_line": 28, - "is_class": false, - "kind": "definition", - "line": 26, - "module": "PCP.Complexity.CostModel", - "name": "PCP.bitsOfFin", - "provenance": "lean", - "structural_dependencies": [], - "type": "(k : ℕ) → Fin (2 ^ k) → List Bool", - "type_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List", - "Bool" - ], - "value_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.map", - "Bool", - "Nat.testBit", - "Fin.val", - "List.range" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R}\n {polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)}\n {PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop} {PolyTimeAlg_1 : PCP.VerifierAlg → Prop}\n {polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R}\n {polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2}\n {polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)},\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 } →\n PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d), (PCP.QueryTree.query a f t).addresses = insert a (f.addresses ∪ t.addresses)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "Finset", - "PCP.QueryTree.addresses", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": 56, - "is_class": false, - "kind": "theorem", - "line": 54, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodeTriple", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (t : List Bool × List Bool × List Bool),\n (PCP.Machine.encodeTriple t).length = t.1.length + t.2.1.length + t.2.2.length + 2", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "Nat", - "List.length", - "PCP.Machine.Sym", - "PCP.Machine.encodeTriple", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "(P : (List Bool → List Bool → Bool) → Prop) →\n (L : PCP.Language) →\n [(a : List Bool → List Bool → Bool) → SizeOf (P a)] →\n [(a : List Bool) → SizeOf (L a)] → SizeOf (PCP.NPCertificate P L)", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "SizeOf.mk", - "PCP.NPCertificate", - "PCP.NPCertificate._sizeOf_1" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": "A canonical budget *is* the closed-form function of the two constants.\n\nNamed for what it says. It is an equality of functions, not a proposition of type\n`Computable V.randomness`. None is needed downstream: the closed form is evidently computable, and\nthe verifier's efficiency is certified separately through `Verifier.ImplementedBy` and the machine\npredicates of `PCP/Complexity/Machine.lean`. ", - "end_line": 167, - "is_class": false, - "kind": "theorem", - "line": 160, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CanonicalRandomness.eq_closedForm", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.randomness = fun n => a * Nat.clog 2 (n + 2) + b", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "PCP.Verifier.CanonicalRandomness", - "Eq", - "PCP.Verifier.randomness", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "HMul.hMul", - "instHMul", - "instMulNat", - "Nat.clog", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Acceptance probability, as an exact rational: the fraction of the `2 ^ randomness` equally\nlikely random strings on which `V` accepts. ", - "end_line": 104, - "is_class": false, - "kind": "definition", - "line": 101, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → PCP.ProofOracle → ℚ", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Rat" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "HDiv.hDiv", - "Rat", - "instHDiv", - "Rat.instDiv", - "Nat.cast", - "Rat.instNatCast", - "Finset.card", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.Verifier.acceptingRandomness", - "Rat.instPowNat", - "Rat.instOfNat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.ctorElimType", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} → ℕ → Sort (max 1 u)", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "cond", - "Nat.ble", - "PULift", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 158, - "is_class": false, - "kind": "theorem", - "line": 157, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CanonicalRandomness.logRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) {a b : ℕ}, V.CanonicalRandomness a b → V.LogRandomness a b", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.LogRandomness" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d addr : ℕ} {onFalse onTrue : PCP.QueryTree d} {addr_1 : ℕ} {onFalse_1 onTrue_1 : PCP.QueryTree d},\n PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1 →\n addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Perfect completeness at `x`: some proof is accepted with probability 1. ", - "end_line": 131, - "is_class": false, - "kind": "definition", - "line": 130, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CompleteAt", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → Prop", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Exists", - "PCP.ProofOracle", - "Eq", - "Rat", - "PCP.Verifier.accProb", - "OfNat.ofNat", - "Rat.instOfNat" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V)),\n sizeOf\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n 1", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "SizeOf.sizeOf", - "PCP.CostModel", - "PCP.CostModel._sizeOf_inst", - "PCP.CostModel.mk", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.brecOn.eq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {motive : (a : ℕ) → PCP.QueryTree a → Sort u} {a : ℕ} (t : PCP.QueryTree a)\n (F_1 : (a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t),\n PCP.QueryTree.brecOn t F_1 = F_1 a t (PCP.QueryTree.brecOn.go t F_1).2", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "Eq", - "PCP.QueryTree.brecOn", - "PProd", - "PCP.QueryTree.brecOn.go" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "The randomness budget is **exactly** `a * ⌈log₂ (n + 2)⌉ + b`.\n\nTwo constants determine the whole budget, so it is computable by construction and carries no\ninformation of its own. This is the \"canonical computable budget\" repair: it closes the hole that\n`LogRandomness` leaves open, and it is without loss of generality because a verifier that wants\nfewer bits can ignore the surplus. ", - "end_line": 155, - "is_class": false, - "kind": "definition", - "line": 148, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.CanonicalRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ → ℕ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "Eq", - "PCP.Verifier.randomness", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "HMul.hMul", - "instHMul", - "instMulNat", - "Nat.clog", - "OfNat.ofNat", - "instOfNatNat" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {randomness : ℕ → ℕ} {queries : ℕ} {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries}\n {randomness_1 : ℕ → ℕ} {queries_1 : ℕ}\n {run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1},\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 } →\n randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "And", - "HEq" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.rec" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "The NP checking relation induced by a verifier: accept `(x, w)` when the finite witness `w`,\nread as a proof, makes `V` accept on *every* random string.\n\nThis is decidable because the random space `Fin (2 ^ randomness)` is finite, which is the whole\npoint: perfect completeness turns into a finite check. Whether it is *polynomial-time* decidable\nis a separate question, answered by `CostModel.polyTimeRel_finiteWitnessCheck`. ", - "end_line": 210, - "is_class": false, - "kind": "definition", - "line": 203, - "module": "PCP.Verifier.Definition", - "name": "PCP.finiteWitnessCheck", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → List Bool → Bool", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Decidable.decide", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Eq", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "PCP.oracleOfWitness", - "Bool.true", - "Nat.decidableForallFin", - "instDecidableEqBool" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "A binary relation on bit strings is polynomial-time when some `FinTM2` machine computes it\nwithin a polynomial number of steps in the encoded input length. ", - "end_line": 67, - "is_class": false, - "kind": "definition", - "line": 64, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.PolyTimeRel", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → List Bool → Bool) → Prop", - "type_dependencies": [ - "List", - "Bool" - ], - "value_dependencies": [ - "List", - "Bool", - "Nonempty", - "Turing.TM2ComputableInPolyTime", - "Prod", - "PCP.Machine.Sym", - "PCP.Machine.encodePair", - "PCP.Machine.encodeBool", - "Prod.fst", - "Prod.snd" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.eq_def", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 : PCP.ProofOracle),\n x_1.eval x_2 =\n match x, x_1, x_2 with\n | x, PCP.QueryTree.leaf b, x_3 => b\n | .(d + 1), PCP.QueryTree.query a f t, π => if π a = true then t.eval π else f.eval π", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Eq", - "Bool", - "PCP.QueryTree.eval", - "PCP.QueryTree.eval.match_1", - "ite", - "Bool.true", - "instDecidableEqBool" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The tree reads at most `d` bits along any branch: its address set has at most `2 ^ d - 1`\nelements, and along a single run at most `d` queries are made. ", - "end_line": 65, - "is_class": false, - "kind": "theorem", - "line": 51, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (T : PCP.QueryTree d), T.addresses.card < 2 ^ d", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeAnswer.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((a : ℕ) → motive (Sum.inr a)) → motive x", - "type_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr", - "Sum.casesOn" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language}\n [inst : (a : List Bool → List Bool → Bool) → SizeOf (P a)] [inst_1 : (a : List Bool) → SizeOf (L a)]\n (witnessBound : Polynomial ℕ) (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true),\n sizeOf { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n 1 + sizeOf witnessBound + sizeOf check_polyTime", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "SizeOf", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "SizeOf.sizeOf", - "PCP.NPCertificate", - "PCP.NPCertificate._sizeOf_inst", - "PCP.NPCertificate.mk", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "Polynomial._sizeOf_inst", - "instSizeOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": "Stop and accept (`true`) or reject (`false`). ", - "end_line": 35, - "is_class": false, - "kind": "constructor", - "line": 34, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf", - "provenance": "lean", - "structural_dependencies": [ - "PCP.QueryTree" - ], - "type": "{d : ℕ} → Bool → PCP.QueryTree d", - "type_dependencies": [ - "Nat", - "Bool", - "PCP.QueryTree" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Only the first `N` proof bits matter when `V.ReadsBelow x N`. ", - "end_line": 128, - "is_class": false, - "kind": "theorem", - "line": 121, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_congr_of_readsBelow", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) {N : ℕ},\n V.ReadsBelow x N → ∀ {π π' : PCP.ProofOracle}, (∀ a < N, π a = π' a) → V.accProb x π = V.accProb x π'", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Nat", - "PCP.Verifier.ReadsBelow", - "PCP.ProofOracle", - "LT.lt", - "instLTNat", - "Eq", - "Rat", - "PCP.Verifier.accProb" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match d + 1, PCP.QueryTree.query a f t with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_2 d a f t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.addresses.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "recursor", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → (t : PCP.Machine.Sym) → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": 52, - "is_class": false, - "kind": "theorem", - "line": 50, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodePair", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (p : List Bool × List Bool), (PCP.Machine.encodePair p).length = p.1.length + p.2.length + 1", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "Nat", - "List.length", - "PCP.Machine.Sym", - "PCP.Machine.encodePair", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 24, - "is_class": false, - "kind": "constructor", - "line": 24, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.sep", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Machine.Sym" - ], - "type": "PCP.Machine.Sym", - "type_dependencies": [ - "PCP.Machine.Sym" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u →\n {P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n PCP.NPCertificate P L →\n {P' : (List Bool → List Bool → Bool) → Prop} → {L' : PCP.Language} → PCP.NPCertificate P' L' → Sort u", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "PCP.NPCertificate.casesOn", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym → ℕ", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.Sym.casesOn", - "Nat", - "Bool" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (a b : Bool), ¬a = b → PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit b → False", - "type_dependencies": [ - "Bool", - "Not", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (a : Bool), PCP.Machine.Sym.bit a = PCP.Machine.Sym.bit a", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk._flat_ctor", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.eq_def", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x),\n x_1.addresses =\n match x, x_1 with\n | x, PCP.QueryTree.leaf accept => ∅\n | .(d + 1), PCP.QueryTree.query a f t => insert a (f.addresses ∪ t.addresses)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "Finset", - "PCP.QueryTree.addresses", - "PCP.QueryTree.addresses.match_1", - "Bool", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk._flat_ctor", - "provenance": "lean", - "structural_dependencies": [], - "type": "(PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n PCP.CostModel", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "(a : ℕ) → SizeOf (PCP.QueryTree a)", - "type_dependencies": [ - "Nat", - "SizeOf", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "SizeOf.mk", - "PCP.QueryTree", - "PCP.QueryTree._sizeOf_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.ctorElim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (ctorIdx : ℕ) → (t : PCP.Machine.Sym) → ctorIdx = t.ctorIdx → PCP.Machine.Sym.ctorElimType ctorIdx → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "Eq", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.ctorElimType" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Nat", - "Eq", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.ctorElimType", - "PCP.Machine.Sym.casesOn", - "Bool", - "PULift.down", - "PCP.Machine.Sym.bit", - "Eq.ndrec", - "PCP.Machine.Sym.sep" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The witness-checking relation. ", - "end_line": 34, - "is_class": false, - "kind": "definition", - "line": 34, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.check", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → List Bool → List Bool → Bool", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 23, - "is_class": false, - "kind": "definition", - "line": 23, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → t.ctorIdx = 0 → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "Bool", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) (x : ℕ) (accept : Bool)\n (h_1 : (x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept))\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)),\n (match x, PCP.QueryTree.leaf accept with\n | x, PCP.QueryTree.leaf accept => h_1 x accept\n | .(d + 1), PCP.QueryTree.query a f t => h_2 d a f t) =\n h_1 x accept", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.addresses.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 85, - "is_class": false, - "kind": "definition", - "line": 85, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {randomness : ℕ → ℕ} →\n {queries : ℕ} →\n {run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries} →\n {randomness' : ℕ → ℕ} →\n {queries' : ℕ} →\n {run' : (x : List Bool) → Fin (2 ^ randomness' x.length) → PCP.QueryTree queries'} →\n { randomness := randomness, queries := queries, run := run } =\n { randomness := randomness', queries := queries', run := run' } →\n (randomness = randomness' → queries = queries' → run ≍ run' → P) → P", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "HEq" - ], - "value_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "HEq", - "id", - "PCP.Verifier.noConfusion" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": "Encoding of a verifier algorithm's answer. A halt decision is one bit; a query is the\nseparator followed by the address in binary. ", - "end_line": 45, - "is_class": false, - "kind": "definition", - "line": 41, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeAnswer", - "provenance": "lean", - "structural_dependencies": [], - "type": "Bool ⊕ ℕ → List PCP.Machine.Sym", - "type_dependencies": [ - "Sum", - "Bool", - "Nat", - "List", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Nat", - "PCP.Machine.encodeAnswer.match_1", - "List", - "PCP.Machine.Sym", - "List.cons", - "PCP.Machine.Sym.bit", - "List.nil", - "PCP.Machine.Sym.sep", - "PCP.Machine.ofBits", - "Nat.bits" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instFintypeSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "Fintype PCP.Machine.Sym", - "type_dependencies": [ - "Fintype", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Fintype.ofEquiv", - "PCP.Machine.Sym", - "Sum", - "Bool", - "Unit", - "instFintypeSum", - "Bool.fintype", - "PUnit.fintype", - "PCP.Machine.Sym.proxyTypeEquiv" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 79, - "is_class": false, - "kind": "definition", - "line": 79, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {PolyTimeRel : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R} →\n {polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)} →\n {PolyTimeRel' : (List Bool → List Bool → Bool) → Prop} →\n {PolyTimeAlg' : PCP.VerifierAlg → Prop} →\n {polyTimeRel_computable' : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel' R → Computable₂ R} →\n {polyTimeAlg_computable' :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg' alg → Computable fun t => alg t.1 t.2.1 t.2.2} →\n {polyTimeRel_finiteWitnessCheck' :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg' alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel' (PCP.finiteWitnessCheck V)} →\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel', PolyTimeAlg := PolyTimeAlg',\n polyTimeRel_computable := polyTimeRel_computable',\n polyTimeAlg_computable := polyTimeAlg_computable',\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck' } →\n (PolyTimeRel = PolyTimeRel' → PolyTimeAlg = PolyTimeAlg' → P) → P", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk", - "id", - "PCP.CostModel.noConfusion" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "SizeOf PCP.Verifier", - "type_dependencies": [ - "SizeOf", - "PCP.Verifier" - ], - "value_dependencies": [ - "SizeOf.mk", - "PCP.Verifier", - "PCP.Verifier._sizeOf_1" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 107, - "is_class": false, - "kind": "theorem", - "line": 106, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_nonneg", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), 0 ≤ V.accProb x π", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "LE.le", - "Rat", - "Rat.instLE", - "OfNat.ofNat", - "Rat.instOfNat", - "PCP.Verifier.accProb" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → ℕ", - "type_dependencies": [ - "PCP.CostModel", - "Nat" - ], - "value_dependencies": [ - "PCP.CostModel" - ] - }, - { - "axioms": [], - "doc": "A bit string as tape symbols. ", - "end_line": 28, - "is_class": false, - "kind": "definition", - "line": 27, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.ofBits", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "List", - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "List", - "Bool", - "List.map", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ] - }, - { - "axioms": [], - "doc": "Run the decision tree against a proof oracle. ", - "end_line": 44, - "is_class": false, - "kind": "definition", - "line": 41, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "PCP.QueryTree.brecOn", - "Bool", - "PCP.QueryTree.eval._f" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "`V` is efficiently implementable in the model `M`. ", - "end_line": 115, - "is_class": false, - "kind": "definition", - "line": 114, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.Efficient", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → PCP.Verifier → Prop", - "type_dependencies": [ - "PCP.CostModel", - "PCP.Verifier" - ], - "value_dependencies": [ - "PCP.CostModel", - "PCP.Verifier", - "Exists", - "PCP.VerifierAlg", - "And", - "PCP.CostModel.PolyTimeAlg", - "PCP.Verifier.ImplementedBy" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "Bound on the number of proof **bits** read (bits, not larger proof symbols). ", - "end_line": 89, - "is_class": false, - "kind": "definition", - "line": 89, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.queries", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow.match_1_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → Prop) (x : ℕ) (x_1 : PCP.QueryTree x),\n (∀ (x : ℕ) (accept : Bool), motive x (PCP.QueryTree.leaf accept)) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d), motive d.succ (PCP.QueryTree.query a f t)) → motive x x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "Nat.succ", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "Nat.succ", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "Eq", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → PCP.CostModel → PCP.CostModel → Sort u", - "type_dependencies": [ - "PCP.CostModel" - ], - "value_dependencies": [ - "PCP.CostModel", - "PCP.CostModel.casesOn", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 50, - "is_class": false, - "kind": "theorem", - "line": 49, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep_zero", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (f : List Bool → Bool ⊕ ℕ) (as : List Bool),\n PCP.QueryTree.ofStep f 0 as =\n match f as with\n | Sum.inl b => PCP.QueryTree.leaf b\n | Sum.inr val => PCP.QueryTree.leaf false", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Eq", - "PCP.QueryTree", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.ofStep", - "PCP.QueryTree.ofStep.match_1", - "PCP.QueryTree.leaf", - "Bool.false" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Soundness: a polynomial-time relation is computable. ", - "end_line": 85, - "is_class": false, - "kind": "theorem", - "line": 85, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.polyTimeRel_computable", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (self : PCP.CostModel) (R : List Bool → List Bool → Bool), self.PolyTimeRel R → Computable₂ R", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.CostModel.PolyTimeRel", - "Computable₂", - "Primcodable.list", - "Primcodable.bool" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "Fair random bits used on inputs of length `n`. ", - "end_line": 87, - "is_class": false, - "kind": "definition", - "line": 87, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.randomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Closure: an efficiently implemented verifier with logarithmic randomness and a polynomial\nproof-length bound induces a polynomial-time NP checking relation.\n\nThis is the bridge between verifier efficiency and NP-checker efficiency.\nDischarging it means showing the model is closed under: enumerating `2 ^ O(log n)` random\nstrings, unfolding a constant-depth query tree, and indexing a polynomially long witness.\n\nThe budget hypothesis is `CanonicalRandomness`, **not** `LogRandomness`. With only an upper\nbound this field is not justifiable for any standard model: an arbitrary `f : ℕ → Bool` can be\nhidden in the budget (see `Verifier.LogRandomness`) and recovered by an elementary\nlength-measuring algorithm, so the field would assert that every unary language has a computable\nchecking relation. A canonical budget is determined by `a` and `b` and carries no such\ninformation. ", - "end_line": 104, - "is_class": false, - "kind": "theorem", - "line": 104, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.polyTimeRel_finiteWitnessCheck", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (self : PCP.CostModel) (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n self.PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → self.PolyTimeRel (PCP.finiteWitnessCheck V)", - "type_dependencies": [ - "PCP.CostModel", - "PCP.Verifier", - "PCP.VerifierAlg", - "Nat", - "Polynomial", - "Nat.instSemiring", - "PCP.CostModel.PolyTimeAlg", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "List", - "Bool", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.CostModel.PolyTimeRel", - "PCP.finiteWitnessCheck" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) →\n (x : ℕ) → Nat.below (motive := fun x => List Bool → PCP.QueryTree x) x → List Bool → PCP.QueryTree x", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Nat.below", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "Nat.below", - "PCP.QueryTree", - "PCP.QueryTree.ofStep.match_3", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.ofStep.match_1", - "PCP.QueryTree.leaf", - "Bool.false", - "Nat.succ", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "PCP.QueryTree.query", - "PProd", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "List.cons", - "List.nil", - "Bool.true" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Verifier → Sort u} →\n (t : PCP.Verifier) →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n motive t", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ], - "value_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk", - "PCP.Verifier.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep._sunfold", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree.ofStep.match_3", - "PCP.QueryTree", - "PCP.QueryTree.ofStep.match_1", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.leaf", - "Bool.false", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "PCP.QueryTree.query", - "PCP.QueryTree.ofStep", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "List.cons", - "List.nil", - "Bool.true" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "`L` is in NP relative to the polynomial-time-checkability notion `P`. ", - "end_line": 43, - "is_class": false, - "kind": "definition", - "line": 41, - "module": "PCP.Complexity.NP", - "name": "PCP.InNP", - "provenance": "lean", - "structural_dependencies": [], - "type": "((List Bool → List Bool → Bool) → Prop) → PCP.Language → Prop", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Nonempty", - "PCP.NPCertificate" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 30, - "is_class": false, - "kind": "constructor", - "line": 30, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk", - "provenance": "lean", - "structural_dependencies": [ - "PCP.NPCertificate" - ], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n (witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n P check →\n (∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n PCP.NPCertificate P L", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True", - "type_dependencies": [ - "Fintype", - "Eq", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "Finset.univ", - "True" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "SizeOf PCP.Machine.Sym", - "type_dependencies": [ - "SizeOf", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "SizeOf.mk", - "PCP.Machine.Sym", - "PCP.Machine.Sym._sizeOf_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 24, - "is_class": false, - "kind": "definition", - "line": 24, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.sep.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} → (t : PCP.Machine.Sym) → t.ctorIdx = 1 → motive PCP.Machine.Sym.sep → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Nat", - "PCP.Machine.Sym.ctorIdx", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 85, - "is_class": false, - "kind": "constructor", - "line": 85, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Verifier" - ], - "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "definition", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ], - "value_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk", - "PCP.CostModel.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.ProofOracle) (b : Bool), (PCP.QueryTree.leaf b).eval x_1 = b", - "type_dependencies": [ - "Nat", - "PCP.ProofOracle", - "Bool", - "Eq", - "PCP.QueryTree.eval", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval._unsafe_rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "PCP.QueryTree.eval.match_1", - "Bool", - "ite", - "Eq", - "Bool.true", - "instDecidableEqBool", - "PCP.QueryTree.eval._unsafe_rec" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (accept : Bool), (PCP.QueryTree.leaf accept).addresses = ∅", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "Finset", - "PCP.QueryTree.addresses", - "PCP.QueryTree.leaf", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (d a : ℕ) (f t : PCP.QueryTree d)\n (π : PCP.ProofOracle) (h_1 : (x : ℕ) → (b : Bool) → (x_1 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_1)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match d + 1, PCP.QueryTree.query a f t, π with\n | x, PCP.QueryTree.leaf b, x_1 => h_1 x b x_1\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_2 d a f t π", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.eval.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.eq_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : PCP.ProofOracle) (d a : ℕ) (f t : PCP.QueryTree d),\n (PCP.QueryTree.query a f t).eval x = if x a = true then t.eval x else f.eval x", - "type_dependencies": [ - "PCP.ProofOracle", - "Nat", - "PCP.QueryTree", - "Eq", - "Bool", - "PCP.QueryTree.eval", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "ite", - "Bool.true", - "instDecidableEqBool" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b b_1 : Bool), (PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1) = (b = b_1)", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "The proof oracle determined by a finite witness: address `j` holds `w[j]`, and `false` at every\naddress beyond `w`. Padding with `false` is harmless exactly because a verifier satisfying\n`Verifier.ReadsBelow x N` never looks past address `N`. ", - "end_line": 201, - "is_class": false, - "kind": "definition", - "line": 198, - "module": "PCP.Verifier.Definition", - "name": "PCP.oracleOfWitness", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool → PCP.ProofOracle", - "type_dependencies": [ - "List", - "Bool", - "PCP.ProofOracle" - ], - "value_dependencies": [ - "List", - "Bool", - "Nat", - "List.getD", - "Bool.false" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "{a : ℕ} → PCP.QueryTree a → ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.rec", - "Bool", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "SizeOf.sizeOf", - "instSizeOfNat", - "Bool._sizeOf_inst" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval_congr.match_1_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀\n (motive :\n (x : ℕ) → (x_1 : PCP.QueryTree x) → (x_2 x_3 : PCP.ProofOracle) → (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → Prop)\n (x : ℕ) (x_1 : PCP.QueryTree x) (x_2 x_3 : PCP.ProofOracle) (x_4 : ∀ a ∈ x_1.addresses, x_2 a = x_3 a),\n (∀ (x : ℕ) (accept : Bool) (x_5 x_6 : PCP.ProofOracle)\n (x_7 : ∀ a ∈ (PCP.QueryTree.leaf accept).addresses, x_5 a = x_6 a),\n motive x (PCP.QueryTree.leaf accept) x_5 x_6 x_7) →\n (∀ (d a : ℕ) (f t : PCP.QueryTree d) (π π' : PCP.ProofOracle)\n (h : ∀ a_1 ∈ (PCP.QueryTree.query a f t).addresses, π a_1 = π' a_1),\n motive (d + 1) (PCP.QueryTree.query a f t) π π' h) →\n motive x x_1 x_2 x_3 x_4", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "`alg` implements `V`: unfolding the algorithm reproduces `V`'s decision tree on every input and\nevery random string.\n\nThis ties the certificate to *this* verifier — its random-bit handling (`bitsOfFin`), its query\naddresses, and its decision rule all have to match. Proving some unrelated verifier efficient\nwould not discharge it. ", - "end_line": 64, - "is_class": false, - "kind": "definition", - "line": 56, - "module": "PCP.Complexity.CostModel", - "name": "PCP.Verifier.ImplementedBy", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → PCP.VerifierAlg → Prop", - "type_dependencies": [ - "PCP.Verifier", - "PCP.VerifierAlg" - ], - "value_dependencies": [ - "PCP.Verifier", - "PCP.VerifierAlg", - "List", - "Bool", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Eq", - "PCP.QueryTree", - "PCP.Verifier.queries", - "PCP.QueryTree.ofStep", - "PCP.bitsOfFin", - "List.nil", - "PCP.Verifier.run" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.below", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → {a : ℕ} → PCP.QueryTree a → Sort (max 1 u)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.rec", - "Bool", - "PUnit", - "PProd" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.card_addresses_lt_two_pow._proof_1_7", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (d a : ℕ) (f t : PCP.QueryTree d),\n f.addresses.card < 2 ^ d →\n t.addresses.card < 2 ^ d →\n (insert a (f.addresses ∪ t.addresses)).card ≤ 1 + (f.addresses.card + t.addresses.card) →\n ¬(insert a (f.addresses ∪ t.addresses)).card < 2 ^ (d + 1) → False", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "LT.lt", - "instLTNat", - "Finset.card", - "PCP.QueryTree.addresses", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "LE.le", - "instLENat", - "Insert.insert", - "Finset", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "Not", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses._unsafe_rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.addresses.match_1", - "Finset", - "Bool", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "PCP.QueryTree.addresses._unsafe_rec" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries),\n sizeOf { randomness := randomness, queries := queries, run := run } = 1 + sizeOf queries", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "SizeOf.sizeOf", - "PCP.Verifier", - "PCP.Verifier._sizeOf_inst", - "PCP.Verifier.mk", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "instSizeOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The relation defines `L`. ", - "end_line": 38, - "is_class": false, - "kind": "theorem", - "line": 38, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L) (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length self.witnessBound ∧ self.check x w = true", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Iff", - "Exists", - "And", - "LE.le", - "Nat", - "instLENat", - "List.length", - "Polynomial.eval", - "Nat.instSemiring", - "PCP.NPCertificate.witnessBound", - "Eq", - "PCP.NPCertificate.check", - "Bool.true" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "definition", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.CostModel → Sort u} →\n (t : PCP.CostModel) →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n motive t", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ], - "value_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk", - "PCP.CostModel.rec" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "{a : ℕ} → PCP.QueryTree a → ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.casesOn", - "Bool" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → ℕ", - "type_dependencies": [ - "PCP.Verifier", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "PCP.Verifier.rec", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "SizeOf.sizeOf", - "instSizeOfNat" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → PCP.Verifier → PCP.Verifier → Sort u", - "type_dependencies": [ - "PCP.Verifier" - ], - "value_dependencies": [ - "PCP.Verifier", - "PCP.Verifier.casesOn", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "HEq" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel._sizeOf_inst", - "provenance": "lean", - "structural_dependencies": [], - "type": "SizeOf PCP.CostModel", - "type_dependencies": [ - "SizeOf", - "PCP.CostModel" - ], - "value_dependencies": [ - "SizeOf.mk", - "PCP.CostModel", - "PCP.CostModel._sizeOf_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → PCP.Machine.Sym → PCP.Machine.Sym → Sort u", - "type_dependencies": [ - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.Sym.casesOn", - "Bool", - "Eq" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym._sizeOf_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym → ℕ", - "type_dependencies": [ - "PCP.Machine.Sym", - "Nat" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.Sym.rec", - "Nat", - "Bool", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "SizeOf.sizeOf", - "Bool._sizeOf_inst" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "`V` reads only proof addresses below `N` on input `x`, whatever the randomness and whatever\nthe oracle answers. This is how \"a proof of polynomial length\" is expressed. ", - "end_line": 119, - "is_class": false, - "kind": "definition", - "line": 116, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.ReadsBelow", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → ℕ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Nat" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "LT.lt", - "instLTNat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {b b_1 : Bool}, PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b_1 → b = b_1", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "recursor", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.CostModel → Sort u} →\n ((PolyTimeRel : (List Bool → List Bool → Bool) → Prop) →\n (PolyTimeAlg : PCP.VerifierAlg → Prop) →\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R) →\n (polyTimeAlg_computable :\n ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2) →\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel (PCP.finiteWitnessCheck V)) →\n motive\n { PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg,\n polyTimeRel_computable := polyTimeRel_computable, polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck }) →\n (t : PCP.CostModel) → motive t", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "PCP.CostModel.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (witnessBound : Polynomial ℕ)\n (check : List Bool → List Bool → Bool) (check_polyTime : P check)\n (spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true)\n (witnessBound_1 : Polynomial ℕ) (check_1 : List Bool → List Bool → Bool) (check_polyTime_1 : P check_1)\n (spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true),\n ({ witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 }) =\n (witnessBound = witnessBound_1 ∧ check = check_1)", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d) (addr_1 : ℕ) (onFalse_1 onTrue_1 : PCP.QueryTree d),\n (PCP.QueryTree.query addr onFalse onTrue = PCP.QueryTree.query addr_1 onFalse_1 onTrue_1) =\n (addr = addr_1 ∧ onFalse = onFalse_1 ∧ onTrue = onTrue_1)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses._sunfold", - "provenance": "lean", - "structural_dependencies": [], - "type": "{d : ℕ} → PCP.QueryTree d → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.addresses.match_1", - "Finset", - "Bool", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "PCP.QueryTree.addresses" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeTriple.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (t : List Bool × List Bool × List Bool),\n PCP.Machine.encodeTriple t =\n PCP.Machine.ofBits t.1 ++ PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.1 ++\n PCP.Machine.Sym.sep :: PCP.Machine.ofBits t.2.2", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.encodeTriple", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.splitter", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "PCP.QueryTree.eval.match_1" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : Bool ⊕ ℕ → Sort u_1) →\n (x : Bool ⊕ ℕ) → ((b : Bool) → motive (Sum.inl b)) → ((val : ℕ) → motive (Sum.inr val)) → motive x", - "type_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Nat", - "Sum.inl", - "Sum.inr", - "Sum.casesOn" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.eval.match_1.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) (x : ℕ) (b : Bool) (x_1 : PCP.ProofOracle)\n (h_1 : (x : ℕ) → (b : Bool) → (x_2 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_2)\n (h_2 : (d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π),\n (match x, PCP.QueryTree.leaf b, x_1 with\n | x, PCP.QueryTree.leaf b, x_2 => h_1 x b x_2\n | .(d + 1), PCP.QueryTree.query a f t, π => h_2 d a f t π) =\n h_1 x b x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Eq", - "PCP.QueryTree.eval.match_1" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instFintypeSym.match_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : Bool ⊕ Unit → Sort u_1) →\n (x : Bool ⊕ Unit) → ((a : Bool) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x", - "type_dependencies": [ - "Sum", - "Bool", - "Unit", - "Sum.inl", - "Sum.inr", - "PUnit.unit" - ], - "value_dependencies": [ - "Sum", - "Bool", - "Unit", - "Sum.inl", - "Sum.inr", - "PUnit.unit", - "Sum.casesOn", - "PUnit.casesOn", - "Unit.unit" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = ↑(V.acceptingRandomness x π).card / 2 ^ V.randomness x.length", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Eq", - "Rat", - "PCP.Verifier.accProb", - "HDiv.hDiv", - "instHDiv", - "Rat.instDiv", - "Nat.cast", - "Rat.instNatCast", - "Finset.card", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.Verifier.acceptingRandomness", - "Rat.instPowNat", - "Rat.instOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 35, - "is_class": false, - "kind": "definition", - "line": 34, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.elim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n t.ctorIdx = 0 → ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "Bool", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "Bool", - "PCP.QueryTree.leaf", - "PCP.QueryTree.ctorElim", - "Eq.symm", - "PULift.up" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} {witnessBound : Polynomial ℕ}\n {check : List Bool → List Bool → Bool} {check_polyTime : P check}\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true}\n {witnessBound_1 : Polynomial ℕ} {check_1 : List Bool → List Bool → Bool} {check_polyTime_1 : P check_1}\n {spec_1 : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound_1 ∧ check_1 x w = true},\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound_1, check := check_1, check_polyTime := check_polyTime_1, spec := spec_1 } →\n witnessBound = witnessBound_1 ∧ check = check_1", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Acceptance probability is exactly `1` precisely when *every* random string accepts. This is\nthe bridge between the probabilistic statement of perfect completeness and the finite, decidable\ncondition used by the NP witness checker below. ", - "end_line": 188, - "is_class": false, - "kind": "theorem", - "line": 169, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_eq_one_iff", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle),\n V.accProb x π = 1 ↔ ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval π = true", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Iff", - "Eq", - "Rat", - "PCP.Verifier.accProb", - "OfNat.ofNat", - "Rat.instOfNat", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "Bool.true" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 23, - "is_class": false, - "kind": "definition", - "line": 23, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {b b' : Bool} → PCP.Machine.Sym.bit b = PCP.Machine.Sym.bit b' → (b = b' → P) → P", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit" - ], - "value_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "id", - "PCP.Machine.Sym.noConfusion" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {t t' : PCP.Verifier} → t = t' → PCP.Verifier.noConfusionType P t t'", - "type_dependencies": [ - "PCP.Verifier", - "Eq", - "PCP.Verifier.noConfusionType" - ], - "value_dependencies": [ - "PCP.Verifier", - "Eq", - "Eq.ndrec", - "PCP.Verifier.noConfusionType", - "PCP.Verifier.casesOn", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "HEq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 31, - "is_class": false, - "kind": "theorem", - "line": 30, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_ofBits", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : List Bool), (PCP.Machine.ofBits x).length = x.length", - "type_dependencies": [ - "List", - "Bool", - "Eq", - "Nat", - "List.length", - "PCP.Machine.Sym", - "PCP.Machine.ofBits" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.recOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.rec" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (accept accept_1 : Bool), (PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1) = (accept = accept_1)", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "PCP.QueryTree", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": "An oracle verifier.\n\nOn an input `x` of length `n` it draws `randomness n` fair bits and then runs the decision tree\nselected by that random string, making at most `queries` *bit* queries into the proof. ", - "end_line": 91, - "is_class": false, - "kind": "inductive", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Verifier.mk", - "PCP.Verifier" - ], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instInhabitedSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "Inhabited PCP.Machine.Sym", - "type_dependencies": [ - "Inhabited", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Inhabited.mk", - "PCP.Machine.Sym", - "PCP.Machine.instInhabitedSym.default" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep._unsafe_rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "(List Bool → Bool ⊕ ℕ) → (d : ℕ) → List Bool → PCP.QueryTree d", - "type_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat", - "PCP.QueryTree.ofStep.match_3", - "PCP.QueryTree", - "PCP.QueryTree.ofStep.match_1", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.leaf", - "Bool.false", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "PCP.QueryTree.query", - "PCP.QueryTree.ofStep._unsafe_rec", - "HAppend.hAppend", - "instHAppendOfAppend", - "List.instAppend", - "List.cons", - "List.nil", - "Bool.true" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 222, - "is_class": false, - "kind": "theorem", - "line": 221, - "module": "PCP.Verifier.Definition", - "name": "PCP.length_witness_of_oracle", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (π : PCP.ProofOracle) (N : ℕ), (List.map π (List.range N)).length = N", - "type_dependencies": [ - "PCP.ProofOracle", - "Nat", - "Eq", - "List.length", - "Bool", - "List.map", - "List.range" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 91, - "is_class": false, - "kind": "recursor", - "line": 81, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Verifier → Sort u} →\n ((randomness : ℕ → ℕ) →\n (queries : ℕ) →\n (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) →\n motive { randomness := randomness, queries := queries, run := run }) →\n (t : PCP.Verifier) → motive t", - "type_dependencies": [ - "PCP.Verifier", - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 108, - "is_class": false, - "kind": "definition", - "line": 68, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {t t' : PCP.CostModel} → t = t' → PCP.CostModel.noConfusionType P t t'", - "type_dependencies": [ - "PCP.CostModel", - "Eq", - "PCP.CostModel.noConfusionType" - ], - "value_dependencies": [ - "PCP.CostModel", - "Eq", - "Eq.ndrec", - "PCP.CostModel.noConfusionType", - "PCP.CostModel.casesOn", - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq.refl" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "recursor", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {motive : PCP.NPCertificate P L → Sort u} →\n ((witnessBound : Polynomial ℕ) →\n (check : List Bool → List Bool → Bool) →\n (check_polyTime : P check) →\n (spec :\n ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true) →\n motive\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec }) →\n (t : PCP.NPCertificate P L) → motive t", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 214, - "is_class": false, - "kind": "theorem", - "line": 212, - "module": "PCP.Verifier.Definition", - "name": "PCP.finiteWitnessCheck_eq_true_iff", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x w : List Bool),\n PCP.finiteWitnessCheck V x w = true ↔\n ∀ (r : Fin (2 ^ V.randomness x.length)), (V.run x r).eval (PCP.oracleOfWitness w) = true", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Iff", - "Eq", - "PCP.finiteWitnessCheck", - "Bool.true", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "PCP.oracleOfWitness" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "DecidableEq PCP.Machine.Sym", - "type_dependencies": [ - "DecidableEq", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "PCP.Machine.instDecidableEqSym.decEq" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk._flat_ctor", - "provenance": "lean", - "structural_dependencies": [], - "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier" - ], - "value_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.mk" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Binary relations on bit strings decidable in polynomial time. ", - "end_line": 81, - "is_class": false, - "kind": "definition", - "line": 81, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.PolyTimeRel", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.CostModel → (List Bool → List Bool → Bool) → Prop", - "type_dependencies": [ - "PCP.CostModel", - "List", - "Bool" - ], - "value_dependencies": [ - "PCP.CostModel" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_congr_of_readsBelow._simp_1_2", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a)", - "type_dependencies": [ - "DecidablePred", - "Finset", - "Eq", - "Membership.mem", - "SetLike.instMembership", - "Finset.instSetLike", - "Finset.filter", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 23, - "is_class": false, - "kind": "constructor", - "line": 23, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.bit", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Machine.Sym" - ], - "type": "Bool → PCP.Machine.Sym", - "type_dependencies": [ - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.bitsOfFin.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), PCP.bitsOfFin k r = List.map (fun j => (↑r).testBit j) (List.range k)", - "type_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "Eq", - "List", - "Bool", - "PCP.bitsOfFin", - "List.map", - "Nat.testBit", - "Fin.val", - "List.range" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": "Encoding of an argument pair: `x`, separator, `w`. ", - "end_line": 35, - "is_class": false, - "kind": "definition", - "line": 33, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodePair", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool × List Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Prod", - "List", - "Bool", - "HAppend.hAppend", - "PCP.Machine.Sym", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b : Bool), PCP.Machine.Sym.bit b = PCP.Machine.Sym.sep → False", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq._proof_4", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (b : Bool), PCP.Machine.Sym.sep = PCP.Machine.Sym.bit b → False", - "type_dependencies": [ - "Bool", - "Eq", - "PCP.Machine.Sym", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.bit", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.ctorElim", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n (ctorIdx : ℕ) →\n {a : ℕ} → (t : PCP.QueryTree a) → ctorIdx = t.ctorIdx → PCP.QueryTree.ctorElimType ctorIdx → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "PCP.QueryTree.ctorElimType" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "PCP.QueryTree.ctorIdx", - "PCP.QueryTree.ctorElimType", - "PCP.QueryTree.casesOn", - "Bool", - "PULift.down", - "PCP.QueryTree.leaf", - "Eq.ndrec", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "_private.PCP.Verifier.Definition.0.PCP.QueryTree.addresses.match_1.splitter", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n ((x : ℕ) → (accept : Bool) → motive x (PCP.QueryTree.leaf accept)) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query a f t)) → motive x x_1", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "PCP.QueryTree.addresses.match_1" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The relation is polynomial-time checkable. ", - "end_line": 36, - "is_class": false, - "kind": "theorem", - "line": 36, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.check_polyTime", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L), P self.check", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "PCP.NPCertificate.check" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 35, - "is_class": false, - "kind": "definition", - "line": 34, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {d : ℕ} →\n {accept : Bool} →\n {d' : ℕ} →\n {accept' : Bool} →\n d = d' → PCP.QueryTree.leaf accept ≍ PCP.QueryTree.leaf accept' → (d = d' → accept = accept' → P) → P", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "HEq", - "PCP.QueryTree", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [ - "Nat", - "Bool", - "Eq", - "HEq", - "PCP.QueryTree", - "PCP.QueryTree.leaf", - "id", - "PCP.QueryTree.noConfusion" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 36, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {d addr : ℕ} →\n {onFalse onTrue : PCP.QueryTree d} →\n {d' addr' : ℕ} →\n {onFalse' onTrue' : PCP.QueryTree d'} →\n d + 1 = d' + 1 →\n PCP.QueryTree.query addr onFalse onTrue ≍ PCP.QueryTree.query addr' onFalse' onTrue' →\n (d = d' → addr = addr' → onFalse ≍ onFalse' → onTrue ≍ onTrue' → P) → P", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "HEq", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "HEq", - "PCP.QueryTree.query", - "id", - "PCP.QueryTree.noConfusion" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.mk.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (PolyTimeRel : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel R → Computable₂ R)\n (polyTimeAlg_computable : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) → PolyTimeRel (PCP.finiteWitnessCheck V))\n (PolyTimeRel_1 : (List Bool → List Bool → Bool) → Prop) (PolyTimeAlg_1 : PCP.VerifierAlg → Prop)\n (polyTimeRel_computable_1 : ∀ (R : List Bool → List Bool → Bool), PolyTimeRel_1 R → Computable₂ R)\n (polyTimeAlg_computable_1 : ∀ (alg : PCP.VerifierAlg), PolyTimeAlg_1 alg → Computable fun t => alg t.1 t.2.1 t.2.2)\n (polyTimeRel_finiteWitnessCheck_1 :\n ∀ (V : PCP.Verifier) (alg : PCP.VerifierAlg) (a b : ℕ) (p : Polynomial ℕ),\n PolyTimeAlg_1 alg →\n V.ImplementedBy alg →\n V.CanonicalRandomness a b →\n (∀ (x : List Bool), V.ReadsBelow x (Polynomial.eval x.length p)) →\n PolyTimeRel_1 (PCP.finiteWitnessCheck V)),\n ({ PolyTimeRel := PolyTimeRel, PolyTimeAlg := PolyTimeAlg, polyTimeRel_computable := polyTimeRel_computable,\n polyTimeAlg_computable := polyTimeAlg_computable,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck } =\n { PolyTimeRel := PolyTimeRel_1, PolyTimeAlg := PolyTimeAlg_1, polyTimeRel_computable := polyTimeRel_computable_1,\n polyTimeAlg_computable := polyTimeAlg_computable_1,\n polyTimeRel_finiteWitnessCheck := polyTimeRel_finiteWitnessCheck_1 }) =\n (PolyTimeRel = PolyTimeRel_1 ∧ PolyTimeAlg = PolyTimeAlg_1)", - "type_dependencies": [ - "List", - "Bool", - "PCP.VerifierAlg", - "Computable₂", - "Primcodable.list", - "Primcodable.bool", - "Computable", - "Prod", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd", - "PCP.Verifier", - "Polynomial", - "Nat.instSemiring", - "PCP.Verifier.ImplementedBy", - "PCP.Verifier.CanonicalRandomness", - "PCP.Verifier.ReadsBelow", - "Polynomial.eval", - "List.length", - "PCP.finiteWitnessCheck", - "Eq", - "PCP.CostModel", - "PCP.CostModel.mk", - "And" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 114, - "is_class": false, - "kind": "theorem", - "line": 109, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.accProb_le_one", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.accProb x π ≤ 1", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "LE.le", - "Rat", - "Rat.instLE", - "PCP.Verifier.accProb", - "OfNat.ofNat", - "Rat.instOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.rec" - ] - }, - { - "axioms": [], - "doc": "Encoding of an argument triple: input, random string, answers so far. ", - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 37, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeTriple", - "provenance": "lean", - "structural_dependencies": [], - "type": "List Bool × List Bool × List Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Prod", - "List", - "Bool", - "HAppend.hAppend", - "PCP.Machine.Sym", - "instHAppendOfAppend", - "List.instAppend", - "PCP.Machine.ofBits", - "Prod.fst", - "List.cons", - "PCP.Machine.Sym.sep", - "Prod.snd" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodeTriple._proof_1_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (t : List Bool × List Bool × List Bool),\n ¬t.1.length + (t.2.1.length + (t.2.2.length + 1) + 1) = t.1.length + t.2.1.length + t.2.2.length + 2 → False", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Not", - "Eq", - "Nat", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "List.length", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} → {t t' : PCP.Machine.Sym} → t = t' → PCP.Machine.Sym.noConfusionType P t t'", - "type_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "PCP.Machine.Sym.noConfusionType" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Eq", - "Eq.ndrec", - "PCP.Machine.Sym.noConfusionType", - "PCP.Machine.Sym.casesOn", - "Bool", - "Eq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.oracleOfWitness.eq_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (w : List Bool) (j : ℕ), PCP.oracleOfWitness w j = w.getD j false", - "type_dependencies": [ - "List", - "Bool", - "Nat", - "Eq", - "PCP.oracleOfWitness", - "List.getD", - "Bool.false" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instFintypeSym.match_5", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : PCP.Machine.Sym → Sort u_1) →\n (x : PCP.Machine.Sym) → ((a : Bool) → motive (PCP.Machine.Sym.bit a)) → (Unit → motive PCP.Machine.Sym.sep) → motive x", - "type_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "Unit", - "PCP.Machine.Sym.sep" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "Bool", - "PCP.Machine.Sym.bit", - "Unit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym.casesOn", - "Unit.unit" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": 31, - "is_class": false, - "kind": "theorem", - "line": 30, - "module": "PCP.Complexity.CostModel", - "name": "PCP.length_bitsOfFin", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), (PCP.bitsOfFin k r).length = k", - "type_dependencies": [ - "Nat", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "Eq", - "List.length", - "Bool", - "PCP.bitsOfFin" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Soundness at `x` with error `s`: every proof is accepted with probability at most `s`. ", - "end_line": 134, - "is_class": false, - "kind": "definition", - "line": 133, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.SoundAt", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Verifier → List Bool → ℚ → Prop", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Rat" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Rat", - "PCP.ProofOracle", - "LE.le", - "Rat.instLE", - "PCP.Verifier.accProb" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "recursor", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.rec", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n {a : ℕ} → (t : PCP.QueryTree a) → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.inj", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} {accept accept_1 : Bool}, PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1 → accept = accept_1", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "PCP.QueryTree", - "PCP.QueryTree.leaf" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.ctorIdx", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → ℕ", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Nat" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instReprSym", - "provenance": "lean", - "structural_dependencies": [], - "type": "Repr PCP.Machine.Sym", - "type_dependencies": [ - "Repr", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Repr.mk", - "PCP.Machine.Sym", - "PCP.Machine.instReprSym.repr" - ] - }, - { - "axioms": [], - "doc": "A \"proxy type\" equivalent to `PCP.Machine.Sym` that is constructed from `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum`. See `PCP.Machine.Sym.proxyTypeEquiv` for the equivalence. (Generated by the `proxy_equiv%` elaborator.)", - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.proxyType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "Sum", - "Bool", - "Unit" - ] - }, - { - "axioms": [ - "propext", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.length_encodePair._proof_1_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (p : List Bool × List Bool), ¬p.1.length + (p.2.length + 1) = p.1.length + p.2.length + 1 → False", - "type_dependencies": [ - "Prod", - "List", - "Bool", - "Not", - "Eq", - "Nat", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "List.length", - "Prod.fst", - "Prod.snd", - "OfNat.ofNat", - "instOfNatNat", - "False" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.ctorElimType", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → ℕ → Sort (max 1 u)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "cond", - "Nat.ble", - "PULift", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ] - }, - { - "axioms": [], - "doc": "One step of an adaptive verifier algorithm.\n\n`alg x r as` is given the input `x`, the random string `r` as a bit list, and the answer bits\nreceived so far (oldest first). It returns either `.inl b`, halting with decision `b`, or\n`.inr a`, naming the next proof address to query.\n\nThis is the algorithmic counterpart of `QueryTree`: a decision tree is what the algorithm *does*,\nthis is the algorithm itself, and a cost model measures the latter. ", - "end_line": 24, - "is_class": false, - "kind": "definition", - "line": 16, - "module": "PCP.Complexity.CostModel", - "name": "PCP.VerifierAlg", - "provenance": "lean", - "structural_dependencies": [], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [ - "List", - "Bool", - "Sum", - "Nat" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.leaf.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (accept : Bool), sizeOf (PCP.QueryTree.leaf accept) = 1 + sizeOf d + sizeOf accept", - "type_dependencies": [ - "Nat", - "Bool", - "Eq", - "SizeOf.sizeOf", - "PCP.QueryTree", - "PCP.QueryTree._sizeOf_inst", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "instSizeOfNat", - "Bool._sizeOf_inst" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 39, - "is_class": false, - "kind": "definition", - "line": 17, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {P_1 : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {t : PCP.NPCertificate P_1 L} →\n {P' : (List Bool → List Bool → Bool) → Prop} →\n {L' : PCP.Language} →\n {t' : PCP.NPCertificate P' L'} → P_1 = P' → L = L' → t ≍ t' → PCP.NPCertificate.noConfusionType P t t'", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Eq", - "HEq", - "PCP.NPCertificate.noConfusionType" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "PCP.NPCertificate", - "Eq", - "HEq", - "Eq.ndrec", - "PCP.NPCertificate.noConfusionType", - "PCP.NPCertificate.casesOn", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Bool.true", - "Eq.refl", - "eq_of_heq" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "The random strings on which `V` accepts `x` given proof `π`. ", - "end_line": 99, - "is_class": false, - "kind": "definition", - "line": 97, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.acceptingRandomness", - "provenance": "lean", - "structural_dependencies": [], - "type": "(V : PCP.Verifier) → (x : List Bool) → PCP.ProofOracle → Finset (Fin (2 ^ V.randomness x.length))", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Finset", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length" - ], - "value_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "PCP.ProofOracle", - "Finset.filter", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "Eq", - "PCP.QueryTree.eval", - "PCP.Verifier.queries", - "PCP.Verifier.run", - "Bool.true", - "instDecidableEqBool", - "Finset.univ", - "Fin.fintype" - ] - }, - { - "axioms": [], - "doc": "Query proof address `addr`, then continue in `onFalse` or `onTrue`. ", - "end_line": 37, - "is_class": false, - "kind": "constructor", - "line": 36, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query", - "provenance": "lean", - "structural_dependencies": [ - "PCP.QueryTree" - ], - "type": "{d : ℕ} → ℕ → PCP.QueryTree d → PCP.QueryTree d → PCP.QueryTree (d + 1)", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.casesOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.rec" - ] - }, - { - "axioms": [], - "doc": "An equivalence between the \"proxy type\" `PCP.Machine.Sym.proxyType` and `PCP.Machine.Sym`. The proxy type is a reducible definition that represents the inductive type using `Unit`, `PLift`, `Sigma`, `Empty`, and `Sum` (and whatever other inductive types appear within the inductive type), and the intended use is to define typeclass instances uses pre-existing instances on these. (Generated by the `proxy_equiv%` elaborator.)", - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.proxyTypeEquiv", - "provenance": "lean", - "structural_dependencies": [], - "type": "Bool ⊕ Unit ≃ PCP.Machine.Sym", - "type_dependencies": [ - "Equiv", - "Sum", - "Bool", - "Unit", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Equiv.mk", - "Sum", - "Bool", - "Unit", - "PCP.Machine.Sym", - "PCP.Machine.instFintypeSym.match_3", - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.instFintypeSym.match_5", - "Sum.inl", - "Sum.inr", - "Unit.unit", - "Sum.casesOn", - "Eq", - "Eq.ndrec", - "Eq.refl", - "Eq.symm", - "PCP.Machine.Sym.casesOn" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym.sep.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "sizeOf PCP.Machine.Sym.sep = 1", - "type_dependencies": [ - "Eq", - "Nat", - "SizeOf.sizeOf", - "PCP.Machine.Sym", - "PCP.Machine.Sym._sizeOf_inst", - "PCP.Machine.Sym.sep", - "OfNat.ofNat", - "instOfNatNat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instInhabitedSym.default", - "provenance": "lean", - "structural_dependencies": [], - "type": "PCP.Machine.Sym", - "type_dependencies": [ - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "PCP.Machine.Sym.bit", - "Inhabited.default", - "Bool", - "instInhabitedBool" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 25, - "is_class": false, - "kind": "definition", - "line": 25, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.instDecidableEqSym.decEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "(x x_1 : PCP.Machine.Sym) → Decidable (x = x_1)", - "type_dependencies": [ - "PCP.Machine.Sym", - "Decidable", - "Eq" - ], - "value_dependencies": [ - "PCP.Machine.Sym", - "PCP.Machine.instDecidableEqSym.decEq.match_1", - "Decidable", - "Eq", - "Bool", - "dite", - "PCP.Machine.Sym.bit", - "instDecidableEqBool", - "Eq.ndrec", - "Decidable.isTrue", - "PCP.Machine.instDecidableEqSym.decEq._proof_1", - "Not", - "Decidable.isFalse", - "PCP.Machine.instDecidableEqSym.decEq._proof_2", - "PCP.Machine.Sym.sep", - "PCP.Machine.instDecidableEqSym.decEq._proof_3", - "PCP.Machine.instDecidableEqSym.decEq._proof_4", - "Unit", - "rfl" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.query.sizeOf_spec", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ {d : ℕ} (addr : ℕ) (onFalse onTrue : PCP.QueryTree d),\n sizeOf (PCP.QueryTree.query addr onFalse onTrue) = 1 + sizeOf d + sizeOf addr + sizeOf onFalse + sizeOf onTrue", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "SizeOf.sizeOf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree._sizeOf_inst", - "PCP.QueryTree.query", - "instSizeOfNat" - ], - "value_dependencies": [] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": 30, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Complexity.NP", - "name": "PCP.NPCertificate.mk.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : (List Bool → List Bool → Bool) → Prop} →\n {L : PCP.Language} →\n {P_1 : Sort u} →\n {witnessBound : Polynomial ℕ} →\n {check : List Bool → List Bool → Bool} →\n {check_polyTime : P check} →\n {spec : ∀ (x : List Bool), L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound ∧ check x w = true} →\n {witnessBound' : Polynomial ℕ} →\n {check' : List Bool → List Bool → Bool} →\n {check_polyTime' : P check'} →\n {spec' :\n ∀ (x : List Bool),\n L x ↔ ∃ w, w.length ≤ Polynomial.eval x.length witnessBound' ∧ check' x w = true} →\n { witnessBound := witnessBound, check := check, check_polyTime := check_polyTime, spec := spec } =\n { witnessBound := witnessBound', check := check', check_polyTime := check_polyTime',\n spec := spec' } →\n (witnessBound = witnessBound' → check = check' → P_1) → P_1", - "type_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk" - ], - "value_dependencies": [ - "List", - "Bool", - "PCP.Language", - "Polynomial", - "Nat", - "Nat.instSemiring", - "Iff", - "Exists", - "And", - "LE.le", - "instLENat", - "List.length", - "Polynomial.eval", - "Eq", - "Bool.true", - "PCP.NPCertificate", - "PCP.NPCertificate.mk", - "id", - "PCP.NPCertificate.noConfusion", - "Eq.refl", - "heq_of_eq" - ] - }, - { - "axioms": [], - "doc": "A decision tree over a Boolean proof oracle, of depth at most `d`.\n\n`leaf` may occur at any depth, so `QueryTree d` is \"at most `d` queries\", not \"exactly `d`\". ", - "end_line": 37, - "is_class": false, - "kind": "inductive", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree", - "provenance": "lean", - "structural_dependencies": [ - "PCP.QueryTree.leaf", - "PCP.QueryTree.query", - "PCP.QueryTree" - ], - "type": "ℕ → Type", - "type_dependencies": [ - "Nat" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "(x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n PCP.QueryTree.below (motive := fun x x_2 => PCP.ProofOracle → Bool) x_1 → PCP.ProofOracle → Bool", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Bool" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.eval.match_1", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "ite", - "Eq", - "Bool.true", - "instDecidableEqBool", - "PProd" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": "Soundness: a polynomial-time verifier algorithm is computable. This rules out a degenerate\nmodel that counts an arbitrary, even noncomputable, step function as efficient; such a model\nwould let a \"verifier\" decide the language outright. ", - "end_line": 89, - "is_class": false, - "kind": "theorem", - "line": 89, - "module": "PCP.Complexity.CostModel", - "name": "PCP.CostModel.polyTimeAlg_computable", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (self : PCP.CostModel) (alg : PCP.VerifierAlg), self.PolyTimeAlg alg → Computable fun t => alg t.1 t.2.1 t.2.2", - "type_dependencies": [ - "PCP.CostModel", - "PCP.VerifierAlg", - "PCP.CostModel.PolyTimeAlg", - "Computable", - "Prod", - "List", - "Bool", - "Sum", - "Nat", - "Primcodable.prod", - "Primcodable.list", - "Primcodable.bool", - "Primcodable.sum", - "Primcodable.ofDenumerable", - "Denumerable.nat", - "Prod.fst", - "Prod.snd" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval.match_1", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : (x : ℕ) → PCP.QueryTree x → PCP.ProofOracle → Sort u_1) →\n (x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n (x_2 : PCP.ProofOracle) →\n ((x : ℕ) → (b : Bool) → (x_3 : PCP.ProofOracle) → motive x (PCP.QueryTree.leaf b) x_3) →\n ((d a : ℕ) → (f t : PCP.QueryTree d) → (π : PCP.ProofOracle) → motive (d + 1) (PCP.QueryTree.query a f t) π) →\n motive x x_1 x_2", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.ProofOracle", - "Bool", - "PCP.QueryTree.leaf", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "PCP.QueryTree.casesOn", - "Eq", - "HEq", - "Eq.ndrec", - "Eq.symm", - "eq_of_heq", - "Eq.refl", - "HEq.refl" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": "The decision tree used on input `x` and random string `r`. ", - "end_line": 91, - "is_class": false, - "kind": "definition", - "line": 91, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.run", - "provenance": "lean", - "structural_dependencies": [], - "type": "(self : PCP.Verifier) → (x : List Bool) → Fin (2 ^ self.randomness x.length) → PCP.QueryTree self.queries", - "type_dependencies": [ - "PCP.Verifier", - "List", - "Bool", - "Fin", - "HPow.hPow", - "Nat", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "PCP.Verifier.randomness", - "List.length", - "PCP.QueryTree", - "PCP.Verifier.queries" - ], - "value_dependencies": [ - "PCP.Verifier" - ] - }, - { - "axioms": [ - "propext" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "theorem", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.Verifier.mk.injEq", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries)\n (randomness_1 : ℕ → ℕ) (queries_1 : ℕ)\n (run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1),\n ({ randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 }) =\n (randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1)", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "Fin", - "HPow.hPow", - "instHPow", - "NPow.toPow", - "Monoid.toNPow", - "Nat.instMonoid", - "OfNat.ofNat", - "instOfNatNat", - "List.length", - "PCP.QueryTree", - "Eq", - "PCP.Verifier", - "PCP.Verifier.mk", - "And", - "HEq" - ], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.brecOn", - "provenance": "lean", - "structural_dependencies": [], - "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} → (t : PCP.QueryTree a) → ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PProd", - "PCP.QueryTree.brecOn.go" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.noConfusionType", - "provenance": "lean", - "structural_dependencies": [], - "type": "Sort u → {a : ℕ} → PCP.QueryTree a → {a' : ℕ} → PCP.QueryTree a' → Sort u", - "type_dependencies": [ - "Nat", - "PCP.QueryTree" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.casesOn", - "Bool", - "Eq", - "HEq" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.eval_congr._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "∀ (x : ℕ) (x_1 : PCP.QueryTree x)\n (f :\n PCP.QueryTree.below (motive := fun x x_2 =>\n ∀ (x_3 x_4 : PCP.ProofOracle), (∀ a ∈ x_2.addresses, x_3 a = x_4 a) → x_2.eval x_3 = x_2.eval x_4) x_1)\n (x_2 x_3 : PCP.ProofOracle), (∀ a ∈ x_1.addresses, x_2 a = x_3 a) → x_1.eval x_2 = x_1.eval x_3", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.eval" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "PCP.ProofOracle", - "Membership.mem", - "Finset", - "SetLike.instMembership", - "Finset.instSetLike", - "PCP.QueryTree.addresses", - "Eq", - "Bool", - "PCP.QueryTree.eval", - "PCP.QueryTree.eval_congr.match_1_1", - "PCP.QueryTree.leaf", - "rfl", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "of_eq_true", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "Eq.trans", - "Or", - "True", - "Finset.mem_insert._simp_1", - "congr", - "congrArg", - "eq_self", - "Finset.mem_union._simp_1", - "true_or", - "PProd", - "Eq.mpr", - "id", - "Iff.mpr", - "Not", - "Classical.or_iff_not_imp_left", - "False.elim", - "ite", - "Bool.true", - "instDecidableEqBool", - "congrFun'", - "ite_congr" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Complexity.CostModel", - "name": "PCP.QueryTree.ofStep.match_3", - "provenance": "lean", - "structural_dependencies": [], - "type": "(motive : ℕ → List Bool → Sort u_1) →\n (x : ℕ) →\n (x_1 : List Bool) →\n ((as : List Bool) → motive 0 as) → ((n : ℕ) → (as : List Bool) → motive n.succ as) → motive x x_1", - "type_dependencies": [ - "Nat", - "List", - "Bool", - "OfNat.ofNat", - "instOfNatNat", - "Nat.succ" - ], - "value_dependencies": [ - "Nat", - "List", - "Bool", - "OfNat.ofNat", - "instOfNatNat", - "Nat.succ", - "Nat.casesOn" - ] - }, - { - "axioms": [ - "propext", - "Classical.choice", - "Quot.sound" - ], - "doc": null, - "end_line": null, - "is_class": false, - "kind": "definition", - "line": null, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.addresses._f", - "provenance": "lean", - "structural_dependencies": [], - "type": "(x : ℕ) → (x_1 : PCP.QueryTree x) → PCP.QueryTree.below x_1 → Finset ℕ", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "Finset" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "PCP.QueryTree.below", - "Finset", - "PCP.QueryTree.addresses.match_1", - "Bool", - "PCP.QueryTree.leaf", - "EmptyCollection.emptyCollection", - "Finset.instEmptyCollection", - "HAdd.hAdd", - "instHAdd", - "instAddNat", - "OfNat.ofNat", - "instOfNatNat", - "PCP.QueryTree.query", - "Insert.insert", - "Finset.instInsert", - "instDecidableEqNat", - "Union.union", - "Finset.instUnion", - "PProd" - ] - }, - { - "axioms": [], - "doc": "Encoding of a Boolean result. ", - "end_line": 48, - "is_class": false, - "kind": "definition", - "line": 47, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.encodeBool", - "provenance": "lean", - "structural_dependencies": [], - "type": "Bool → List PCP.Machine.Sym", - "type_dependencies": [ - "Bool", - "List", - "PCP.Machine.Sym" - ], - "value_dependencies": [ - "Bool", - "List.cons", - "PCP.Machine.Sym", - "PCP.Machine.Sym.bit", - "List.nil" - ] - }, - { - "axioms": [], - "doc": null, - "end_line": 37, - "is_class": false, - "kind": "definition", - "line": 30, - "module": "PCP.Verifier.Definition", - "name": "PCP.QueryTree.noConfusion", - "provenance": "lean", - "structural_dependencies": [], - "type": "{P : Sort u} →\n {a : ℕ} →\n {t : PCP.QueryTree a} → {a' : ℕ} → {t' : PCP.QueryTree a'} → a = a' → t ≍ t' → PCP.QueryTree.noConfusionType P t t'", - "type_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HEq", - "PCP.QueryTree.noConfusionType" - ], - "value_dependencies": [ - "Nat", - "PCP.QueryTree", - "Eq", - "HEq", - "Eq.ndrec", - "PCP.QueryTree.noConfusionType", - "PCP.QueryTree.casesOn", - "Bool", - "Eq.refl", - "HEq.refl", - "eq_of_heq" - ] - }, - { - "axioms": [], - "doc": "The tape alphabet: a bit, or a separator between arguments.\n\nA separator is needed because the machine takes one input list, while our relations and algorithms\ntake two or three bit strings. Self-delimiting encodings would avoid it at the cost of a length\nprefix; a separator symbol is the simpler convention and is fixed here once. ", - "end_line": 25, - "is_class": false, - "kind": "inductive", - "line": 17, - "module": "PCP.Complexity.Machine", - "name": "PCP.Machine.Sym", - "provenance": "lean", - "structural_dependencies": [ - "PCP.Machine.Sym.bit", - "PCP.Machine.Sym.sep", - "PCP.Machine.Sym" - ], - "type": "Type", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "name": "PCP.Algebraic.ThreeColorGrid.colorable_iff_exists_constraints", - "module": "PCP.Algebraic.ThreeColorGrid", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem colorable_iff_exists_constraints [CharP F 2] {ω : F}\n (hω : IsPrimitiveRoot ω 3) (H : Finset F) (G : SimpleGraph (σ → H)) :\n G.Colorable 3 ↔ ∃ P : MvPolynomial σ F,\n P.totalDegree ≤ (H.card - 1) * Fintype.card σ ∧\n VanishesOn H (validPolynomial P) ∧\n VanishesOn H (properPolynomial (edgeExtension H G) (differencePolynomial P))", - "line": 117, - "end_line": 132, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le_log_add_one", - "module": "PCP.Algebraic.ThreeColorParameterChoice", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem volume_le_log_add_one (N : ℕ) : volume N ≤ 32 * (Nat.clog 2 N + 1)", - "line": 79, - "end_line": 82, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Lang.ThreeColorRuntime.polyTimeAlg", - "module": "PCP.Complexity.ThreeColorRuntime", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem polyTimeAlg :\n Machine.PolyTimeAlg ComputableThreeColorAmplifiedQueryAlgorithm.algorithm\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\n", - "line": 11, - "end_line": 15, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true", - "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem exists_proof_test_eq_true (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : Function.Injective nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) {ω : F} (hω : IsPrimitiveRoot ω 3)\n (H : Finset F) (hH : H.Nonempty) (G : SimpleGraph (Fin n → H)) (hG : G.Colorable 3)\n (hdegree : 5 * ((H.card - 1) * n) < m ^ c) :\n ∃ π : Proof F n m c t, ∀ s, test ρ nodes ζ H G π s = true", - "line": 101, - "end_line": 128, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.rejectionRate_lower_bound", - "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", - "kind": "theorem", - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem rejectionRate_lower_bound\n (hq : 2 * c < Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) (H : Finset F) (hH : H.Nonempty)\n (P : MvPolynomial (Fin n) F) (M : MvPolynomial (Fin n ⊕ Fin n) F)\n (hP : P.totalDegree ≤ D) (hM : M.totalDegree ≤ D)\n (hdecode : c * m ^ c ≤ D) (hnot : ¬ GridVanishing.VanishesOn H P)\n (p' : (Fin n → F) → Coefficients t 1 → ZMod 2)\n (M' : CertificatePoint F n → Coefficients t 1 → ZMod 2)\n (A : Auxiliary F n m c t) {δP δM : ℚ}\n (hp : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) p'\n (fun x => encode 1 (ρ (eval x P))) ≤ δP)\n (hm : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) M'\n (fun x => encode 1 (ρ (eval x M))) ≤ δM) :\n (1 - ((D * H.card : ℕ) : ℚ) / Fintype.card F) / 2 ≤\n (1 + 2 * BinaryLocalCorrection.soundnessConstant c) *\n rejectionRate ρ nodes ζ H p' M' A + δP + 2 * δM +\n (D : ℚ) / (Fintype.card F - 1 : ℕ)", - "line": 249, - "end_line": 298, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "name": "PCP.Algebraic.GridVanishing.vanishesOn_iff_exists_decomposition", - "module": "PCP.Algebraic.GridVanishing", - "kind": "theorem", - "type": "SOURCE-LEVEL SIGNATURE (not elaborated; section variables below):\ntheorem vanishesOn_iff_exists_decomposition (H : Finset R)\n (p : MvPolynomial σ R) :\n VanishesOn H p ↔ ∃ Q : σ → MvPolynomial σ R,\n (∀ i, (Q i).totalDegree ≤ p.totalDegree - H.card) ∧\n p = ∑ i, Q i * coordinate H i\nSECTION VARIABLE DECLARATIONS (source order; some may be out of scope):\nvariable {R σ : Type*} [CommRing R]\nvariable [IsDomain R]\nvariable [Finite σ]\nvariable [Fintype σ]", - "line": 134, - "end_line": 148, - "axioms": [], - "type_dependencies": [], - "value_dependencies": [], - "structural_dependencies": [], - "provenance": "source-read" - }, - { - "axioms": [], - "doc": null, - "end_line": 277, - "is_class": false, - "kind": "theorem", - "line": 246, - "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", - "name": "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate_lower_bound", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem rejectionRate_lower_bound\n (hq : 2 * c < Fintype.card F)\n (ρ : F ≃ₗ[ZMod 2] (Fin t → ZMod 2))\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ x, (Q x).natDegree ≤ r)\n {nodes : Fin (c + 1) → F} (hnodes : GeneratorLowDegreeTest.IsGeneratorNodes nodes)\n {ζ : F} (hζ : StandardLocalCorrection.GoodNodes c ζ) (H : Finset F) (hH : H.Nonempty)\n (f : (Fin n → F) → F) (P : MvPolynomial (Fin n) F)\n (hvalue : ∀ x, (Q x).eval (f x) = eval x P)\n (M : MvPolynomial (Fin n ⊕ Fin n) F) (hP : P.totalDegree ≤ D) (hM : M.totalDegree ≤ D)\n (hdecode : c * m ^ c ≤ D) (hnot : ¬ VanishesOn H P)\n (p : (Fin n → F) → Coefficients t r → ZMod 2)\n (M' : CertificatePoint F n → Coefficients t 1 → ZMod 2) (A : Auxiliary F n m c t)\n {δP δM : ℚ} (hp : HadamardDerivedOracle.fullDistance ρ p f ≤ δP)\n (hm : BinaryLagrangeConstraint.homogeneousDistance (le_refl 1) M'\n (fun x => encode 1 (ρ (eval x M))) ≤ δM) :\n (1 - ((D * H.card : ℕ) : ℚ) / Fintype.card F) / 2 ≤\n (1 + 2 * BinaryLocalCorrection.soundnessConstant c) *\n (rejectionRate ρ Q hQ nodes ζ H p M' A + 2 * δP) + 2 * δM +\n (D : ℚ) / (Fintype.card F - 1 : ℕ)", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 41, - "is_class": false, - "kind": "theorem", - "line": 39, - "module": "PCP.Complexity.ReferenceNPConverse", - "name": "PCP.ReferenceNP.inNP_iff_mem", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ntheorem inNP_iff_mem {L : Complexity.Language} :\n PCP.InNP Machine.PolyTimeRel L ↔ L ∈ Complexity.NP", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 64, - "is_class": false, - "kind": "def", - "line": 63, - "module": "PCP.Algebraic.SetMultilinear", - "name": "PCP.Algebraic.SetMultilinear.evaluationPoint", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ndef evaluationPoint (x : R) : Variables m c → R :=\n fun ij => x ^ ((ij.2 : ℕ) * m ^ (ij.1 : ℕ))", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 32, - "is_class": false, - "kind": "abbrev", - "line": 32, - "module": "PCP.Algebraic.EncodedLineLowDegreeTest", - "name": "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nabbrev Auxiliary (F σ : Type*) (m c t : ℕ) := Lines F σ → RowOracle F m c t", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 45, - "is_class": false, - "kind": "structure", - "line": 37, - "module": "PCP.Algebraic.ThreeColorVerifier", - "name": "PCP.Algebraic.ThreeColorVerifier.Proof", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\nstructure Proof (F : Type*) (n m c t : ℕ) where\n color : Vertex F n → Coefficients t 3 → ZMod 2\n validCert : PairPoint F n → Coefficients t 1 → ZMod 2\n difference : PairPoint F n → Coefficients t 3 → ZMod 2\n properCert : ProperPoint F n → Coefficients t 1 → ZMod 2\n colorLines : EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t\n validLines : EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t\n differenceLines : EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t\n properLines : EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 136, - "is_class": false, - "kind": "inductive", - "line": 124, - "module": "PCP.Algebraic.ThreeColorVerifier", - "name": "PCP.Algebraic.ThreeColorVerifier.Query", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ninductive Query (F : Type*) (n m c t : ℕ) where\n | color : Vertex F n → Coefficients t 3 → Query F n m c t\n | validCert : PairPoint F n → Coefficients t 1 → Query F n m c t\n | difference : PairPoint F n → Coefficients t 3 → Query F n m c t\n | properCert : ProperPoint F n → Coefficients t 1 → Query F n m c t\n | colorLine : (Vertex F n × Vertex F n) → BinaryLocalCorrection.InnerPoint F m c →\n Coefficients t 1 → Query F n m c t\n | validLine : (PairPoint F n × PairPoint F n) → BinaryLocalCorrection.InnerPoint F m c →\n Coefficients t 1 → Query F n m c t\n | differenceLine : (PairPoint F n × PairPoint F n) → BinaryLocalCorrection.InnerPoint F m c →\n Coefficients t 1 → Query F n m c t\n | properLine : (ProperPoint F n × ProperPoint F n) → BinaryLocalCorrection.InnerPoint F m c →\n Coefficients t 1 → Query F n m c t", - "type_dependencies": [], - "value_dependencies": [] - }, - { - "axioms": [], - "doc": null, - "end_line": 147, - "is_class": false, - "kind": "def", - "line": 139, - "module": "PCP.Algebraic.ThreeColorVerifier", - "name": "PCP.Algebraic.ThreeColorVerifier.read", - "provenance": "source-read", - "structural_dependencies": [], - "type": "SOURCE EXCERPT, NOT ELABORATED:\ndef read (π : Proof F n m c t) : Query F n m c t → ZMod 2\n | .color x q => π.color x q\n | .validCert x q => π.validCert x q\n | .difference x q => π.difference x q\n | .properCert x q => π.properCert x q\n | .colorLine uv x q => π.colorLines uv x q\n | .validLine uv x q => π.validLines uv x q\n | .differenceLine uv x q => π.differenceLines uv x q\n | .properLine uv x q => π.properLines uv x q", - "type_dependencies": [], - "value_dependencies": [] - } - ] + "PCP.Algebraic.PointLineConstants.smallError" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The rest of the grid verifier, with its one primary bit supplied as an argument. ", + "end_line": 48, + "is_class": false, + "kind": "definition", + "line": 40, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {n m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n Finset F →\n (PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t →\n PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample F n m c t → ZMod 2 → Option (ZMod 2 × ZMod 2)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "Option", + "Prod" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck", + "Option.some", + "PCP.Algebraic.BinaryZeroOnGridCorrection.call", + "Sum", + "PCP.Algebraic.BinaryZeroOnGrid.zeroPoint", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGrid.recoveryPoint" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.color.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) (a_2 : PCP.Algebraic.ThreeColorVerifier.Vertex F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3),\n (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1 = PCP.Algebraic.ThreeColorVerifier.Query.color a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "One variable for each possible digit in each block. ", + "end_line": 33, + "is_class": false, + "kind": "definition", + "line": 32, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.Variables", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Prod", + "Fin" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.PointLineSoundness", + "name": "PCP.Algebraic.PointLineTest.correction.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] {inst_4 : DecidableEq σ} [inst_5 : DecidableEq σ]\n (table table_1 : PCP.Algebraic.PointLineTest.LineTable F σ c),\n table = table_1 →\n ∀ (x x_1 : σ → F),\n x = x_1 → PCP.Algebraic.PointLineTest.correction table x = PCP.Algebraic.PointLineTest.correction table_1 x_1", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.PointLineTest.LineTable", + "Eq", + "PCP.Algebraic.PointLineTest.correction" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The linear map on the paper's actual domain of polynomials of degree at most `d`. ", + "end_line": 203, + "is_class": false, + "kind": "definition", + "line": 200, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.boundedEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] →\n (m : ℕ) →\n [NeZero m] →\n (c d : ℕ) → ↥(Polynomial.degreeLE R ↑d) →ₗ[R] MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Subtype", + "Polynomial", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LinearMap.comp", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.SetMultilinear.boundedEncode._proof_1", + "PCP.Algebraic.SetMultilinear.encode", + "Submodule.subtype" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 435, + "is_class": false, + "kind": "theorem", + "line": 431, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 1 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.validCert π.validLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Sum", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.validLines" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 25, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instDecidableEqSym", + "provenance": "lean", + "structural_dependencies": [], + "type": "DecidableEq PCP.Machine.Sym", + "type_dependencies": [ + "DecidableEq", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "PCP.Machine.instDecidableEqSym.decEq" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk._flat_ctor", + "provenance": "lean", + "structural_dependencies": [], + "type": "(randomness : ℕ → ℕ) →\n (queries : ℕ) → ((x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries) → PCP.Verifier", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier" + ], + "value_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "PCP.Verifier.mk" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} [inst : SizeOf F]\n (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n sizeOf (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2) = 1 + sizeOf a", + "type_dependencies": [ + "Nat", + "SizeOf", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "SizeOf.sizeOf", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query._sizeOf_inst", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Prod._sizeOf_inst", + "instSizeOfDefault" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Below the selected exponent, an admissible predecessor cannot hold the input. ", + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 41, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.predecessor_volume_lt", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ},\n 2 < PCP.Algebraic.ThreeColorParameterChoice.exponent N →\n (PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1) *\n 2 ^ (PCP.Algebraic.ThreeColorParameterChoice.exponent N - 1) <\n Nat.clog 2 N", + "type_dependencies": [ + "Nat", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "HMul.hMul", + "instHMul", + "instMulNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.FixedLagrangeConstraint.rejectionRate_nodes._simp_1_8", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b ≠ 0) = (a ≠ b)", + "type_dependencies": [ + "AddGroup", + "Eq", + "Ne", + "HSub.hSub", + "instHSub", + "SubNegMonoid.toSub", + "AddGroup.toSubNegMonoid", + "OfNat.ofNat", + "Zero.toOfNat0", + "NegZeroClass.toZero", + "SubNegZeroMonoid.toNegZeroClass", + "SubtractionMonoid.toSubNegZeroMonoid", + "AddGroup.toSubtractionMonoid" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.exists_program._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ) [DecidableEq h.tm.Λ]\n [DecidableEq h.tm.σ] [(k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)],\n PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk →\n ∀ {k a : ℕ} (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a) (P : PCP.Lang.Prog)\n (A C D : ℕ) (x : List Bool),\n PCP.Lang.listSize (List.map Bool.toNat x) ≤ 2 * x.length →\n ¬PCP.Lang.listSize (List.map Bool.toNat x) + 1 ≤ 2 * x.length + 1 → False", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "PCP.Lang.Prog", + "LE.le", + "instLENat", + "PCP.Lang.listSize", + "List.map", + "Bool.toNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "Not", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The small-rejection binary guarantee for arbitrary finite coordinate types.\nIt is derived from the proved generic field theorem, without transporting or\nassuming a binary tester's soundness. ", + "end_line": 104, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Algebraic.BinaryLocalRowDecoding", + "name": "PCP.Algebraic.BinaryLocalRowDecoding.exists_close_of_small_rejection", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] [inst_2 : Fintype F] [inst_3 : Fintype σ]\n [inst_4 : DecidableEq σ] {c t r : ℕ},\n 2 * c < Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (a : Fin (c + 1) → F),\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes a →\n ∀ (H : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2),\n (112 * ↑(c + 2) + 4) * PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H ≤\n PCP.Algebraic.GeneratorLowDegreeTest.smallError c →\n ∃ Q,\n Q.totalDegree ≤ c ∧\n PCP.Algebraic.relativeDistance (fun p => H p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ ((MvPolynomial.eval x) Q)) ≤\n (112 * (↑c + 2) + 60) * PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr H fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ ((MvPolynomial.eval x) Q)))) ≤\n (112 * (↑c + 2) + 60) * PCP.Algebraic.BinaryLowDegreeTest.rejectionRate hr ρ a H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Rat", + "Rat.instLE", + "Rat.instMul", + "Rat.instAdd", + "Rat.instOfNat", + "Nat.cast", + "Rat.instNatCast", + "PCP.Algebraic.BinaryLowDegreeTest.rejectionRate", + "PCP.Algebraic.GeneratorLowDegreeTest.smallError", + "Exists", + "MvPolynomial", + "And", + "MvPolynomial.totalDegree", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "_private.PCP.Algebraic.BinaryZeroOnGridSoundness.0.PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1.eq_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (motive : Option (ZMod 2) → Option (ZMod 2) → Option (ZMod 2) → Sort u_1) (x x_1 x_2 : Option (ZMod 2))\n (h_1 : (p m₀ mZ : ZMod 2) → motive (some p) (some m₀) (some mZ))\n (h_2 : (x x_3 x_4 : Option (ZMod 2)) → motive x x_3 x_4),\n (∀ (p m₀ mZ : ZMod 2), x = some p → x_1 = some m₀ → x_2 = some mZ → False) →\n (match x, x_1, x_2 with\n | some p, some m₀, some mZ => h_1 p m₀ mZ\n | x, x_4, x_5 => h_2 x x_4 x_5) =\n h_2 x x_1 x_2", + "type_dependencies": [ + "Option", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Option.some", + "Eq", + "False", + "PCP.Algebraic.BinaryZeroOnGrid.optionCheck.match_1" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 270, + "is_class": false, + "kind": "definition", + "line": 269, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} → [Field F] → [Fintype F] → [DecidableEq F] → [Fintype σ] → [DecidableEq σ] → ℕ → F → ((σ → F) → F) → ℚ", + "type_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "Rat" + ], + "value_dependencies": [ + "Field", + "Fintype", + "DecidableEq", + "Nat", + "PCP.Algebraic.WeightedConstraint.rejectionRate", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Pi.addCommGroup", + "Ring.toAddCommGroup", + "DivisionRing.toRing", + "Field.toDivisionRing", + "Pi.Function.module", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Semiring.toAddCommMonoid", + "Ring.toSemiring", + "Semiring.toModule", + "Fin.fintype", + "Pi.instFintype", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 82, + "is_class": false, + "kind": "theorem", + "line": 81, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes_ne_zero", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F},\n IsPrimitiveRoot ζ (Fintype.card F - 1) → ∀ (i : Fin (c + 1)), PCP.Algebraic.GeneratorLowDegreeTest.nodes c ζ i ≠ 0", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Ne", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes", + "Zero.toOfNat0", + "MulZeroClass.toZero", + "instMulZeroClassOfSemiring", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Binary relations on bit strings decidable in polynomial time. ", + "end_line": 81, + "is_class": false, + "kind": "definition", + "line": 81, + "module": "PCP.Complexity.CostModel", + "name": "PCP.CostModel.PolyTimeRel", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.CostModel → (List Bool → List Bool → Bool) → Prop", + "type_dependencies": [ + "PCP.CostModel", + "List", + "Bool" + ], + "value_dependencies": [ + "PCP.CostModel" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 448, + "is_class": false, + "kind": "theorem", + "line": 444, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_three", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 3 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.properCert π.properLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Sum", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "le_refl", + "Nat.instPreorder", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.Proof.properLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 442, + "is_class": false, + "kind": "theorem", + "line": 437, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_two", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 2 =\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate ⋯ ρ nodes ζ π.difference π.differenceLines", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "Sum", + "instFintypeSum", + "Fin.fintype", + "instDecidableEqSum", + "instDecidableEqFin", + "Decidable.byContradiction", + "LE.le", + "instLENat", + "Nat.decLe", + "Not", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "PCP.Algebraic.ThreeColorVerifier.Proof.difference", + "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.gridSeed.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c t r : ℕ} (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.gridSeed s = (s.1, s.2.1)", + "type_dependencies": [ + "Field", + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Eq", + "PCP.Algebraic.BinaryZeroOnGridCorrection.TestSample", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed", + "Prod.mk", + "Fin", + "Prod", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Sum", + "Prod.fst", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.colorLine.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n {a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1}\n {a_3 : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n}\n {a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c}\n {a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1},\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.colorLine a_3 a_4 a_5 →\n a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.polyTimeMap_constant._simp_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True", + "type_dependencies": [ + "Preorder", + "Eq", + "LE.le", + "Preorder.toLE", + "True" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The exponent vector of a basis image. ", + "end_line": 159, + "is_class": false, + "kind": "definition", + "line": 157, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.digitExponents", + "provenance": "lean", + "structural_dependencies": [], + "type": "(m : ℕ) → [NeZero m] → (c : ℕ) → ℕ → PCP.Algebraic.SetMultilinear.Variables m c →₀ ℕ", + "type_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables" + ], + "value_dependencies": [ + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finset.sum", + "Fin", + "Finsupp", + "PCP.Algebraic.SetMultilinear.Variables", + "Finsupp.instAddCommMonoid", + "Nat.instAddCommMonoid", + "Finset.univ", + "Fin.fintype", + "Finsupp.single", + "Prod.mk", + "PCP.Algebraic.digit", + "Fin.val", + "OfNat.ofNat", + "instOfNatNat" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Formal polynomial recovery. The exponent bound is essential. ", + "end_line": 98, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ) (P : Polynomial R),\n P.natDegree < m ^ c → (PCP.Algebraic.SetMultilinear.decode m c) ((PCP.Algebraic.SetMultilinear.encode m c) P) = P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Polynomial", + "CommSemiring.toSemiring", + "LT.lt", + "instLTNat", + "Polynomial.natDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "LinearMap", + "RingHom.id", + "Semiring.toAddCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Substitute powers of `Y` for the block variables, before evaluating `Y`. ", + "end_line": 69, + "is_class": false, + "kind": "definition", + "line": 66, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} →\n [inst : CommSemiring R] → (m c : ℕ) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) R →+* Polynomial R", + "type_dependencies": [ + "CommSemiring", + "Nat", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Polynomial", + "CommSemiring.toSemiring", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "Polynomial.semiring" + ], + "value_dependencies": [ + "CommSemiring", + "Nat", + "MvPolynomial.eval₂Hom", + "Polynomial", + "CommSemiring.toSemiring", + "PCP.Algebraic.SetMultilinear.Variables", + "Polynomial.commSemiring", + "Polynomial.C", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Semiring.toMonoid", + "Polynomial.semiring", + "Polynomial.X", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fin.val", + "Prod.snd", + "Fin", + "Nat.instMonoid", + "Prod.fst" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "The primary oracle uses degree-`r` queries; certificate queries keep their original types. ", + "end_line": 64, + "is_class": false, + "kind": "definition", + "line": 61, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.Query", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type u_2 → ℕ → ℕ → ℕ → ℕ → ℕ → Type u_2", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "Sum", + "Prod", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "1 ≤ 3", + "type_dependencies": [ + "LE.le", + "Nat", + "instLENat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Encoding an ordinary finite graph gives the intended completeness statement. ", + "end_line": 63, + "is_class": false, + "kind": "theorem", + "line": 60, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.completeAt_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N : ℕ} (G : SimpleGraph (Fin N)) [inst : DecidableRel G.Adj],\n G.Colorable 3 →\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.CompleteAt (PCP.Algebraic.ThreeColorEncoding.encode G)", + "type_dependencies": [ + "Nat", + "SimpleGraph", + "Fin", + "DecidableRel", + "SimpleGraph.Adj", + "SimpleGraph.Colorable", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Verifier.CompleteAt", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "PCP.Algebraic.ThreeColorEncoding.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.CostModel", + "name": "PCP.bitsOfFin.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), PCP.bitsOfFin k r = List.map (fun j => (↑r).testBit j) (List.range k)", + "type_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "List", + "Bool", + "PCP.bitsOfFin", + "List.map", + "Nat.testBit", + "Fin.val", + "List.range" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "Encoding of an argument pair: `x`, separator, `w`. ", + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 33, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodePair", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool × List Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Prod", + "List", + "Bool", + "HAppend.hAppend", + "PCP.Machine.Sym", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The algebraic conditions in Corollary 2.10, separate from degree bounds. ", + "end_line": 59, + "is_class": false, + "kind": "definition", + "line": 56, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.IsCertificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{R : Type u_1} → {σ : Type u_2} → [inst : CommRing R] → Finset R → MvPolynomial σ R → MvPolynomial (σ ⊕ σ) R → Prop", + "type_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum" + ], + "value_dependencies": [ + "CommRing", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Sum", + "And", + "Eq", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "OfNat.ofNat", + "Zero.toOfNat0", + "instMulZeroClassOfSemiring", + "AddMonoidAlgebra.semiring", + "Finsupp.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 101, + "is_class": false, + "kind": "theorem", + "line": 97, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.generator_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ),\n IsPrimitiveRoot (PCP.Algebraic.ThreeColorFields.generator k)\n (Fintype.card (PCP.Algebraic.ThreeColorFields.FieldFamily k) - 1)", + "type_dependencies": [ + "Nat", + "IsPrimitiveRoot", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "CommRing.toCommMonoid", + "Field.toCommRing", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.generator", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "PCP.Algebraic.ThreeColorFields.fieldFamilyFintype" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The relation is polynomial-time checkable. ", + "end_line": 36, + "is_class": false, + "kind": "theorem", + "line": 36, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.check_polyTime", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {P : (List Bool → List Bool → Bool) → Prop} {L : PCP.Language} (self : PCP.NPCertificate P L), P self.check", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "PCP.NPCertificate.check" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properLine.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ}\n (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1)\n (a_3 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n × PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_4 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)\n (a_5 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2 =\n PCP.Algebraic.ThreeColorVerifier.Query.properLine a_3 a_4 a_5) =\n (a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5)", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.encode.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c : ℕ),\n PCP.Algebraic.SetMultilinear.encode m c = PCP.Algebraic.SetMultilinear.encode m c", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Eq", + "LinearMap", + "CommSemiring.toSemiring", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "Polynomial", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Polynomial.module", + "Semiring.toModule", + "AddMonoidAlgebra.instModule", + "PCP.Algebraic.SetMultilinear.encode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 35, + "is_class": false, + "kind": "definition", + "line": 34, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {d : ℕ} →\n {accept : Bool} →\n {d' : ℕ} →\n {accept' : Bool} →\n d = d' → PCP.QueryTree.leaf accept ≍ PCP.QueryTree.leaf accept' → (d = d' → accept = accept' → P) → P", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "HEq", + "PCP.QueryTree", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [ + "Nat", + "Bool", + "Eq", + "HEq", + "PCP.QueryTree", + "PCP.QueryTree.leaf", + "id", + "PCP.QueryTree.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 42, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.smallError_pos", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (c : ℕ), 0 < PCP.Algebraic.GeneratorLowDegreeTest.smallError c", + "type_dependencies": [ + "Nat", + "LT.lt", + "Rat", + "Rat.instLT", + "OfNat.ofNat", + "Rat.instOfNat", + "PCP.Algebraic.GeneratorLowDegreeTest.smallError" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 45, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.recOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t) →\n ((color :\n PCP.Algebraic.ThreeColorVerifier.Vertex F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (validCert :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (difference :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3 → ZMod 2) →\n (properCert :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2) →\n (colorLines : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n) m c t) →\n (validLines differenceLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t) →\n (properLines :\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin (n + n) ⊕ Fin (n + n)) m c t) →\n motive\n { color := color, validCert := validCert, difference := difference, properCert := properCert,\n colorLines := colorLines, validLines := validLines, differenceLines := differenceLines,\n properLines := properLines }) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Fin", + "Sum", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorVerifier.Proof.mk", + "PCP.Algebraic.ThreeColorVerifier.Proof.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 36, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.query.noConfusion", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : Sort u} →\n {d addr : ℕ} →\n {onFalse onTrue : PCP.QueryTree d} →\n {d' addr' : ℕ} →\n {onFalse' onTrue' : PCP.QueryTree d'} →\n d + 1 = d' + 1 →\n PCP.QueryTree.query addr onFalse onTrue ≍ PCP.QueryTree.query addr' onFalse' onTrue' →\n (d = d' → addr = addr' → onFalse ≍ onFalse' → onTrue ≍ onTrue' → P) → P", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HEq", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "HEq", + "PCP.QueryTree.query", + "id", + "PCP.QueryTree.noConfusion" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The tester constructs a nearby field function and an actual formal line table,\nwith point-line rejection controlled by its own rejection. No smallness is needed here. ", + "end_line": 319, + "is_class": false, + "kind": "theorem", + "line": 243, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.exists_decoded_table", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (hr : 1 ≤ r) (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t),\n ∃ g T,\n PCP.Algebraic.relativeDistance (fun p => f p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction r fun x => ρ (g x)) ≤\n 28 * PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ∧\n (PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance hr f fun x =>\n ⇑(PCP.Algebraic.Hadamard.encode r (ρ (g x)))) ≤\n 28 * PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H ∧\n PCP.Algebraic.PointLineTest.rejectionRate g T ≤\n PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant c *\n PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate hr ρ nodes ζ f H", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Exists", + "PCP.Algebraic.PointLineTest.LineTable", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "And", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Rat.instMul", + "Rat.instOfNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "PCP.Algebraic.BinaryLagrangeConstraint.homogeneousDistance", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "PCP.Algebraic.PointLineTest.rejectionRate", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 114, + "is_class": false, + "kind": "theorem", + "line": 109, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.accProb_le_one", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (V : PCP.Verifier) (x : List Bool) (π : PCP.ProofOracle), V.accProb x π ≤ 1", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "PCP.ProofOracle", + "LE.le", + "Rat", + "Rat.instLE", + "PCP.Verifier.accProb", + "OfNat.ofNat", + "Rat.instOfNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The concrete reduction retains its exact language program for verifier composition. ", + "end_line": 241, + "is_class": false, + "kind": "theorem", + "line": 211, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.checker_program_reduction", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ),\n ∃ f p P C d,\n ∀ (x : List Bool),\n P.run (List.map Bool.toNat x) = List.map Bool.toNat (f x) ∧\n P.cost (List.map Bool.toNat x) ≤ C * (x.length + 1) ^ d ∧\n ((PCP.Algebraic.ThreeColorEncoding.graph (f x)).Colorable 3 ↔\n ∃ w, w.length ≤ Polynomial.eval x.length q ∧ R x w = true) ∧\n (f x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "Exists", + "PCP.Lang.Prog", + "And", + "Eq", + "PCP.Lang.Prog.run", + "List.map", + "Bool.toNat", + "LE.le", + "instLENat", + "PCP.Lang.Prog.cost", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "List.length", + "OfNat.ofNat", + "instOfNatNat", + "Iff", + "SimpleGraph.Colorable", + "Fin", + "PCP.Algebraic.ThreeColorEncoding.vertexCount", + "PCP.Algebraic.ThreeColorEncoding.graph", + "Polynomial.eval", + "Bool.true" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 25, + "is_class": false, + "kind": "definition", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : PCP.Machine.Sym → Sort u} →\n (t : PCP.Machine.Sym) → ((b : Bool) → motive (PCP.Machine.Sym.bit b)) → motive PCP.Machine.Sym.sep → motive t", + "type_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep" + ], + "value_dependencies": [ + "PCP.Machine.Sym", + "Bool", + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym.rec" + ] + }, + { + "axioms": [], + "doc": "Encoding of an argument triple: input, random string, answers so far. ", + "end_line": 39, + "is_class": false, + "kind": "definition", + "line": 37, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeTriple", + "provenance": "lean", + "structural_dependencies": [], + "type": "List Bool × List Bool × List Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "Prod", + "List", + "Bool", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Prod", + "List", + "Bool", + "HAppend.hAppend", + "PCP.Machine.Sym", + "instHAppendOfAppend", + "List.instAppend", + "PCP.Machine.ofBits", + "Prod.fst", + "List.cons", + "PCP.Machine.Sym.sep", + "Prod.snd" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Substitution by the vanishing polynomials multiplies degree by at most `|H|`. ", + "end_line": 149, + "is_class": false, + "kind": "theorem", + "line": 141, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.totalDegree_substitute_coordinate_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [IsDomain R] [Finite σ] (H : Finset R),\n H.Nonempty →\n ∀ (M : MvPolynomial (σ ⊕ σ) R),\n ((PCP.Algebraic.GridVanishing.substitute (PCP.Algebraic.GridVanishing.coordinate H)) M).totalDegree ≤\n M.totalDegree * H.card", + "type_dependencies": [ + "CommRing", + "IsDomain", + "CommSemiring.toSemiring", + "CommRing.toCommSemiring", + "Finite", + "Finset", + "Finset.Nonempty", + "MvPolynomial", + "Sum", + "LE.le", + "Nat", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "PCP.Algebraic.GridVanishing.coordinate", + "HMul.hMul", + "instHMul", + "instMulNat", + "Finset.card" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The computed encoded graph has polynomial bit length. ", + "end_line": 151, + "is_class": false, + "kind": "theorem", + "line": 145, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.length_encode_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : List Bool → List Bool → Bool} (h : PCP.Machine.NPTableau.Checker R) (q : Polynomial ℕ)\n [inst : DecidableEq h.tm.Λ] [inst_1 : DecidableEq h.tm.σ]\n [inst_2 : (k : h.tm.K) → DecidableEq (PCP.Machine.ComputationTableau.Symbol h.tm k)]\n (hs : PCP.Machine.StackSupported h.tm (Turing.haltList h.tm (PCP.Machine.NPTableau.output h true)).stk) {k a : ℕ}\n (eK : h.tm.K ≃ Fin k) (eA : PCP.Machine.TableauConstraints.Alphabet h.tm ≃ Fin a),\n ∃ p, ∀ (x : List Bool), (PCP.Reduction.NPThreeColorRuntime.encode h q hs eK eA x).length ≤ Polynomial.eval x.length p", + "type_dependencies": [ + "List", + "Bool", + "PCP.Machine.NPTableau.Checker", + "Polynomial", + "Nat", + "Nat.instSemiring", + "DecidableEq", + "Turing.FinTM2.Λ", + "Turing.TM2ComputableAux.tm", + "PCP.Machine.Sym", + "Turing.TM2ComputableInPolyTime.toTM2ComputableAux", + "Prod", + "PCP.Machine.encodePair", + "PCP.Machine.encodeBool", + "Prod.fst", + "Prod.snd", + "Turing.FinTM2.σ", + "Turing.FinTM2.K", + "PCP.Machine.ComputationTableau.Symbol", + "PCP.Machine.StackSupported", + "Turing.TM2.Cfg.stk", + "Turing.FinTM2.Γ", + "Turing.haltList", + "PCP.Machine.NPTableau.output", + "Bool.true", + "Equiv", + "Fin", + "PCP.Machine.TableauConstraints.Alphabet", + "Exists", + "LE.le", + "instLENat", + "List.length", + "PCP.Reduction.NPThreeColorRuntime.encode", + "Polynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": 31, + "is_class": false, + "kind": "theorem", + "line": 30, + "module": "PCP.Complexity.CostModel", + "name": "PCP.length_bitsOfFin", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ) (r : Fin (2 ^ k)), (PCP.bitsOfFin k r).length = k", + "type_dependencies": [ + "Nat", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "List.length", + "Bool", + "PCP.bitsOfFin" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Soundness at `x` with error `s`: every proof is accepted with probability at most `s`. ", + "end_line": 134, + "is_class": false, + "kind": "definition", + "line": 133, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.SoundAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Verifier → List Bool → ℚ → Prop", + "type_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Rat" + ], + "value_dependencies": [ + "PCP.Verifier", + "List", + "Bool", + "Rat", + "PCP.ProofOracle", + "LE.le", + "Rat.instLE", + "PCP.Verifier.accProb" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 383, + "is_class": false, + "kind": "definition", + "line": 383, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.instFintypeTestSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n [inst : Field F] →\n {m c t : ℕ} →\n [Fintype F] → [DecidableEq F] → {k r : ℕ} → Fintype (PCP.Algebraic.DerivedZeroOnGrid.TestSample F k m c t r)", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "instFintypeProd", + "Fin", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Pi.instFintype", + "instDecidableEqFin", + "Fin.fintype", + "PCP.Algebraic.ThreeColorVerifier.instFintypeGridRandomness", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "ZMod.fintype", + "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_7" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "recursor", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.rec", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) →\n motive d onFalse → motive d onTrue → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n {a : ℕ} → (t : PCP.QueryTree a) → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate.congr_simp", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n {inst_3 : DecidableEq F} [inst_4 : DecidableEq F] [inst_5 : Fintype σ] {inst_6 : DecidableEq σ}\n [inst_7 : DecidableEq σ] (ρ ρ_1 : F ≃ₗ[ZMod 2] Fin t → ZMod 2),\n ρ = ρ_1 →\n ∀ (nodes nodes_1 : Fin (c + 1) → F),\n nodes = nodes_1 →\n ∀ (ζ ζ_1 : F),\n ζ = ζ_1 →\n ∀ (f f_1 : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2),\n f = f_1 →\n ∀ (H H_1 : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t),\n H = H_1 →\n ∀ (a a_1 : σ → F),\n a = a_1 →\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a =\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ_1 nodes_1 ζ_1 f_1 H_1 a_1", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Eq", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 143, + "is_class": false, + "kind": "definition", + "line": 143, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n [Fintype F] → [Fintype σ] → [DecidableEq σ] → Fintype (PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r)", + "type_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "DecidableEq", + "inferInstance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "instFintypeProd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 136, + "is_class": false, + "kind": "definition", + "line": 123, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n {motive : PCP.Algebraic.ThreeColorVerifier.Query F n m c t → Sort u} →\n (t_1 : PCP.Algebraic.ThreeColorVerifier.Query F n m c t) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.color a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.difference a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1)) →\n ((a : PCP.Algebraic.ThreeColorVerifier.Vertex F n × PCP.Algebraic.ThreeColorVerifier.Vertex F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.colorLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.validLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.differenceLine a a_1 a_2)) →\n ((a :\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n ×\n PCP.Algebraic.ThreeColorVerifier.ProperPoint F n) →\n (a_1 : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (a_2 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (PCP.Algebraic.ThreeColorVerifier.Query.properLine a a_1 a_2)) →\n motive t_1", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Vertex", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query.color", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.validCert", + "PCP.Algebraic.ThreeColorVerifier.Query.difference", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.ThreeColorVerifier.Query.colorLine", + "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "PCP.Algebraic.ThreeColorVerifier.Query.properLine", + "PCP.Algebraic.ThreeColorVerifier.Query.rec" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.leaf.inj", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {d : ℕ} {accept accept_1 : Bool}, PCP.QueryTree.leaf accept = PCP.QueryTree.leaf accept_1 → accept = accept_1", + "type_dependencies": [ + "Nat", + "Bool", + "Eq", + "PCP.QueryTree", + "PCP.QueryTree.leaf" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.properGridQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n m c t : ℕ} →\n (motive : PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3 → Sort u_2) →\n (x : PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3) →\n ((x : Fin (n + n) → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((fst : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F (n + n)) →\n (x : Fin (n + n) ⊕ Fin (n + n) → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) → motive (Sum.inr (fst, Sum.inl (x, q)))) →\n ((a : PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F (n + n)) →\n (b : Fin (n + n) ⊕ Fin (n + n) → F) →\n (x : PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) →\n motive (Sum.inr (a, Sum.inr (b, x, q)))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Fin", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryLocalCorrection.Query", + "Sum", + "Prod.mk", + "Sum.inr", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.nodes_injective._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [inst : Fintype F],\n 2 * c < Fintype.card F → ∀ ⦃i : Fin (c + 1)⦄, 1 < Fintype.card F → ¬↑i < Fintype.card F - 1 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "Fin.val", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.NP", + "name": "PCP.NPCertificate.ctorIdx", + "provenance": "lean", + "structural_dependencies": [], + "type": "{P : (List Bool → List Bool → Bool) → Prop} → {L : PCP.Language} → PCP.NPCertificate P L → ℕ", + "type_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate", + "Nat" + ], + "value_dependencies": [ + "List", + "Bool", + "PCP.Language", + "PCP.NPCertificate" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 90, + "is_class": false, + "kind": "theorem", + "line": 88, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.cubeRoot_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (k : ℕ), IsPrimitiveRoot (PCP.Algebraic.ThreeColorFields.cubeRoot k) 3", + "type_dependencies": [ + "Nat", + "IsPrimitiveRoot", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "CommRing.toCommMonoid", + "Field.toCommRing", + "PCP.Algebraic.BinaryMaterializedField.instField", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.extensionDegreeNeZero", + "PCP.Algebraic.ThreeColorFields.cubeRoot" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Read one indexed primary or auxiliary bit. ", + "end_line": 84, + "is_class": false, + "kind": "definition", + "line": 80, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.read", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n {m c t r : ℕ} →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Query F σ m c t r → ZMod 2", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Query", + "PCP.Algebraic.EncodedLineLowDegreeTest.read.match_1", + "Prod", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 242, + "is_class": false, + "kind": "theorem", + "line": 225, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.exists_polynomial", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {c : ℕ} [inst_1 : Fintype F] {ζ : F} [Finite σ],\n 2 * c < Fintype.card F →\n IsPrimitiveRoot ζ (Fintype.card F - 1) →\n ∀ (f : (σ → F) → F),\n (∀ (u v : σ → F), f u = PCP.Algebraic.GeneratorLowDegreeTest.correct c ζ f u v) →\n ∃ P, P.totalDegree ≤ c ∧ ∀ (x : σ → F), (MvPolynomial.eval x) P = f x", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Finite", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Fintype.card", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.correct", + "Exists", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "And", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "DFunLike.coe", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "MvPolynomial.eval" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.ctorElimType", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} → ℕ → Sort (max 1 u)", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "cond", + "Nat.ble", + "PULift", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Actual normalized rejection over the complete finite seed. ", + "end_line": 149, + "is_class": false, + "kind": "definition", + "line": 145, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t r : ℕ} →\n [Fintype F] →\n [Fintype σ] →\n [DecidableEq σ] →\n 1 ≤ r →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n (Fin (c + 1) → F) →\n F →\n ((σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2) →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t → ℚ", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Rat" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample", + "instDecidableEqBool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "Bool.true" + ] + }, + { + "axioms": [], + "doc": "One step of an adaptive verifier algorithm.\n\n`alg x r as` is given the input `x`, the random string `r` as a bit list, and the answer bits\nreceived so far (oldest first). It returns either `.inl b`, halting with decision `b`, or\n`.inr a`, naming the next proof address to query.\n\nThis is the algorithmic counterpart of `QueryTree`: a decision tree is what the algorithm *does*,\nthis is the algorithm itself, and a cost model measures the latter. ", + "end_line": 24, + "is_class": false, + "kind": "definition", + "line": 16, + "module": "PCP.Complexity.CostModel", + "name": "PCP.VerifierAlg", + "provenance": "lean", + "structural_dependencies": [], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [ + "List", + "Bool", + "Sum", + "Nat" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 165, + "is_class": false, + "kind": "theorem", + "line": 163, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.binaryDimension_eq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), PCP.Algebraic.ThreeColorFields.binaryDimension M = 4 * max 1 (Nat.clog 16 M)", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Algebraic.ThreeColorFields.binaryDimension", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "Max.max", + "Nat.instMax", + "Nat.clog" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 132, + "is_class": false, + "kind": "constructor", + "line": 131, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.validLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The selected field, with all the same roots and coordinate constructions. ", + "end_line": 123, + "is_class": false, + "kind": "definition", + "line": 122, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.Chosen", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Type", + "type_dependencies": [ + "Nat" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorFields.FieldFamily", + "PCP.Algebraic.ThreeColorFields.index" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true._proof_1_3", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n m c : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H)),\n 5 * ((H.card - 1) * n) < m ^ c →\n ∀ (P : MvPolynomial (Fin n) F) (MVal : MvPolynomial (Fin n ⊕ Fin n) F)\n (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n MVal.totalDegree ≤ 3 * ((H.card - 1) * n) → ¬MVal.totalDegree < m ^ c → False", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Reduction.NPThreeColorRuntime", + "name": "PCP.Reduction.NPThreeColorRuntime.costPoly._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "(1 + 1).AtLeastTwo", + "type_dependencies": [ + "Nat.AtLeastTwo", + "HAdd.hAdd", + "Nat", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 47, + "is_class": false, + "kind": "theorem", + "line": 45, + "module": "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "name": "PCP.Algebraic.ThreeColorAmplifiedVerifier.readsBelow", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (x : List Bool),\n PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier.ReadsBelow x\n (Polynomial.eval x.length PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound)", + "type_dependencies": [ + "List", + "Bool", + "PCP.Verifier.ReadsBelow", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier", + "Polynomial.eval", + "Nat", + "Nat.instSemiring", + "List.length", + "PCP.Algebraic.ThreeColorCanonicalVerifier.proofBound" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 34, + "is_class": false, + "kind": "theorem", + "line": 33, + "module": "PCP.Algebraic.GridVanishing", + "name": "PCP.Algebraic.GridVanishing.coordinate_empty", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (i : σ), PCP.Algebraic.GridVanishing.coordinate ∅ i = 1", + "type_dependencies": [ + "CommRing", + "Eq", + "MvPolynomial", + "CommRing.toCommSemiring", + "PCP.Algebraic.GridVanishing.coordinate", + "EmptyCollection.emptyCollection", + "Finset", + "Finset.instEmptyCollection", + "OfNat.ofNat", + "One.toOfNat1", + "AddMonoidAlgebra.zero", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instZero" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 469, + "is_class": false, + "kind": "theorem", + "line": 460, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_five", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 5 =\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ\n (fun x => PCP.Algebraic.HadamardDerivedOracle.weightedCubic (PCP.Algebraic.ThreeColorVerifier.edgeValue H G x)) ⋯\n nodes ζ H (PCP.Algebraic.ThreeColorVerifier.flatDifference π) π.properCert\n (PCP.Algebraic.ThreeColorVerifier.properAuxiliary π)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.weightedCubic", + "Field.toCommRing", + "PCP.Algebraic.ThreeColorVerifier.edgeValue", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_weightedCubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.casesOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} →\n (t : PCP.QueryTree a) →\n ({d : ℕ} → (accept : Bool) → motive d (PCP.QueryTree.leaf accept)) →\n ({d : ℕ} →\n (addr : ℕ) →\n (onFalse onTrue : PCP.QueryTree d) → motive (d + 1) (PCP.QueryTree.query addr onFalse onTrue)) →\n motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "Bool", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "PCP.QueryTree.rec" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 458, + "is_class": false, + "kind": "theorem", + "line": 450, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate_four", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F) (H : Finset F)\n (G : SimpleGraph (Fin n → ↥H)) (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t),\n PCP.Algebraic.ThreeColorVerifier.branchRejectionRate ρ nodes ζ H G π 4 =\n PCP.Algebraic.DerivedZeroOnGrid.rejectionRate ρ (fun x => PCP.Algebraic.HadamardDerivedOracle.cubic) ⋯ nodes ζ H\n π.color π.validCert (PCP.Algebraic.ThreeColorVerifier.validAuxiliary π)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "SimpleGraph", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "Eq", + "Rat", + "PCP.Algebraic.ThreeColorVerifier.branchRejectionRate", + "Fin.instOfNat", + "Nat.instNeZeroSucc", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate", + "PCP.Algebraic.HadamardDerivedOracle.cubic", + "Field.toCommRing", + "PCP.Algebraic.HadamardDerivedOracle.natDegree_cubic_le", + "IsLocalRing.toNontrivial", + "Field.instIsLocalRing", + "PCP.Algebraic.ThreeColorVerifier.Proof.color", + "PCP.Algebraic.ThreeColorVerifier.Proof.validCert", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym.sep.sizeOf_spec", + "provenance": "lean", + "structural_dependencies": [], + "type": "sizeOf PCP.Machine.Sym.sep = 1", + "type_dependencies": [ + "Eq", + "Nat", + "SizeOf.sizeOf", + "PCP.Machine.Sym", + "PCP.Machine.Sym._sizeOf_inst", + "PCP.Machine.Sym.sep", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "definition", + "line": 44, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.differenceLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Sum", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": "Both chosen dimension and inner base are bounded by the parameter volume. ", + "end_line": 86, + "is_class": false, + "kind": "theorem", + "line": 84, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.size_le_volume", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n PCP.Algebraic.ThreeColorParameters.size (PCP.Algebraic.ThreeColorParameterChoice.exponent N) ≤\n PCP.Algebraic.ThreeColorParameterChoice.volume N", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "PCP.Algebraic.ThreeColorParameters.size", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "PCP.Algebraic.ThreeColorParameterChoice.volume" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.decodedAt.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ}\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (Q : (σ → F) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F)\n (parameter : Fˣ → F) (s : PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t),\n PCP.Algebraic.BinaryLocalCorrection.decodedAt ρ Q parameter s =\n (PCP.Algebraic.Hadamard.linearEncode\n (ρ (Polynomial.eval (parameter s.2.1) ((PCP.Algebraic.SetMultilinear.decode m c) (Q s.1)))))\n s.2.2.1.2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Eq", + "PCP.Algebraic.BinaryLocalCorrection.decodedAt", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.instInhabitedSym.default", + "provenance": "lean", + "structural_dependencies": [], + "type": "PCP.Machine.Sym", + "type_dependencies": [ + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "PCP.Machine.Sym.bit", + "Inhabited.default", + "Bool", + "instInhabitedBool" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.test.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t r : ℕ} (hr : 1 ≤ r)\n (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) (nodes : Fin (c + 1) → F) (ζ : F)\n (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t r → ZMod 2)\n (H : PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F σ m c t)\n (s : PCP.Algebraic.EncodedLineLowDegreeTest.Sample F σ m c t r),\n PCP.Algebraic.EncodedLineLowDegreeTest.test hr ρ nodes ζ f H s =\n (PCP.Algebraic.Hadamard.test hr (f s.1.1) s.2.2.2.1 &&\n PCP.Algebraic.BinaryLowDegreeTest.test PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1 ρ nodes (H s.1)\n s.2.2.2.2 &&\n decide\n (PCP.Algebraic.EncodedLineLowDegreeTest.corrected ρ ζ H s =\n f (PCP.Algebraic.PolynomialLine.point s.1.1 s.1.2 s.2.1)\n ((PCP.Algebraic.Hadamard.homogeneousIndex hr) s.2.2.1.2)))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LE.le", + "instLENat", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample", + "Eq", + "Bool", + "PCP.Algebraic.EncodedLineLowDegreeTest.test", + "Bool.and", + "PCP.Algebraic.Hadamard.test", + "Prod.fst", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "PCP.Algebraic.BinaryLowDegreeTest.test", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.EncodedLineLowDegreeTest.test._proof_1", + "Decidable.decide", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected", + "PCP.Algebraic.PolynomialLine.point", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.homogeneousIndex", + "ZMod.decidableEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryZeroOnGridSoundness", + "name": "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {m c t : ℕ} {σ : Type u_2},\n PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv =\n { toFun := fun s => (s.2.1, s.2.2.1, (s.2.2.2.1, s.1), s.2.2.2.2),\n invFun := fun s => (s.2.2.1.2, s.1, s.2.1, s.2.2.1.1, s.2.2.2), left_inv := ⋯, right_inv := ⋯ }", + "type_dependencies": [ + "Field", + "Nat", + "Eq", + "Equiv", + "Prod", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CallSeed", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv", + "Equiv.mk", + "Prod.mk", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_1", + "PCP.Algebraic.BinaryZeroOnGridCorrection.callSampleEquiv._proof_2" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 89, + "is_class": false, + "kind": "theorem", + "line": 69, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "_private.PCP.Algebraic.BinaryLocalCorrectionSoundness.0.PCP.Algebraic.BinaryLocalCorrection.distance_sample_comparison", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] {m c t : ℕ} [inst_1 : Fintype F] [inst_2 : DecidableEq F]\n [inst_3 : Fintype σ] [inst_4 : DecidableEq σ] {A : Type u_3} [inst_5 : DecidableEq A]\n (k l : (σ → F) × Fˣ → (Fin t → ZMod 2) → A),\n (PCP.Algebraic.relativeDistance (fun s => k (s.1, s.2.1) s.2.2.1.2) fun s => l (s.1, s.2.1) s.2.2.1.2) =\n PCP.Algebraic.relativeDistance (fun p => k p.1 p.2) fun p => l p.1 p.2", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "DecidableEq", + "Prod", + "Units", + "Semiring.toMonoid", + "CommSemiring.toSemiring", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Fin", + "ZMod", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "Rat", + "PCP.Algebraic.relativeDistance", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "instFintypeProd", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Prod.mk", + "Prod.fst", + "Prod.snd" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 250, + "is_class": false, + "kind": "theorem", + "line": 244, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "_private.PCP.Algebraic.ThreeColorVerifier.0.PCP.Algebraic.ThreeColorVerifier.read_properGridQuery", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {n m c t : ℕ} (π : PCP.Algebraic.ThreeColorVerifier.Proof F n m c t)\n (q : PCP.Algebraic.DerivedZeroOnGrid.Query F (n + n) m c t 3),\n PCP.Algebraic.ThreeColorVerifier.read π (PCP.Algebraic.ThreeColorVerifier.properGridQuery q) =\n PCP.Algebraic.DerivedZeroOnGrid.read (PCP.Algebraic.ThreeColorVerifier.flatDifference π) π.properCert\n (PCP.Algebraic.ThreeColorVerifier.properAuxiliary π) q", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.DerivedZeroOnGrid.Query", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "ZMod", + "PCP.Algebraic.ThreeColorVerifier.read", + "PCP.Algebraic.ThreeColorVerifier.properGridQuery", + "PCP.Algebraic.DerivedZeroOnGrid.read", + "PCP.Algebraic.ThreeColorVerifier.flatDifference", + "PCP.Algebraic.ThreeColorVerifier.Proof.properCert", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 134, + "is_class": false, + "kind": "constructor", + "line": 133, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.differenceLine", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.PairPoint F n × PCP.Algebraic.ThreeColorVerifier.PairPoint F n →\n PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → PCP.Algebraic.ThreeColorVerifier.Query F n m c t", + "type_dependencies": [ + "Nat", + "Prod", + "PCP.Algebraic.ThreeColorVerifier.PairPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.ThreeColorVerifier.Query" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "A supplied anchor table is exactly the paper's generator table. ", + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 35, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → [Field F] → {c : ℕ} → [Fintype F] → (Fin (c + 1) → F) → Prop", + "type_dependencies": [ + "Field", + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Field", + "Nat", + "Fintype", + "Fin", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "Exists", + "And", + "IsPrimitiveRoot", + "CommRing.toCommMonoid", + "Field.toCommRing", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fintype.card", + "Eq", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume_le_log_add_one._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ), ¬max 8 (Nat.clog 2 N) ≤ 8 * (Nat.clog 2 N + 1) → False", + "type_dependencies": [ + "Nat", + "Not", + "LE.le", + "instLENat", + "Max.max", + "Nat.instMax", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Per-branch query budgets in the same order as `BranchSeed`. ", + "end_line": 320, + "is_class": false, + "kind": "definition", + "line": 318, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchQueryBound", + "provenance": "lean", + "structural_dependencies": [], + "type": "ℕ → Fin 7 → ℕ", + "type_dependencies": [ + "Nat", + "Fin", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [ + "Nat", + "Matrix.vecCons", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Matrix.vecEmpty" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Honest primary encodings identify the received grid check with its fixed honest counterpart. ", + "end_line": 145, + "is_class": false, + "kind": "theorem", + "line": 135, + "module": "PCP.Algebraic.DerivedZeroOnGridSoundness", + "name": "PCP.Algebraic.DerivedZeroOnGrid.check_encode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {n m c t r : ℕ} (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (Q : (Fin n → F) → Polynomial F) (hQ : ∀ (x : Fin n → F), (Q x).natDegree ≤ r) (nodes : Fin (c + 1) → F) (ζ : F)\n (H : Finset F) (f : (Fin n → F) → F)\n (M :\n PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint F n →\n PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (A : PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary F n m c t)\n (s : PCP.Algebraic.DerivedZeroOnGrid.TestSample F n m c t r),\n PCP.Algebraic.DerivedZeroOnGrid.check ρ Q hQ nodes ζ H (fun x => ⇑(PCP.Algebraic.Hadamard.encode r (ρ (f x)))) M A s =\n PCP.Algebraic.BinaryZeroOnGridCorrection.check ρ nodes ζ H\n (fun x => ⇑(PCP.Algebraic.Hadamard.encode 1 (ρ (Polynomial.eval (f x) (Q x))))) M A\n (PCP.Algebraic.DerivedZeroOnGrid.gridSeed s)", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "Polynomial", + "LE.le", + "instLENat", + "Polynomial.natDegree", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Finset", + "PCP.Algebraic.BinaryZeroOnGridCorrection.CertificatePoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryZeroOnGridCorrection.Auxiliary", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample", + "Semiring.toMonoid", + "Eq", + "Option", + "Prod", + "PCP.Algebraic.DerivedZeroOnGrid.check", + "DFunLike.coe", + "LinearMap", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.encode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "PCP.Algebraic.BinaryZeroOnGridCorrection.check", + "Polynomial.eval", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.eval._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : ℕ) →\n (x_1 : PCP.QueryTree x) →\n PCP.QueryTree.below (motive := fun x x_2 => PCP.ProofOracle → Bool) x_1 → PCP.ProofOracle → Bool", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Bool" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PCP.ProofOracle", + "Bool", + "PCP.QueryTree.eval.match_1", + "PCP.QueryTree.leaf", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "ite", + "Eq", + "Bool.true", + "instDecidableEqBool", + "PProd" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorFields", + "name": "PCP.Algebraic.ThreeColorFields.binaryDimension.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (M : ℕ), PCP.Algebraic.ThreeColorFields.binaryDimension M = 4 * (PCP.Algebraic.ThreeColorFields.index M + 1)", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Algebraic.ThreeColorFields.binaryDimension", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.ThreeColorFields.index" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "Full coefficient-oracle proximity suffices, with the factor two for homogeneous labels. ", + "end_line": 356, + "is_class": false, + "kind": "theorem", + "line": 333, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.failure_le_full_distance", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] [CharP F 2] [NeZero m],\n 2 * c < Fintype.card F →\n ∀ (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2) {nodes : Fin (c + 1) → F},\n PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes nodes →\n ∀ {ζ : F},\n PCP.Algebraic.StandardLocalCorrection.GoodNodes c ζ →\n ∀ {D : ℕ} (P : MvPolynomial σ F),\n P.totalDegree ≤ D →\n c * m ^ c ≤ D →\n ∀ (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) {δ : ℚ},\n PCP.Algebraic.relativeDistance (fun p => f p.1 p.2)\n (PCP.Algebraic.Hadamard.encodeFunction 1 fun x => ρ ((MvPolynomial.eval x) P)) ≤\n δ →\n ∀ (a : σ → F),\n (PCP.Algebraic.relativeDistance (PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a)\n fun s =>\n some ((PCP.Algebraic.Hadamard.linearEncode (ρ ((MvPolynomial.eval a) P))) s.2.2.1.2)) ≤\n PCP.Algebraic.BinaryLocalCorrection.soundnessConstant c *\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a +\n 2 * δ +\n ↑D / (2 * ↑(Fintype.card F - 1))", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "CharP", + "AddGroupWithOne.toAddMonoidWithOne", + "Ring.toAddGroupWithOne", + "DivisionRing.toRing", + "Field.toDivisionRing", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HMul.hMul", + "instHMul", + "instMulNat", + "Fintype.card", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes", + "PCP.Algebraic.StandardLocalCorrection.GoodNodes", + "MvPolynomial", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Rat", + "Rat.instLE", + "PCP.Algebraic.relativeDistance", + "Prod", + "instFintypeProd", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "Nat.instNeZeroSucc", + "ZMod.decidableEq", + "Prod.fst", + "Prod.snd", + "PCP.Algebraic.Hadamard.encodeFunction", + "DFunLike.coe", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "RingHom", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "MvPolynomial.eval", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "Option", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "Option.instDecidableEq", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.some", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "Rat.instAdd", + "Rat.instMul", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "Rat.instOfNat", + "HDiv.hDiv", + "instHDiv", + "Rat.instDiv", + "Nat.cast", + "Rat.instNatCast" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 141, + "is_class": false, + "kind": "definition", + "line": 141, + "module": "PCP.Algebraic.EncodedLineLowDegreeTest", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} → {m c t : ℕ} → [Fintype F] → Fintype (PCP.Algebraic.BinaryLocalCorrection.InnerSeed F m c t)", + "type_dependencies": [ + "Nat", + "Fintype", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed" + ], + "value_dependencies": [ + "Nat", + "Fintype", + "inferInstance", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "instFintypeProd", + "Bool", + "Prod", + "PCP.Algebraic.SetMultilinear.Variables", + "PCP.Algebraic.Hadamard.TestRandomness", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Fin", + "HSub.hSub", + "instHSub", + "instSubNat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Fin.val", + "Pi.instFintype", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "ZMod", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "instDecidableEqFin", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed._proof_1" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "theorem", + "line": 43, + "module": "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "name": "PCP.Algebraic.EncodedLineLowDegreeTest.instNonemptyInnerPoint", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [Field F] {m c : ℕ}, Nonempty (PCP.Algebraic.BinaryLocalCorrection.InnerPoint F m c)", + "type_dependencies": [ + "Field", + "Nat", + "Nonempty", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.differenceCheckQuery.match_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {n t : ℕ} →\n (motive : PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3 → Sort u_2) →\n (x : PCP.Algebraic.BinaryDifferenceConsistency.Query F (Fin n) t 3) →\n ((x : Fin n → F) → (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inl (x, q))) →\n ((x : Fin n ⊕ Fin n → F) →\n (q : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 3) → motive (Sum.inr (x, q))) →\n motive x", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "Sum", + "Prod.mk", + "Sum.inr" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.BinaryDifferenceConsistency.Query", + "Fin", + "OfNat.ofNat", + "instOfNatNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "Sum.inl", + "Prod", + "Sum", + "Prod.mk", + "Sum.inr", + "Sum.casesOn", + "Prod.casesOn" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 94, + "is_class": false, + "kind": "theorem", + "line": 91, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.certificate_isCertificate", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : Fintype σ] (H : Finset R) (p : MvPolynomial σ R)\n (Q : σ → MvPolynomial σ R),\n p = ∑ i, Q i * PCP.Algebraic.GridVanishing.coordinate H i →\n PCP.Algebraic.GridVanishing.IsCertificate H p (PCP.Algebraic.GridVanishing.certificate Q)", + "type_dependencies": [ + "CommRing", + "Fintype", + "Finset", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "Finset.sum", + "AddMonoidAlgebra.instAddCommMonoid", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finset.univ", + "HMul.hMul", + "instHMul", + "AddMonoidAlgebra.instMul", + "Finsupp.instAdd", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "PCP.Algebraic.GridVanishing.coordinate", + "PCP.Algebraic.GridVanishing.IsCertificate", + "PCP.Algebraic.GridVanishing.certificate" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": "Minimality is retained as a usable interface for every competing exponent. ", + "end_line": 39, + "is_class": false, + "kind": "theorem", + "line": 37, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.exponent_le", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {N a : ℕ}, 2 ≤ a → Nat.clog 2 N ≤ a * 2 ^ a → PCP.Algebraic.ThreeColorParameterChoice.exponent N ≤ a", + "type_dependencies": [ + "Nat", + "LE.le", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "Nat.clog", + "HMul.hMul", + "instHMul", + "instMulNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "PCP.Algebraic.ThreeColorParameterChoice.exponent" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Query.properCert.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_2} {n m c t : ℕ} (a : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_1 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1) (a_2 : PCP.Algebraic.ThreeColorVerifier.ProperPoint F n)\n (a_3 : PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1),\n (PCP.Algebraic.ThreeColorVerifier.Query.properCert a a_1 =\n PCP.Algebraic.ThreeColorVerifier.Query.properCert a_2 a_3) =\n (a = a_2 ∧ a_1 = a_3)", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "OfNat.ofNat", + "instOfNatNat", + "Eq", + "PCP.Algebraic.ThreeColorVerifier.Query", + "PCP.Algebraic.ThreeColorVerifier.Query.properCert", + "And" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.Verifier.mk.injEq", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (randomness : ℕ → ℕ) (queries : ℕ) (run : (x : List Bool) → Fin (2 ^ randomness x.length) → PCP.QueryTree queries)\n (randomness_1 : ℕ → ℕ) (queries_1 : ℕ)\n (run_1 : (x : List Bool) → Fin (2 ^ randomness_1 x.length) → PCP.QueryTree queries_1),\n ({ randomness := randomness, queries := queries, run := run } =\n { randomness := randomness_1, queries := queries_1, run := run_1 }) =\n (randomness = randomness_1 ∧ queries = queries_1 ∧ run ≍ run_1)", + "type_dependencies": [ + "Nat", + "List", + "Bool", + "Fin", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat", + "List.length", + "PCP.QueryTree", + "Eq", + "PCP.Verifier", + "PCP.Verifier.mk", + "And", + "HEq" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.GeneratorLowDegreeTest", + "name": "_private.PCP.Algebraic.GeneratorLowDegreeTest.0.PCP.Algebraic.GeneratorLowDegreeTest.zero_of_constraints._proof_1_2", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {c : ℕ} [Fintype F] (n : ℕ), 0 < n → n ≤ c + 1 → ¬n - 1 < c + 1 → False", + "type_dependencies": [ + "Nat", + "Fintype", + "LT.lt", + "instLTNat", + "OfNat.ofNat", + "instOfNatNat", + "LE.le", + "instLENat", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "Not", + "HSub.hSub", + "instHSub", + "instSubNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": 43, + "is_class": false, + "kind": "definition", + "line": 43, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.Proof.validLines", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_2} →\n {n m c t : ℕ} →\n PCP.Algebraic.ThreeColorVerifier.Proof F n m c t →\n PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary F (Fin n ⊕ Fin n) m c t", + "type_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof", + "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary", + "Sum", + "Fin" + ], + "value_dependencies": [ + "Nat", + "PCP.Algebraic.ThreeColorVerifier.Proof" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.rejectionRate.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} {σ : Type u_2} [inst : Field F] [inst_1 : Algebra (ZMod 2) F] {m c t : ℕ} [inst_2 : Fintype F]\n [inst_3 : DecidableEq F] [inst_4 : Fintype σ] [inst_5 : DecidableEq σ] (ρ : F ≃ₗ[ZMod 2] Fin t → ZMod 2)\n (nodes : Fin (c + 1) → F) (ζ : F) (f : (σ → F) → PCP.Algebraic.BinaryPolynomialSpace.Coefficients t 1 → ZMod 2)\n (H : (σ → F) → PCP.Algebraic.BinaryLocalCorrection.RowOracle F m c t) (a : σ → F),\n PCP.Algebraic.BinaryLocalCorrection.rejectionRate ρ nodes ζ f H a =\n PCP.Algebraic.AffineLineSampling.fraction fun s =>\n PCP.Algebraic.BinaryLocalCorrection.sample ρ nodes ζ f H a s = none", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "Fintype", + "DecidableEq", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "PCP.Algebraic.BinaryPolynomialSpace.Coefficients", + "PCP.Algebraic.BinaryLocalCorrection.RowOracle", + "Eq", + "Rat", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate", + "PCP.Algebraic.AffineLineSampling.fraction", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "Semiring.toMonoid", + "instFintypeProd", + "Prod", + "Units", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Pi.instFintype", + "instFintypeUnitsOfDecidableEq", + "PCP.Algebraic.SetMultilinear.Variables", + "instDecidableEqProd", + "instDecidableEqFin", + "Fin.fintype", + "ZMod.fintype", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_2", + "Bool", + "PCP.Algebraic.Hadamard.TestRandomness", + "PCP.Algebraic.BinaryLowDegreeTest.InterpolationRandomness", + "Bool.fintype", + "HSub.hSub", + "instHSub", + "instSubNat", + "Fin.val", + "PCP.Algebraic.BinaryPolynomialSpace.Monomials", + "Subtype.instDecidableEq", + "Finset", + "LE.le", + "instLENat", + "Finset.card", + "Finset.decidableEq", + "Subtype.fintype", + "Nat.decLe", + "Finset.fintype", + "Option", + "PCP.Algebraic.BinaryLocalCorrection.sample", + "Option.none" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": null, + "end_line": 37, + "is_class": false, + "kind": "definition", + "line": 30, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.brecOn", + "provenance": "lean", + "structural_dependencies": [], + "type": "{motive : (a : ℕ) → PCP.QueryTree a → Sort u} →\n {a : ℕ} → (t : PCP.QueryTree a) → ((a : ℕ) → (t : PCP.QueryTree a) → PCP.QueryTree.below t → motive a t) → motive a t", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "PProd", + "PCP.QueryTree.brecOn.go" + ] + }, + { + "axioms": [], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.noConfusionType", + "provenance": "lean", + "structural_dependencies": [], + "type": "Sort u → {a : ℕ} → PCP.QueryTree a → {a' : ℕ} → PCP.QueryTree a' → Sort u", + "type_dependencies": [ + "Nat", + "PCP.QueryTree" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.casesOn", + "Bool", + "Eq", + "HEq" + ] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 212, + "is_class": false, + "kind": "theorem", + "line": 205, + "module": "PCP.Algebraic.SetMultilinear", + "name": "PCP.Algebraic.SetMultilinear.decode_boundedEncode", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} [inst : CommSemiring R] (m : ℕ) [inst_1 : NeZero m] (c d : ℕ),\n d < m ^ c →\n ∀ (P : ↥(Polynomial.degreeLE R ↑d)),\n (PCP.Algebraic.SetMultilinear.decode m c) ((PCP.Algebraic.SetMultilinear.boundedEncode m c d) P) = ↑P", + "type_dependencies": [ + "CommSemiring", + "Nat", + "NeZero", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "LT.lt", + "instLTNat", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "Subtype", + "Polynomial", + "CommSemiring.toSemiring", + "Membership.mem", + "Submodule", + "Semiring.toAddCommMonoid", + "Polynomial.semiring", + "Polynomial.module", + "Semiring.toModule", + "SetLike.instMembership", + "Submodule.setLike", + "Polynomial.degreeLE", + "Nat.cast", + "WithBot", + "WithBot.instNatCast", + "instNatCastNat", + "Eq", + "DFunLike.coe", + "RingHom", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Semiring.toNonAssocSemiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode", + "LinearMap", + "RingHom.id", + "Submodule.addCommMonoid", + "AddMonoidAlgebra.instAddCommMonoid", + "Submodule.module", + "AddMonoidAlgebra.instModule", + "LinearMap.instFunLike", + "PCP.Algebraic.SetMultilinear.boundedEncode", + "Subtype.val" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": "The corresponding true bit in a chosen decoded polynomial row. ", + "end_line": 118, + "is_class": false, + "kind": "definition", + "line": 114, + "module": "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "name": "PCP.Algebraic.BinaryLocalCorrection.decodedAt", + "provenance": "lean", + "structural_dependencies": [], + "type": "{F : Type u_1} →\n {σ : Type u_2} →\n [inst : Field F] →\n [inst_1 : Algebra (ZMod 2) F] →\n {m c t : ℕ} →\n (F ≃ₗ[ZMod 2] Fin t → ZMod 2) →\n ((σ → F) → MvPolynomial (PCP.Algebraic.SetMultilinear.Variables m c) F) →\n (Fˣ → F) → PCP.Algebraic.BinaryLocalCorrection.Sample F σ m c t → ZMod 2", + "type_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "RingHomInvPair.ids", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample" + ], + "value_dependencies": [ + "Field", + "Algebra", + "ZMod", + "OfNat.ofNat", + "Nat", + "instOfNatNat", + "Semifield.toCommSemiring", + "Field.toSemifield", + "ZMod.instField", + "Nat.fact_prime_two", + "CommSemiring.toSemiring", + "LinearEquiv", + "RingHom.id", + "Semiring.toNonAssocSemiring", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate._proof_1", + "Fin", + "Semiring.toAddCommMonoid", + "Pi.addCommMonoid", + "Algebra.toModule", + "Pi.Function.module", + "Semiring.toModule", + "MvPolynomial", + "PCP.Algebraic.SetMultilinear.Variables", + "Units", + "Semiring.toMonoid", + "PCP.Algebraic.BinaryLocalCorrection.Sample", + "DFunLike.coe", + "LinearMap", + "LinearMap.instFunLike", + "PCP.Algebraic.Hadamard.linearEncode", + "EquivLike.toFunLike", + "DFinsupp.instEquivLikeLinearEquiv", + "Polynomial.eval", + "Prod.fst", + "Prod", + "PCP.Algebraic.BinaryLocalCorrection.InnerPoint", + "PCP.Algebraic.BinaryLocalCorrection.InnerSeed", + "Prod.snd", + "RingHom", + "Polynomial", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "Polynomial.semiring", + "RingHom.instFunLike", + "PCP.Algebraic.SetMultilinear.decode" + ] + }, + { + "axioms": [ + "propext" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorParameterChoice", + "name": "PCP.Algebraic.ThreeColorParameterChoice.volume.eq_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ (N : ℕ),\n PCP.Algebraic.ThreeColorParameterChoice.volume N =\n PCP.Algebraic.ThreeColorParameterChoice.exponent N * 2 ^ PCP.Algebraic.ThreeColorParameterChoice.exponent N", + "type_dependencies": [ + "Nat", + "Eq", + "PCP.Algebraic.ThreeColorParameterChoice.volume", + "HMul.hMul", + "instHMul", + "instMulNat", + "PCP.Algebraic.ThreeColorParameterChoice.exponent", + "HPow.hPow", + "instHPow", + "NPow.toPow", + "Monoid.toNPow", + "Nat.instMonoid", + "OfNat.ofNat", + "instOfNatNat" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifierCompleteness", + "name": "PCP.Algebraic.ThreeColorVerifier.exists_proof_test_eq_true._proof_1_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {F : Type u_1} [inst : Field F] {n : ℕ} {m c : ℕ} (H : Finset F) (G : SimpleGraph (Fin n → ↥H))\n (P : MvPolynomial (Fin n) F) (MVal : MvPolynomial (Fin n ⊕ Fin n) F)\n (MProp : MvPolynomial (Fin (n + n) ⊕ Fin (n + n)) F),\n MProp.totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.properPolynomial (PCP.Algebraic.ThreeColorGrid.edgeExtension H G)\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P)).totalDegree ≤\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree +\n 3 * (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree →\n (PCP.Algebraic.ThreeColorGrid.edgeExtension H G).totalDegree ≤ 2 * ((H.card - 1) * n) →\n (PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial P).totalDegree ≤ (H.card - 1) * n →\n ¬MProp.totalDegree ≤ 5 * ((H.card - 1) * n) → False", + "type_dependencies": [ + "Field", + "Nat", + "Finset", + "SimpleGraph", + "Fin", + "Subtype", + "Membership.mem", + "SetLike.instMembership", + "Finset.instSetLike", + "MvPolynomial", + "Semifield.toCommSemiring", + "Field.toSemifield", + "Sum", + "CommRing.toCommSemiring", + "Field.toCommRing", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "LE.le", + "instLENat", + "MvPolynomial.totalDegree", + "PCP.Algebraic.ThreeColorGrid.properPolynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension", + "Fin.fintype", + "instDecidableEqFin", + "Classical.propDecidable", + "Eq", + "PCP.Algebraic.BinaryDifferenceConsistency.differencePolynomial", + "HMul.hMul", + "instHMul", + "instMulNat", + "OfNat.ofNat", + "instOfNatNat", + "HSub.hSub", + "instHSub", + "instSubNat", + "Finset.card", + "Preorder.toLE", + "Nat.instPreorder", + "Not", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "definition", + "line": null, + "module": "PCP.Verifier.Definition", + "name": "PCP.QueryTree.addresses._f", + "provenance": "lean", + "structural_dependencies": [], + "type": "(x : ℕ) → (x_1 : PCP.QueryTree x) → PCP.QueryTree.below x_1 → Finset ℕ", + "type_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "Finset" + ], + "value_dependencies": [ + "Nat", + "PCP.QueryTree", + "PCP.QueryTree.below", + "Finset", + "PCP.QueryTree.addresses.match_1", + "Bool", + "PCP.QueryTree.leaf", + "EmptyCollection.emptyCollection", + "Finset.instEmptyCollection", + "HAdd.hAdd", + "instHAdd", + "instAddNat", + "OfNat.ofNat", + "instOfNatNat", + "PCP.QueryTree.query", + "Insert.insert", + "Finset.instInsert", + "instDecidableEqNat", + "Union.union", + "Finset.instUnion", + "PProd" + ] + }, + { + "axioms": [], + "doc": "Encoding of a Boolean result. ", + "end_line": 48, + "is_class": false, + "kind": "definition", + "line": 47, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.encodeBool", + "provenance": "lean", + "structural_dependencies": [], + "type": "Bool → List PCP.Machine.Sym", + "type_dependencies": [ + "Bool", + "List", + "PCP.Machine.Sym" + ], + "value_dependencies": [ + "Bool", + "List.cons", + "PCP.Machine.Sym", + "PCP.Machine.Sym.bit", + "List.nil" + ] + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "doc": null, + "end_line": null, + "is_class": false, + "kind": "theorem", + "line": null, + "module": "PCP.Algebraic.ThreeColorVerifier", + "name": "PCP.Algebraic.ThreeColorVerifier.branchTest._proof_1", + "provenance": "lean", + "structural_dependencies": [], + "type": "¬1 ≤ 3 → False", + "type_dependencies": [ + "Not", + "LE.le", + "Nat", + "instLENat", + "OfNat.ofNat", + "instOfNatNat", + "False" + ], + "value_dependencies": [] + }, + { + "axioms": [], + "doc": "The tape alphabet: a bit, or a separator between arguments.\n\nA separator is needed because the machine takes one input list, while our relations and algorithms\ntake two or three bit strings. Self-delimiting encodings would avoid it at the cost of a length\nprefix; a separator symbol is the simpler convention and is fixed here once. ", + "end_line": 25, + "is_class": false, + "kind": "inductive", + "line": 17, + "module": "PCP.Complexity.Machine", + "name": "PCP.Machine.Sym", + "provenance": "lean", + "structural_dependencies": [ + "PCP.Machine.Sym.bit", + "PCP.Machine.Sym.sep", + "PCP.Machine.Sym" + ], + "type": "Type", + "type_dependencies": [], + "value_dependencies": [] + }, + { + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "doc": null, + "end_line": 44, + "is_class": false, + "kind": "theorem", + "line": 42, + "module": "PCP.Algebraic.VanishingCertificate", + "name": "PCP.Algebraic.GridVanishing.substitute_X_inr", + "provenance": "lean", + "structural_dependencies": [], + "type": "∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (Y : σ → MvPolynomial σ R) (i : σ),\n (PCP.Algebraic.GridVanishing.substitute Y) (MvPolynomial.X (Sum.inr i)) = Y i", + "type_dependencies": [ + "CommRing", + "MvPolynomial", + "CommRing.toCommSemiring", + "Eq", + "DFunLike.coe", + "RingHom", + "Sum", + "AddMonoidAlgebra.nonAssocSemiring", + "Finsupp", + "Nat", + "MulZeroClass.toZero", + "Nat.instMulZeroClass", + "CommSemiring.toSemiring", + "Finsupp.instAddZeroClass", + "AddMonoid.toAddZeroClass", + "Nat.instAddMonoid", + "RingHom.instFunLike", + "PCP.Algebraic.GridVanishing.substitute", + "MvPolynomial.X", + "Sum.inr" + ], + "value_dependencies": [] + } + ], + "lean_version": "4.35.0-rc2", + "modules": [ + "PCP.Algebraic.BinaryLocalCorrectionSoundness", + "PCP.Algebraic.BinaryLocalRowDecoding", + "PCP.Algebraic.BinaryZeroOnGridSoundness", + "PCP.Algebraic.DerivedZeroOnGridSoundness", + "PCP.Algebraic.EncodedLineLowDegreeSoundness", + "PCP.Algebraic.EncodedLineLowDegreeTest", + "PCP.Algebraic.GeneratorLowDegreeTest", + "PCP.Algebraic.GridVanishing", + "PCP.Algebraic.PointLineSoundness", + "PCP.Algebraic.SetMultilinear", + "PCP.Algebraic.ThreeColorAmplifiedVerifier", + "PCP.Algebraic.ThreeColorFields", + "PCP.Algebraic.ThreeColorGrid", + "PCP.Algebraic.ThreeColorParameterChoice", + "PCP.Algebraic.ThreeColorVerifier", + "PCP.Algebraic.ThreeColorVerifierCompleteness", + "PCP.Algebraic.VanishingCertificate", + "PCP.Complexity.CostModel", + "PCP.Complexity.Machine", + "PCP.Complexity.NP", + "PCP.Complexity.ReferenceNPConverse", + "PCP.Complexity.ThreeColorRuntime", + "PCP.Reduction.NPThreeColorRuntime", + "PCP.ReverseConcrete", + "PCP.Theorem", + "PCP.Verifier.Definition" + ], + "provenance": { + "kind": "lean", + "text": "Read by Lean 4.35.0-rc2 from the authors' compiled modules." + } } diff --git a/papers/pcp-specialist/links.json b/papers/pcp-specialist/links.json index d37f5cd..3ee70bf 100644 --- a/papers/pcp-specialist/links.json +++ b/papers/pcp-specialist/links.json @@ -392,7 +392,54 @@ "PCP.Algebraic.EncodedLineLowDegreeTest.Auxiliary": "Encoded line-table type", "PCP.Algebraic.ThreeColorVerifier.Proof": "The eight proof tables", "PCP.Algebraic.ThreeColorVerifier.Query": "Eight physical query tags", - "PCP.Algebraic.ThreeColorVerifier.read": "Read a tagged proof bit" + "PCP.Algebraic.ThreeColorVerifier.read": "Read a tagged proof bit", + "PCP.Algebraic.BinaryLocalCorrection.soundnessConstant": "Loss constant of local correction", + "PCP.Algebraic.BinaryLocalCorrection.rejectionRate": "Rejection rate of local correction", + "PCP.Algebraic.BinaryLocalRowDecoding.decodingConstant": "Inner decoding constant", + "PCP.Algebraic.DerivedZeroOnGrid.GridRandomness": "ZERO randomness apart from the point", + "PCP.Algebraic.DerivedZeroOnGrid.TestSample": "Randomness of the derived ZERO test", + "PCP.Algebraic.DerivedZeroOnGrid.gridSeed": "Drop the fresh correction seed", + "PCP.Algebraic.DerivedZeroOnGrid.withPrimaryBit": "ZERO test given its primary bit", + "PCP.Algebraic.DerivedZeroOnGrid.check": "The derived ZERO check", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerPoint": "Finitely many inner points (ZERO)", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeInnerSeed": "Finitely many inner seeds (ZERO)", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeCallSeedSumFin": "Finitely many call seeds (ZERO)", + "PCP.Algebraic.DerivedZeroOnGrid.instFintypeGridRandomness": "Finitely many grid seeds (ZERO)", + "PCP.Algebraic.DerivedZeroOnGrid.rejectionRate": "Rejection rate of the derived ZERO test", + "PCP.Algebraic.EncodedLineLowDegreeTest.lineErrorConstant": "Line error factor of the line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.soundnessConstant": "Proximity factor of the line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.Lines": "Lines as point and direction", + "PCP.Algebraic.EncodedLineLowDegreeTest.Sample": "Randomness of the encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.corrected": "Corrected comparison bit", + "PCP.Algebraic.EncodedLineLowDegreeTest.test": "The encoded-line test", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerPoint": "Finitely many inner points (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeInnerSeed": "Finitely many inner seeds (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeProdTestRandomnessInnerSeed": "Finitely many seed pairs (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.instFintypeSample": "Finitely many samples (line test)", + "PCP.Algebraic.EncodedLineLowDegreeTest.rejectionRate": "Rejection rate of the encoded-line test", + "PCP.Algebraic.GeneratorLowDegreeTest.nodes": "Powers of the generator as nodes", + "PCP.Algebraic.GeneratorLowDegreeTest.weights": "Lagrange weights at zero", + "PCP.Algebraic.GeneratorLowDegreeTest.IsGeneratorNodes": "Nodes from a primitive root", + "PCP.Algebraic.GeneratorLowDegreeTest.rejectionRate": "Inner weighted test rejection rate", + "PCP.Algebraic.GridVanishing.VanishesOn": "Vanishing on the grid", + "PCP.Algebraic.SetMultilinear.Variables": "Variables of the digit encoding", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.repetitions": "Fixed repetition count", + "PCP.Algebraic.ThreeColorAmplifiedVerifier.verifier": "The amplified verifier", + "PCP.Algebraic.ThreeColorGrid.validPolynomial": "Vertex constraint polynomial", + "PCP.Algebraic.ThreeColorGrid.properPolynomial": "Edge constraint polynomial", + "PCP.Algebraic.ThreeColorGrid.edgeExtension": "Low-degree extension of the edges", + "PCP.Algebraic.ThreeColorVerifier.Vertex": "Points for one vertex", + "PCP.Algebraic.ThreeColorVerifier.PairPoint": "Points for a pair of vertices", + "PCP.Algebraic.ThreeColorVerifier.ProperPoint": "Points for the edge certificate", + "PCP.Algebraic.ThreeColorVerifier.flatten": "Flattening two vertex blocks", + "PCP.Algebraic.ThreeColorVerifier.edgeValue": "Adjacency extension at a point", + "PCP.Algebraic.ThreeColorVerifier.flatDifference": "Difference table on flat coordinates", + "PCP.Algebraic.ThreeColorVerifier.validAuxiliary": "Line tables for the vertex certificate", + "PCP.Algebraic.ThreeColorVerifier.properAuxiliary": "Line tables for the edge certificate", + "PCP.Algebraic.ThreeColorVerifier.BranchSeed": "Seven branch seed types", + "PCP.Algebraic.ThreeColorVerifier.Sample": "Randomness of the graph verifier", + "PCP.Algebraic.ThreeColorVerifier.branchTest": "Seven concrete branch tests", + "PCP.Algebraic.ThreeColorVerifier.test": "Conjunction of the seven checks" }, "fidelity_held": "The selected source has not yet been compared against elaborated Lean statements for this page." } diff --git a/papers/pcp-specialist/paper.toml b/papers/pcp-specialist/paper.toml index 4822864..d047ed0 100644 --- a/papers/pcp-specialist/paper.toml +++ b/papers/pcp-specialist/paper.toml @@ -16,7 +16,7 @@ source = "https://github.com/troyjlee/tcs-formalizations/tree/a0ce13ed0fa264f051 source_name = "tcs-formalizations at a0ce13e" source_lines = "https://github.com/troyjlee/tcs-formalizations/blob/a0ce13ed0fa264f051c1278e039596ce65557fa4/{path}#L{line}-L{end}" licence = "Apache-2.0" -scope = "Selected source excerpts appear alongside retained Lean statements and the extracted reading-guide interface. Each declaration shows its source status. Proof dependencies and axiom reports are available only for records with the relevant extraction." +scope = "Lean 4.35.0-rc2 compiled the listed modules of the authors' project, and each declaration's statement, dependencies and axioms shown here are Lean's own report from those compiled modules. The links from the paper's sentences to the Lean, the plain titles and the notes were made with AI and have not been reviewed by the authors." [reading] language = "lean" diff --git a/tests/journey.py b/tests/journey.py index c7f28b0..9122bab 100644 --- a/tests/journey.py +++ b/tests/journey.py @@ -1361,8 +1361,8 @@ def at_heading() -> bool: page.goto(f"{full}/@declarations", wait_until="load") made = page.get_by_role("heading", name="How this page was made").locator("..").inner_text() - check("compiled only the statement" in made and "did not build" in made and "were read from source" in made, - "the index names the scope of retained compilation and source-read evidence") + check("Lean’s own output from modules compiled" in made and "were read from source" not in made, + "the index says the declaration data is Lean's output from compiled modules") check("Proofs whose Lean reports list no axioms" not in page.locator(".index").inner_text(), "this mixed edition does not present unextracted proofs as free of axioms") table = page.locator(".index table").bounding_box()