diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..65dab5b --- /dev/null +++ b/.gitattributes @@ -0,0 +1,19 @@ +# Normalize text files to LF in the repository. +* text=auto eol=lf + +# Keep the repository's source and data formats explicitly textual. +*.md text +*.py text +*.json text +*.jsonl text +*.yml text +*.yaml text +*.sh text +*.txt text + +# These files are intended for direct viewing, not diffing as source. +*.png binary +*.jpg binary +*.jpeg binary +*.gif binary +*.pdf binary diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..5f54dc9 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,72 @@ +name: Repository +on: + pull_request: + push: + branches: [main, 'dev*', 'dev**/**', 'release*', 'release**/**', 'codex/**'] + workflow_dispatch: +permissions: + contents: read +concurrency: + group: repository-${{ github.ref }} + cancel-in-progress: true +jobs: + verify: + name: Repository / verify + runs-on: ubuntu-24.04 + timeout-minutes: 30 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + path: product + persist-credentials: false + submodules: false + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 + with: + node-version: '22.23.2' + - name: Read fixed shared-tool source + id: tooling + working-directory: product + run: | + node --input-type=module -e 'import fs from "node:fs"; const t=JSON.parse(fs.readFileSync("release/tooling.json")); for(const k of ["workspace","core"]) if(t[k]) {if(!/^[a-f0-9]{40}$/.test(t[k].commit)) throw Error("Unpinned tools"); fs.appendFileSync(process.env.GITHUB_OUTPUT, k+"="+t[k].commit+"\n");}' + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + repository: shendeguize/AgentOrganon + ref: ${{ steps.tooling.outputs.workspace }} + path: tools + persist-credentials: false + - name: Install pinned Lean toolchain in temporary runner storage + env: + ELAN_HOME: ${{ runner.temp }}/organon-elan + run: | + mkdir -p "$RUNNER_TEMP/organon-elan-bootstrap" + curl --proto '=https' --tlsv1.2 --fail --location https://github.com/leanprover/elan/releases/download/v4.2.4/elan-x86_64-unknown-linux-gnu.tar.gz --output "$RUNNER_TEMP/organon-elan-bootstrap/elan.tar.gz" + echo "42b94d4244e8353142c456ec0e4ca6528fd898a6c604d4059f494e706e431f63 $RUNNER_TEMP/organon-elan-bootstrap/elan.tar.gz" | sha256sum --check --strict + tar -xzf "$RUNNER_TEMP/organon-elan-bootstrap/elan.tar.gz" -C "$RUNNER_TEMP/organon-elan-bootstrap" + "$RUNNER_TEMP/organon-elan-bootstrap/elan-init" -y --no-modify-path --default-toolchain leanprover/lean4:v4.33.1 + "$ELAN_HOME/bin/elan" toolchain install leanprover/lean4:v4.33.1 + echo "ELAN_HOME=$ELAN_HOME" >> "$GITHUB_ENV" + echo "$ELAN_HOME/bin" >> "$GITHUB_PATH" + - name: Source tests and human-document links + working-directory: product + env: + ORGANON_WORKSPACE_ROOT: ${{ github.workspace }}/tools + ORGANON_CORE_ROOT: ${{ github.workspace }}/product + run: | + npm test + npm run check:content + - name: Install locked site build dependencies + working-directory: product/tools/site + run: npm ci --ignore-scripts + - name: Build and validate released-site paths + working-directory: product + env: + ORGANON_CORE_ROOT: ${{ github.workspace }}/product + run: npm run check:site + - name: Check current Lean evidence and four reader editions + run: node product/skills/organon-core-leanify-prove/scripts/check.js product/lean/philosophy --manuscript manuscript.json + - name: Keep development site preview + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 + with: + name: development-site-OrganonCore-${{ github.run_attempt }} + path: product/dist/site/ + if-no-files-found: error diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml new file mode 100644 index 0000000..59fea0e --- /dev/null +++ b/.github/workflows/pages.yml @@ -0,0 +1,77 @@ +name: Verified release Pages +on: + workflow_dispatch: + inputs: + version: + description: Published product version + required: true + type: string + manifest_sha256: + description: Canonical digest of the fully published release manifest + required: true + type: string +permissions: {} +concurrency: + group: site-data-${{ github.repository }} + cancel-in-progress: false +jobs: + prepare: + if: github.repository == 'shendeguize/OrganonCore' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/release/1.0.0') + runs-on: ubuntu-24.04 + timeout-minutes: 45 + permissions: + contents: write + outputs: + deploy: ${{ steps.state.outputs.deploy }} + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 + with: + node-version: '22.23.2' + - name: Read fixed workspace tooling + id: tooling + run: | + node --input-type=module - <<'NODE' + import fs from 'node:fs'; + const tooling = JSON.parse(fs.readFileSync('release/tooling.json', 'utf8')); + if (tooling.schema_version !== 1 || tooling.workspace?.repository !== 'shendeguize/AgentOrganon' || !/^[a-f0-9]{40}$/.test(tooling.workspace.commit)) throw new Error('Invalid fixed workspace tooling'); + fs.appendFileSync(process.env.GITHUB_OUTPUT, `commit=${tooling.workspace.commit}\n`); + NODE + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + repository: shendeguize/AgentOrganon + ref: ${{ steps.tooling.outputs.commit }} + path: .tooling/workspace + persist-credentials: false + - name: Verify all channels and build fixed released sources + id: state + env: + GITHUB_TOKEN: ${{ github.token }} + GH_TOKEN: ${{ github.token }} + GOVERNANCE_AUDIT_TOKEN: ${{ secrets.GOVERNANCE_AUDIT_TOKEN }} + RELEASE_VERSION: ${{ inputs.version }} + MANIFEST_SHA256: ${{ inputs.manifest_sha256 }} + run: node .tooling/workspace/scripts/release/site-data.mjs pages --version "$RELEASE_VERSION" --manifest-sha256 "$MANIFEST_SHA256" + - uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa + if: steps.state.outputs.deploy == 'true' + with: + name: github-pages-${{ github.run_attempt }} + path: ${{ steps.state.outputs.public_dir }} + deploy: + needs: prepare + if: needs.prepare.outputs.deploy == 'true' + runs-on: ubuntu-24.04 + timeout-minutes: 10 + permissions: + pages: write + id-token: write + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e + id: deployment + with: + artifact_name: github-pages-${{ github.run_attempt }} diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..e86472f --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,90 @@ +name: Publish verified product +on: + workflow_dispatch: + inputs: + version: + description: Exact validated product version + required: true + manifest_sha256: + description: Canonical sealed manifest digest + required: true + operation: + description: Controlled publication step + required: true + type: choice + options: [publish, promote] + bootstrap_npm: + description: Use the short-lived first-publication credential + type: boolean + default: false +permissions: + contents: read +concurrency: + group: publish-${{ inputs.version }} + cancel-in-progress: false +jobs: + publish: + if: github.ref == 'refs/heads/release/1.0.0' + environment: ${{ startsWith(inputs.version, '1.0.0-rc.') && 'npm-rc' || 'npm-stable' }} + runs-on: ubuntu-24.04 + permissions: + contents: write + actions: read + id-token: write + env: + RELEASE_VERSION: ${{ inputs.version }} + RELEASE_MANIFEST_SHA256: ${{ inputs.manifest_sha256 }} + APPROVED_RC_MANIFEST_SHA256: ${{ vars.APPROVED_RC_MANIFEST_SHA256 }} + NPM_CHANNEL_STRATEGY: ${{ vars.NPM_CHANNEL_STRATEGY }} + RELEASE_OPERATION: ${{ inputs.operation }} + GH_TOKEN: ${{ github.token }} + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + ref: ${{ github.sha }} + path: product + persist-credentials: false + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 + with: + node-version: '22.23.2' + registry-url: https://registry.npmjs.org + - name: Read fixed release tooling + id: tooling + working-directory: product + run: | + node --input-type=module -e 'import fs from "node:fs"; const t=JSON.parse(fs.readFileSync("release/tooling.json")); if(t.workspace.repository!=="shendeguize/AgentOrganon" || !/^[a-f0-9]{40}$/.test(t.workspace.commit)) throw Error("Unpinned tools"); fs.appendFileSync(process.env.GITHUB_OUTPUT,"workspace="+t.workspace.commit+"\n")' + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + repository: shendeguize/AgentOrganon + ref: ${{ steps.tooling.outputs.workspace }} + path: tools + persist-credentials: false + - name: Install exact npm with OIDC support in the temporary runner + run: npm install --global npm@12.0.2 --ignore-scripts + - name: Fetch exact public validated bundle + + run: node tools/scripts/release/publish.mjs fetch --version "$RELEASE_VERSION" --manifest-sha256 "$RELEASE_MANIFEST_SHA256" --out candidate + - name: Verify identity and every gate before credentials are exposed + run: | + node tools/scripts/release/manifest.mjs check --manifest candidate/release-manifest.json + node --input-type=module -e 'import {readJSON} from "./tools/scripts/release/lib.mjs"; import {assertDispatch} from "./tools/scripts/release/manifest.mjs"; assertDispatch(readJSON("candidate/release-manifest.json"),process.env,"core")' + - name: Verify approved RC to stable source transition + if: inputs.version == '1.0.0' + run: node tools/scripts/release/stable.mjs --manifest candidate/release-manifest.json + - name: First npm publication with short-lived bootstrap credential + if: inputs.operation == 'publish' && inputs.bootstrap_npm + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_BOOTSTRAP_TOKEN }} + GOVERNANCE_AUDIT_TOKEN: ${{ secrets.GOVERNANCE_AUDIT_TOKEN }} + run: node tools/scripts/release/publish.mjs publish --manifest candidate/release-manifest.json --product core + - name: OIDC publication or verified bundle operation + if: inputs.operation != 'promote' && !(inputs.operation == 'publish' && inputs.bootstrap_npm) + env: + GOVERNANCE_AUDIT_TOKEN: ${{ secrets.GOVERNANCE_AUDIT_TOKEN }} + run: node tools/scripts/release/publish.mjs "$RELEASE_OPERATION" --manifest candidate/release-manifest.json --product core + - name: Complete channel recommendation only after all three products match + if: inputs.operation == 'promote' + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TAG_TOKEN }} + GOVERNANCE_AUDIT_TOKEN: ${{ secrets.GOVERNANCE_AUDIT_TOKEN }} + run: node tools/scripts/release/publish.mjs promote --manifest candidate/release-manifest.json --product core diff --git a/.github/workflows/stars.yml b/.github/workflows/stars.yml new file mode 100644 index 0000000..a8b0b4d --- /dev/null +++ b/.github/workflows/stars.yml @@ -0,0 +1,67 @@ +name: Observed stars +on: + workflow_dispatch: + schedule: + - cron: '17 2 * * *' +permissions: {} +concurrency: + group: site-data-${{ github.repository }} + cancel-in-progress: false +jobs: + prepare: + if: github.repository == 'shendeguize/OrganonCore' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/release/1.0.0') + runs-on: ubuntu-24.04 + timeout-minutes: 45 + permissions: + contents: write + outputs: + deploy: ${{ steps.state.outputs.deploy }} + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 + with: + node-version: '22.23.2' + - name: Read fixed workspace tooling + id: tooling + run: | + node --input-type=module - <<'NODE' + import fs from 'node:fs'; + const tooling = JSON.parse(fs.readFileSync('release/tooling.json', 'utf8')); + if (tooling.schema_version !== 1 || tooling.workspace?.repository !== 'shendeguize/AgentOrganon' || !/^[a-f0-9]{40}$/.test(tooling.workspace.commit)) throw new Error('Invalid fixed workspace tooling'); + fs.appendFileSync(process.env.GITHUB_OUTPUT, `commit=${tooling.workspace.commit}\n`); + NODE + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + repository: shendeguize/AgentOrganon + ref: ${{ steps.tooling.outputs.commit }} + path: .tooling/workspace + persist-credentials: false + - name: Sample actual total and retain released HTML + id: state + env: + GITHUB_TOKEN: ${{ github.token }} + GH_TOKEN: ${{ github.token }} + run: node .tooling/workspace/scripts/release/site-data.mjs stars + - uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa + if: steps.state.outputs.deploy == 'true' + with: + name: github-pages-${{ github.run_attempt }} + path: ${{ steps.state.outputs.public_dir }} + deploy: + needs: prepare + if: needs.prepare.outputs.deploy == 'true' + runs-on: ubuntu-24.04 + timeout-minutes: 10 + permissions: + pages: write + id-token: write + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e + id: deployment + with: + artifact_name: github-pages-${{ github.run_attempt }} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..30bdd14 --- /dev/null +++ b/.gitignore @@ -0,0 +1,46 @@ +# Local project state +.local/ + +# Python +__pycache__/ +*.py[cod] +*$py.class +.Python +*.so +.venv/ +venv/ +env/ +ENV/ +pip-wheel-metadata/ +*.egg-info/ +build/ +dist/ + +# Python tooling +.pytest_cache/ +.mypy_cache/ +.ruff_cache/ +.tox/ +.nox/ +.coverage +.coverage.* +htmlcov/ + +# Operating system +.DS_Store +.AppleDouble +.LSOverride + +# Editor and IDE +.idea/ +.vscode/ + +# .local + + +node_modules/ + +*.log + +# Lean compiler outputs +*.olean diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..2ab1507 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,54 @@ +# Working on Organon Core + +Read [PHILOSOPHY.md](PHILOSOPHY.md), including its meanings and limits, before assessing or changing this repository. It is the English authority. [Rationale](rationale/README.md) explains the philosophy without adding core obligations. Skills implement context-specific methods and may be revised. Product runtime tools have no third-party runtime dependencies. Site building and validation may use locked third-party dependencies, which are excluded from installation packages. + +For skills applied outside this repository, use [philosophy resolution](skills/references/philosophy-resolution.md) to retain the caller's selected adopted baseline; Core remains the baseline for maintaining this repository. The [document format](skills/references/structure.md) specifies version metadata and stable text-unit IDs as revisable interfaces, not additional philosophical commitments. + +For an input assessment, use [organon-core-assess](skills/organon-core-assess/SKILL.md). For philosophical absorption and its necessary synchronization, use [organon-core-absorb](skills/organon-core-absorb/SKILL.md). Read their shared [iteration rules](skills/references/iteration.md) for external grilling, independent-first cross-validation, authorization, records, and stopping. Delegated reviewers return findings instead of recursively requesting review. + +Use [organon-core-principled-review](skills/organon-core-principled-review/SKILL.md) for full analysis when its stated trigger conditions apply. It owns the six-dimension method, including bounded review of its own output and criteria. Reuse findings with their standards and grounds; assess owns current philosophical compatibility judgments, while absorb owns philosophical adoption. Method findings do not automatically establish core conflicts, and principled review does not replace independent cross-validation. Routine narrow assessment and wording-only work retain their separate scope. + +The initiating agent owns independent skill and documentation maintenance under the shared iteration rules, combining the applicable review skills without treating that work as philosophical absorption. Those rules retain requirements, authorization, actual validation, wording, translation, independent review, and stopping checks. Use external grilling when explicitly requested or needed for material unresolved choices; its absence blocks only the dependent stage. + +For repository wording review, use [organon-core-wording-review](skills/organon-core-wording-review/SKILL.md). It checks wording quality only and is also used by `organon-core-absorb`. + +Keep changes precise and limited to their authorized scope. Preserve confirmed wording and meaning; a change to a philosophical commitment or its applicability requires the user's explicit decision, even if presented as an explanation. Existing authorization need not be requested again. + +For repository text you create or revise and for user-facing replies, use grammatically correct, precise, concise wording that is unambiguous in context. Use terms consistently and make referents, conditions, and scope clear. Remove repetition that adds no information, while retaining necessary qualifications. + +Define relevant [validation cases](skills/references/validation.md) before a method change and retain actual results and independent review locally. Update affected documents and links together. Do not represent file checks, agent agreement, or self-application as proof of philosophical correctness. + +Keep private inputs and iteration records under ignored `.local/`. The legacy archive is historical, not an active source of obligations. Preserve user configuration and original requirements. Core delivers philosophical text together with maintained Lean implementations, evidence, reader manuscripts and their checking tools. These tools do not acquire philosophical authority. Do not restore the retired legacy checker or release workflow as part of ordinary maintenance. + +For local records, start with `.local/ACTIVE.md`. Keep feedback records active. Exclude `.local/archived/` from default recursive searches and do not open archive packages by default. When the task explicitly requires historical material, consult `.local/archived/INDEX.md` and retrieve only the relevant packages or members, following their recorded dependencies and restoration conditions. Archived decisions are historical evidence, not active obligations; later corrections belong in separate records linked to the originals. + +## Lean evidence maintenance + +Use [organon-core-leanify-prove](skills/organon-core-leanify-prove/SKILL.md) for source-faithful formalization and [organon-core-lean-natural-language](skills/organon-core-lean-natural-language/SKILL.md) for code explanation and reader editions. [Lean delivery](lean/README.md) identifies current and historical run objects and the standalone checks. English philosophy remains authoritative; a mismatch is a correspondence finding, not permission to change a philosophical commitment. + +Before changing philosophy, rationale, source versions, encoded statements, assumptions, or tool/skill behavior that affects evidence, identify the affected source units, declarations, review objects and bilingual manuscripts. Preserve the preceding snapshots and judgments. Content hashes matter even without a version bump; a version number alone cannot establish currentness. Unrelated repository changes do not require fresh semantic review of every proof. + +Stable current-object paths do not identify immutable evidence. Before replacement, archive the previous reference closure under ignored `.local/`, including out-of-run reader files, and verify historical replay from a separate copy. The formal Lean delivery contains only current objects and their required evidence; its use and tests must not depend on local history. New execution receipts identify loaded tools and observed runtime versions; they do not establish tool approval. Record the impact of relevant method/tool changes and perform the affected checks without retroactively adding execution identities or new approval to historical records. + +Do not declare the affected maintenance complete until required builds, declaration/dependency audits, source-fidelity review and both manuscript granularities in English and Chinese have been synchronized and checked. Reuse unchanged proof or review material only with its exact objects verified and reuse disclosed. Changed source or interpretation needs a new reviewed object; do not merely refresh old expected hashes. Missing tools or independent review leave the dependent stage explicitly incomplete while unrelated work may continue. + +This completion condition requires accurate evidence and states, not complete formalization or successful proof of every claim. Preserve limited, failed, incomplete, inapplicable and stale results with their reasons. Separate historical replay from current-source approval. [Translation guidance](zh/AGENTS.md#lean-对照稿) preserves those distinctions in Chinese. Ordinary philosophical assessment does not require Lean. + +## Remote publication authorization + +- Remote publication includes `git push` (branches or tags), release publication, + PR merges, deployments, and uploads of project artifacts to remote destinations. +- An explicit user request or prior approval authorizes the stated action, + target, and scope. Reuse that authorization unless withdrawn or superseded; + do not ask again for the same work. +- General implementation requests, credentials, and tool availability do not + authorize publication. Approval to push does not by itself authorize a force + push, merge, deployment, or publication to another target. +- When authorization is missing, first complete authorized preparation and + relevant checks. Present the reviewable result, exact destination, scope, + action, and known consequential effects, then request confirmation once. + Explain that this rule requires authorization for the uncovered publication. +- Execute only the authorized scope. If the action, target, or scope materially + changes, obtain authorization for that change. Silence is not confirmation. +- Continue authorized preparation and read-only inspection while awaiting a + decision. This rule does not require confirmation for every remote interaction. diff --git a/PHILOSOPHY.md b/PHILOSOPHY.md new file mode 100644 index 0000000..db7027d --- /dev/null +++ b/PHILOSOPHY.md @@ -0,0 +1,153 @@ +--- +format_version: 0.1.0 +philosophy_version: 0.1.4 +core_version: 0.1.4 +derived_from: null +--- +# Organon Philosophy: Charter and Grounds + + +This is the authoritative statement of Organon’s philosophy. It expresses adopted commitments, not factual assertions about every system or a proof of universal correctness. + +The quoted provisions, their meanings, and their conditions of application form the core. The charter and Grounds constrain one another; their grouping establishes neither a deductive hierarchy nor an order of priority. [Rationale](rationale/README.md) supplies arguments and cases without adding obligations to this core. Skills are revisable applications under the repository’s stated objectives and constraints, not part of the philosophical commitments themselves. + +## 1. Charter + + +### 1.1 Overview + + +**Self-Transcendence · Internal Consistency · Reflexivity** + +> A system is intrinsically oriented toward expanding what it can understand and construct. It brings itself and its principles within the scope of generation and assessment, with internal consistency constraining this process. + +The overview connects three distinct requirements: self-transcendence establishes a generative orientation and refuses to treat existing forms as final, internal consistency constrains judgments held simultaneously, and reflexivity brings the system and its principles within the scope of their own generation and assessment. The provisions below specify the conditions for each. + +### 1.2 Self-Transcendence + + +> A system is intrinsically oriented toward expanding what it can understand and construct. It does not regard any existing form as the endpoint of generation. + +#### 1.2.1 Generative Orientation + + +A commitment to keeping generative possibilities open is distinct from valuing their expansion. A system has an intrinsic orientation when it regards that expansion as worth pursuing. Merely permitting change does not fully express this orientation. + +#### 1.2.2 Non-finality + + +Refusing to regard an existing form as an endpoint keeps it open to being surpassed. “Existing form” includes a system’s current organization, methods, and principles, not only its appearance or artifacts. These remain within the scope of possible change; their revisability does not guarantee actual progress. + +#### 1.2.3 Grounds for Achievement and Limits + + +Whether progress has actually occurred remains a separate judgment. Having the orientation does not guarantee progress. Progress cannot be established merely by an increase in the number of artifacts, levels of abstraction, or terms. + +- “Intrinsic orientation” expresses Organon’s philosophical commitment; it does not assert that all systems in fact develop autonomously. +- Self-transcendence does not imply independence from external experience, knowledge, or collaboration, nor does it guarantee autonomous execution or self-improvement. +- Refusing to regard an existing form as an endpoint does not require every action to produce change. Justified stability can coexist with a generative orientation. +- Whether transcendence expands what can be understood and constructed requires discernible grounds; a system’s own claim of generation does not establish actual achievement. + +### 1.3 Internal Consistency + + +> The principles and judgments a system holds simultaneously, together with their implications, must not yield contradictory judgments on the same question under the same assumptions, meanings of terms, and scope of application. + +#### 1.3.1 Meaning + + +“Held simultaneously” specifies which principles, judgments, and implications must hold together. Revision may withdraw an earlier judgment; old and new principles need not remain compatible forever. When a change has occurred, that change cannot be represented as though it had not occurred. + +“The same assumptions, meanings of terms, and scope of application” specifies the basis for comparing judgments. Divergent judgments under different conditions do not automatically constitute contradictions. Nor can unacknowledged changes in assumptions, meanings, or scope be used to conceal an existing contradiction. + +#### 1.3.2 Conditions and Limits + + +- Tension between different assessments or values does not directly constitute a contradiction. Revision or qualification is needed when they require incompatible conclusions under the same conditions. +- Internal consistency is not correctness or sufficiency. A set of principles may be internally consistent while relying on false assumptions or neglecting important questions. + +### 1.4 Reflexivity + + +> A system’s principles of generation and assessment also apply to the system itself and to the formation, application, and revision of those principles. + +#### 1.4.1 Meaning + + +Reflexivity encompasses both the system itself and its principles. Assessment concerns not only whether the system conforms to its principles, but also how those principles are formed, where they apply, and why they may need revision. The formation and revision of principles thus also become objects of generation and assessment. + +#### 1.4.2 Conditions and Limits + + +- Applying principles equally retains their conditions of application. When the relevant conditions hold, being the system itself is not a basis for exemption. Nor does the requirement of reflexivity establish that every principle can be applied to itself without examining its applicability. +- Self-application does not constitute self-proof. Subjecting a principle to its own assessment does not thereby establish its correctness. +- That a revision is produced by the system itself does not give it sufficient grounds. + +## 2. Grounds + + +> The grounds of principles and judgments must be articulable and subject to assessment appropriate to the nature of the claim. The strength and scope of a claim must be proportionate to the support provided by its grounds. + +### 2.1 Articulation and Responsibilities of Assessment + + +Articulation and assessment have distinct responsibilities. Articulability requires that concepts, assumptions, reasons, and limits can be identified. Assessment requires examining whether those grounds support the corresponding claim. Clearly expressed grounds are not thereby sufficiently established. When a claim has more than one applicable aspect, the corresponding assessment responsibilities apply to each aspect. Omitting a classification does not waive an applicable responsibility. + +| Type of claim | Responsibility of assessment | What cannot substitute for that responsibility | +| --- | --- | --- | +| Empirical claim | Examine observations, evidence, and performance, together with the conditions, scope, and uncertainty of their support for the claim. | Treating measurability or repeatability itself as proof of relevance, correctness, or value. | +| Inferential claim | Examine whether the conclusion is supported by the stated assumptions and inferential relations. | Treating the absence of conflict between a conclusion and its assumptions as sufficient to establish that the conclusion follows from them. | +| Value commitment | State the position taken, its reasons, limits of application, and consequences, and remain open to relevant criticism. | Presenting a commitment as an empirical fact or a necessary inference, or substituting self-assertion for reasons. | + +Initial value commitments may be stated explicitly as commitments; they need not prove all their own starting assumptions. The strength and scope of a claim do not require conversion to a common numerical scale. Different types of claims specify their support and limits in accordance with their nature. + +### 2.2 Relations, Scope, and the Limits of Measurement + + +Performance is discerned within particular relations, conditions, and scopes of observation. A boundary helps specify what a comparison concerns, but local examples do not automatically support unconditional universal conclusions. A judgment cannot establish that relevant differences do not exist merely because its chosen scope omits them. + +Measurement can make some differences comparable. Repeated assessment can help examine the stability of corresponding conclusions. Their roles, and the role of any assessment framework, must be explained relative to the claim and its context. Measurement, repeatability, and an assessment framework do not form a universally necessary chain on which all judgments must depend. + +An observation that has not been reproduced may still offer limited support, and random outcomes need not be identical on every occasion. The verifiability of observations, reproducibility of conditions, and stability of conclusions must be distinguished. + +### 2.3 Capability Claims + + +Capability claims are subject to Grounds: the capability claimed, its conditions, and the support for it must be identifiable. The core does not prescribe uniform definitions of method mastery, method generation, or capability levels. Applications specify the capabilities they assess and may require understanding, explanation, or performance under relevant variations. + +Grounds for a capability claim may be supplied by an external assessor. Their articulability does not by itself require the assessed system to understand or explain its internal generation process. Evidence of reliable output must be assessed against the capability actually claimed; it does not automatically establish understanding of that process. Nor can the number of method documents, terms, tools, or artifacts alone establish a capability beyond what that evidence supports. + +### 2.4 Implementation Choices: Openness to Alternatives + + +> The choice of an implementation must be supported by reasons connected to the objectives and values pursued and to the relevant constraints. Its name, conventional use, or established status alone does not provide sufficient grounds for giving it priority. + +This choice provision adds an additional evaluative commitment: name, conventional use, or established status alone is insufficient to establish priority. Grouping it under Grounds does not mean that it follows from the general requirement to assess reasons, or merely from the discernibility of performance. Conventions and existing arrangements may have practical significance, but that significance must be connected to the objectives and values pursued and to the relevant constraints. + +#### 2.4.1 Conditions and Limits + + +- Openness does not make all implementations equivalent, nor does it guarantee multiple feasible implementations for the same objective. +- A method’s explanatory power, limits of application, simplicity, and explicit process requirements may all provide grounded reasons for assessment. They cannot be excluded merely because they concern methods internal to the implementation. +- Identical local performance does not establish overall equivalence. Relations, conditions, and the scope of comparison are constrained by the provisions of Grounds. +- Openness does not reject an implementation merely because it already exists or is conventionally used. Relevant reasons may still give it priority. + +## 3. Relationships and Necessary Terms + + +### 3.1 Roles and Mutual Constraints + + +The charter states the generative orientation, the consistency constraint, and reflexive application. Grounds specifies support requirements for judgments and includes an additional commitment concerning implementation choices. Both parts belong to the core and constrain one another. Their placement neither makes Grounds a deduction from the charter nor gives the charter priority over it. Each commitment needs its own reasons. + +Internal Consistency concerns whether simultaneously held judgments can hold together; Grounds concerns whether and how far a claim is supported. A conclusion may fail to conflict with its assumptions without being supported by them. Self-Transcendence specifies a generative orientation and non-finality; neither establishes actual capability. Applications may supply objectives, values, and capability definitions; claims made under those objectives, values, and definitions remain subject to the relevant core provisions. + +Self-Transcendence does not substitute for Reflexivity: keeping existing forms open to being surpassed differs from applying relevant principles to the system and to their own formation, application, and revision. Reflexivity extends these requirements to the system and to the formation, application, and revision of its principles. The grounds and limits of the Grounds provisions must themselves be articulable. The system’s own capability claims remain subject to assessment, and this philosophy’s existing form cannot gain priority merely from its established status. Such mutual application provides no self-proof and does not remove conditions of application. + +### 3.2 Necessary Terms + + +| Term | Meaning in this philosophy | +| --- | --- | +| Existing form | The system’s current organization, methods, and principles, not only its appearance or artifacts. | +| Assessment | Examination of reasons, applicability, and observed performance; not limited to executable tests. | diff --git a/README.md b/README.md new file mode 100644 index 0000000..83aa41e --- /dev/null +++ b/README.md @@ -0,0 +1,58 @@ +![OrganonCore](assets/banner.svg) + +[English](README.md) · [简体中文](zh/README.md) · [Website](https://shendeguize.github.io/OrganonCore/) · [Releases](https://github.com/shendeguize/OrganonCore/releases) + +# OrganonCore + +The philosophy and its review methods. + +## Design Aim · Ground agent judgments and improvements + +Make commitments, reasons and boundaries readable, assessable and revisable. Organon supplies philosophy and methods; it does not promise correct judgments or automatic improvement. Philosophical adoption retains an explicit human decision. + +The philosophy adopts **Self-Transcendence, Internal Consistency and Reflexivity**, with **Grounds** constraining the support and scope of judgments. Its philosophical version is **0.1.4**; product version **1.0.0-rc.1** identifies the installation package and site edition. + +## Start here + +```sh +npx --yes @shendeguize/agent-organon@1.0.0-rc.1 install --product core --agent codex --scope project --project /path/to/workspace --version 1.0.0-rc.1 +``` + +Release candidate **1.0.0-rc.1** awaits review. Run this command once the public package is available; before publication use a local candidate archive. Requires Node.js 22+. Project and global installation are available; the release matrix records actual validation for the six agent adapters. + +[Complete quick start: install → check → select philosophy → read-only assessment](https://shendeguize.github.io/OrganonCore/quick-start) + +## Read and navigate + +| Entry | Content | +| --- | --- | +| [AgentOrganon](https://github.com/shendeguize/AgentOrganon) | Workspace skills and management of adopted copies. | +| [OrganonCore](https://github.com/shendeguize/OrganonCore) | Core philosophy, review methods and Lean evidence. | +| [AdvisedOrganons](https://github.com/shendeguize/AdvisedOrganons) | Domain philosophy collection; select a domain explicitly. | +| [Docs](https://shendeguize.github.io/OrganonCore/understand) | Concepts, operations and capability boundaries for readers. | +| [Philosophy](https://shendeguize.github.io/OrganonCore/philosophy) | Adopted commitments with their meanings and conditions. | +| [Lean](https://shendeguize.github.io/OrganonCore/lean) | Claim overviews and paired code with line explanations. | + +Release packages contain philosophy, non-Lean skills and required runtime files. Websites, tutorials, Lean projects and evidence remain in source. Rationale is separate from reader documentation and adds no philosophical obligations; maintenance protocols live in maintenance. + + +## Choose a method + +| Method | Purpose | +| --- | --- | +| `organon-core-assess` | Assess an input under the selected philosophy. | +| `organon-core-absorb` | Examine reasons for philosophical revision and carry out authorized adoption. | +| `organon-core-principled-review` | Analyze an object under the shared method’s stated standards. | +| `organon-core-wording-review` | Review wording without deciding philosophical adoption. | + +## Star history + +![Observed total stars for this repository](https://shendeguize.github.io/OrganonCore/assets/stars.svg) + +Daily observations begin when collection is enabled. Zero totals, unstars and missing samples are retained; the chart reports its update time. + +## Contribute + +Read the repository’s agent guidance and maintenance protocols before contributing. Mechanical checks, independent review and human adoption decisions have distinct responsibilities. + +MIT · [License](LICENSE) diff --git a/assets/banner.svg b/assets/banner.svg new file mode 100644 index 0000000..a9a0f64 --- /dev/null +++ b/assets/banner.svg @@ -0,0 +1 @@ +OrganonCore — OrganonGround agent judgments and improvements. Philosophy, methods and grounds.PHILOSOPHY · METHODS · GROUNDSOrganonCoreGround agent judgments and improvements.ORGANON / 1.0.0-rc.1 diff --git a/docs/getting-started.md b/docs/getting-started.md new file mode 100644 index 0000000..f25be39 --- /dev/null +++ b/docs/getting-started.md @@ -0,0 +1,47 @@ +# Quick start + +Use Node.js 22 or later and your chosen agent tool. These commands target the published candidate package; before publication, use the local candidate archive route below. + +## 1. Install the methods + +```sh +npx --yes @shendeguize/agent-organon@1.0.0-rc.1 install --product core --agent codex --scope project --project /path/to/workspace --version 1.0.0-rc.1 +``` + +Replace `/path/to/workspace` with your project path. Choose `codex`, `claude`, `cursor`, `copilot`, `gemini` or `opencode` for `--agent`. Start with project installation; use `--scope global` for global installation. Installing methods does not adopt a philosophy. + +## 2. Check installation and discovery + +```sh +npx --yes @shendeguize/agent-organon@1.0.0-rc.1 check --product core --agent codex --scope project --project /path/to/workspace +``` + +Open the agent in that project and confirm the method appears in its skill list or can be loaded explicitly. File checks establish installation integrity; actual tool support is recorded in the candidate’s validation matrix. Resolve reported project/global naming conflicts before continuing. + +## 3. Select a philosophy explicitly + +```sh +npx --yes @shendeguize/agent-organon@1.0.0-rc.1 init --product core --agent codex --scope project --project /path/to/workspace --philosophy core +``` + +Read the preview, confirm the destination and philosophical text, then repeat the command with `--apply --plan-sha256 ` using the exact `planSha256` value in that preview. A changed philosophy or instruction file requires a new preview and decision. An existing philosophy must not be silently replaced; the collection root does not select a domain. Method installation and project adoption are managed separately. + +## 4. Complete a read-only assessment + +Give the agent the actual material you want assessed and ask: + +> Use `organon-core-assess` with this project’s explicitly selected `PHILOSOPHY.md` as the adopted baseline. Assess the material’s grounds, applicability and possible conflicts. Return a read-only report; do not edit files or adopt a proposal. + +Check that the report identifies its baseline, reasons and limits. An assessment does not authorize philosophical revision; missing independent review must remain explicitly incomplete. + +## Offline archives and lifecycle commands + +Download and extract the archive from the corresponding GitHub Release. Every product includes `installer/organon.mjs`, which Node can run directly; only the AgentOrganon npm package registers the `organon` command. + +```sh +node /path/to/extracted/package/installer/organon.mjs install --product core --agent codex --scope project --project /path/to/workspace --from /path/to/shendeguize-organon-core-1.0.0-rc.1.tgz +``` + +The same entrypoint provides `update`, `rollback` and `uninstall`. Check integrity before updating; user modifications or existing-file conflicts stop an update. Uninstall retains user modifications and the adopted project philosophy. + +[Understand the concepts and boundaries](https://shendeguize.github.io/OrganonCore/understand) · [GitHub Releases](https://github.com/shendeguize/OrganonCore/releases) diff --git a/docs/understanding.md b/docs/understanding.md new file mode 100644 index 0000000..5385794 --- /dev/null +++ b/docs/understanding.md @@ -0,0 +1,37 @@ +# Understand Organon + +## Start with three distinct objects + +**Philosophy** states adopted commitments, their meanings and conditions of application. **Skills** apply methods to tasks and remain revisable. **Tools** check and transform files; they do not decide philosophical correctness or reasons for adoption. + +## How an assessment starts + +Identify the actual input and adopted philosophy, then state the question to assess. Examine reasons, conditions and scope; distinguish contradiction from insufficient support. When considering a revision, keep the preceding baseline identifiable. Compatibility does not warrant adoption, and conflict does not by itself defeat reasons for revision. + +## When change is needed + +An ordinary assessment can end with a report. Absorption examines reasons for philosophical revision and implements it after explicit authorization. Wording review concerns expression; file management checks structure and identity. These methods have different responsibilities and do not replace one another’s judgments. + +## A map of the reading material + +- [Philosophy](https://shendeguize.github.io/OrganonCore/philosophy): commitments, meanings and limits. +- [Rationale](https://shendeguize.github.io/OrganonCore/rationale): arguments, alternatives and objections; no additional philosophical obligations. +- [Lean reader](https://shendeguize.github.io/OrganonCore/lean): begin with claims, premises and boundaries, then inspect declarations and line explanations. +- Maintenance protocols: review, validation and release procedures for maintainers, in the repository’s `maintenance/` directory. + +## What Lean can establish + +Lean checks formal conclusions under given definitions and assumptions. Target `accepted`, kernel `passed` and source fidelity are different judgments; `limited`, `incomplete` and `not_applicable` retain their recorded meanings. Defining a duty does not show its fulfillment; a finite model does not establish universal real-world correctness. Readers unfamiliar with Lean can start with the claim overview and consult the paired code and explanation pages one line at a time. + +## Installation and adoption are separate + +Project installation supplies method entrypoints for that project; global installation supplies user-level entrypoints. Neither adopts a philosophy automatically. A project selects its baseline through explicit initialization; updating, rolling back or uninstalling methods does not automatically change that decision. A domain collection requires an explicit domain choice. + +## Choose a method + +| Method | Purpose | +| --- | --- | +| `organon-core-assess` | Assess an input under the selected philosophy. | +| `organon-core-absorb` | Examine reasons for philosophical revision and carry out authorized adoption. | +| `organon-core-principled-review` | Analyze an object under the shared method’s stated standards. | +| `organon-core-wording-review` | Review wording without deciding philosophical adoption. | diff --git a/lean/.gitignore b/lean/.gitignore new file mode 100644 index 0000000..9b73095 --- /dev/null +++ b/lean/.gitignore @@ -0,0 +1,5 @@ +**/evidence/checks/ +**/leanified/.lake/ +**/leanified/lake-manifest.json +!**/evidence/lean-audit.log +!**/evidence/lake-build.log diff --git a/lean/README.md b/lean/README.md new file mode 100644 index 0000000..add3cdb --- /dev/null +++ b/lean/README.md @@ -0,0 +1,36 @@ +# Lean implementations and reader editions + +Core owns its Lean project, checkers and two skills and works without AgentOrganon. The English [philosophy](../PHILOSOPHY.md) is authoritative. Formal definitions, conditional results, finite examples and reader explanations add no philosophical commitments. + +## Current object + +| Source | English | Chinese | Run and code | +| --- | --- | --- | --- | +| Philosophy 0.1.4 | [Overview](philosophy/overview.md), [details](philosophy/details.md) | [速览](../zh/lean/philosophy/overview.md), [详解](../zh/lean/philosophy/details.md) | [Manifest](philosophy/manuscript.json), [CoreReader.lean](philosophy/leanified/CoreReader.lean) | + +The [frozen catalog](philosophy/targets.json) retains 28 targets, 62 prescribed declarations and all 33 source paragraphs. One supplementary application-variation case brings the checked inventory to 63 declarations. The two empty headings remain structural entries. Targets distinguish specifications, conditional theorems, satisfiability, non-entailment and nonformal boundaries. Completing this catalog does not mean that all source paragraphs are unconditionally true or completely formalized. + +The overview follows complete claims and their conditions. The details contain the exact complete Lean sources and explanations of every nonblank line in both languages. [Review records](philosophy/reviews/README.md) distinguish the preserved source-first and code-blind initial assessments from later informed comparisons and explain changed judgments. [Validation](VALIDATION.md) provides actual check evidence and its limits. + +The stable `philosophy/` path identifies the current object, not immutable evidence. Source, run, code, actual declaration types, review and manuscript hashes identify the objects checked. [Source context](philosophy/SOURCE-CONTEXT.md) explains the frozen source's original relative links. + +## Standalone use + +Use [organon-core-leanify-prove](../skills/organon-core-leanify-prove/SKILL.md) for formalization and [organon-core-lean-natural-language](../skills/organon-core-lean-natural-language/SKILL.md) for code explanation and manuscripts. These are agent entrypoints, not installed executables. Preserve a caller-selected baseline under the [selection contract](../skills/references/philosophy-resolution.md); code-only explanation requires no philosophy. Language and `--explain-lines` are skill inputs. + +With Node >=22, RTK and installed Lean `v4.33.1`, run from Core: + +```sh +rtk proxy node skills/organon-core-leanify-prove/scripts/check.js lean/philosophy --manuscript manuscript.json +rtk proxy node --test tests/*.test.js +``` + +Omitting `--manuscript manuscript.json` checks the frozen source, build, declarations, cases and dependencies. Manuscript checking additionally verifies current-source bindings, exact excerpts, the frozen target catalog, actual type hashes and reported review/status constraints across both languages and granularities. It does not certify semantic fidelity, translation accuracy, reviewer independence or philosophical correctness. No Mathlib, third-party Node dependency or automatic toolchain installation is used. + +New checks write receipts beneath ignored `evidence/checks/`. They identify loaded checker/parser bytes and observed Node/Lean/Lake versions; this does not authenticate or approve an implementation. Historical records without receipts remain records without known execution identity. + +## History and maintenance + +Formal delivery contains the current philosophy object and its necessary evidence. The preceding philosophy and rationale runs and reader views are archived under ignored `.local/lean-history/` on the maintaining machine. Rationale remains explanatory source text, without a separate current proof assignment. Clones, ordinary copies and current tests do not depend on local archives. + +Before replacing a current object, preserve the preceding source/run/code/review/view closure and verify historical replay from a separate copy. Follow [dependency-driven maintenance](../AGENTS.md#lean-evidence-maintenance): review affected objects, disclose reuse and prior exposure, and synchronize both languages. A stable path or unchanged version number does not keep old approval current. Ordinary philosophical assessment does not require Lean. diff --git a/lean/VALIDATION.md b/lean/VALIDATION.md new file mode 100644 index 0000000..b087a13 --- /dev/null +++ b/lean/VALIDATION.md @@ -0,0 +1,18 @@ +# Current Lean checks + +Run from the Core root with Node >=22, RTK and installed Lean `v4.33.1`: + +```sh +rtk proxy node skills/organon-core-leanify-prove/scripts/check.js lean/philosophy --manuscript manuscript.json +rtk proxy node --test tests/*.test.js +``` + +The first command builds the current project, audits every registered declaration and case, saves actual full declaration types, and checks current-source bindings and all four reader views. The second checks Core's runtime and delivery behavior, including retention of the frozen target catalog and rejection of source drift. New checks write execution records under ignored `evidence/checks/`. + +| Current object | Selected evidence | +| --- | --- | +| Philosophy | [Kernel](philosophy/evidence/kernel.json), [manuscript](philosophy/evidence/manuscript-check.json), [actual declaration types](philosophy/evidence/declaration-types.json), [execution identity](philosophy/evidence/execution-identity.json), [context](philosophy/evidence/README.md) | + +These records bind exact inputs. Successful checking does not establish philosophical correctness or actual-world fulfillment of an adopted duty. Target acceptance is separate from a source paragraph's partial correspondence and from empirical/value adequacy. [Independent review records](philosophy/reviews/README.md) preserve initial objections, corrections, exposure and final scope. + +Private iteration logs, preceding deliveries and ordinary-copy reports remain under ignored `.local/`. They are not dependencies of the formal delivery. The selected per-run records above remain with their current object; rerunning checks does not rewrite them automatically. diff --git a/lean/philosophy/PREREGISTERED.md b/lean/philosophy/PREREGISTERED.md new file mode 100644 index 0000000..cc618df --- /dev/null +++ b/lean/philosophy/PREREGISTERED.md @@ -0,0 +1,5 @@ +# Frozen goals before Lean encoding + +2026-09-14. Independent source-first inventory and candidate comparison complete. The explicitly authorized complete-core scope is fixed in `targets-frozen.json`, SHA256 `35cda8ba439af8b32fd180efae2829b370bc5b82960cc91feb24e3e03636d2f4`:28 families,33 exact source paragraphs,62 prescribed declarations. Source SHA unchanged. Independent initial and comparison bytes retained. No new Lean code existed before this freeze. + +The author draft's generic removal/satisfiability result is an implementation helper, not a new independent completion target. Only permission-not-entailing-valuation direction is registered. Failed D/W targets cannot be reclassified to boundaries; material scope changes require a new visible decision and preserved previous judgment. This record is an inspectable freeze, not a cryptographic authority against an actor rewriting every record. diff --git a/lean/philosophy/SOURCE-CONTEXT.md b/lean/philosophy/SOURCE-CONTEXT.md new file mode 100644 index 0000000..1817956 --- /dev/null +++ b/lean/philosophy/SOURCE-CONTEXT.md @@ -0,0 +1,7 @@ +# Frozen source context + +`snapshots/PHILOSOPHY.md` preserves the exact English PHILOSOPHY 0.1.4 bytes. Its relative links are interpreted from the [Core source location](../../PHILOSOPHY.md), not from the snapshot directory. The linked [rationale](../../rationale/README.md) supplies explanation without adding core obligations or a separate current proof assignment. + +The authoritative source, code, target catalog and reviews have separate identities. The source's version number alone does not establish currentness. Reader statuses remain conditional on the stated representations, assumptions and review scope. + +The original preregistration retains its historical source/catalog identity. The current metadata and rationale path were separately compared in [source migration review](reviews/source-migration-2026-09-15.md); unchanged Lean code, target bodies and bounded judgments are reused with that scope disclosed. diff --git a/lean/philosophy/details.md b/lean/philosophy/details.md new file mode 100644 index 0000000..b357808 --- /dev/null +++ b/lean/philosophy/details.md @@ -0,0 +1,12119 @@ +# Philosophy and Lean: detailed reader + +This reader follows 28 frozen targets. Target acceptance, Lean checking and source fidelity are separate judgments. Defining a duty does not establish its fulfillment; a finite model does not establish universal real-world correctness. The tracing appendix retains all 33 source paragraphs and two empty headings. + +`accepted` records acceptance of a target within its stated scope; `limited` retains a bounded formal correspondence for a source paragraph; `incomplete` retains material without a complete source proof. Lean `passed` reports checking of registered declarations; checking a normative interface is not fulfillment of its duty. + +[Other granularity](overview.md) · [Frozen targets](targets.json) · [Review and exposure record](reviews/README.md) · [Actual declaration types](evidence/declaration-types.json) + +| Target | Claim | Kind | Target review | +| --- | --- | --- | --- | +| [T01](#t01) | Authority and boundaries | boundary | accepted | +| [T02](#t02) | A shared nonempty model | satisfiability | accepted | +| [T03](#t03) | Generative commitment | specification | accepted | +| [T04](#t04) | Permission does not supply valuation | nonentailment | accepted | +| [T05](#t05) | Revisability and progress | theorem | accepted | +| [T06](#t06) | Generation has limits | nonentailment | accepted | +| [T07](#t07) | Achievement needs matching grounds | theorem | accepted | +| [T08](#t08) | Whole-theory consistency | theorem | accepted | +| [T09](#t09) | Revision and context changes | nonentailment | accepted | +| [T10](#t10) | Changes must be acknowledged | theorem | accepted | +| [T11](#t11) | Tension and contradiction | nonentailment | accepted | +| [T12](#t12) | Consistency is not truth or coverage | nonentailment | accepted | +| [T13](#t13) | Reflexive work with actual inquiry and reasons | specification | accepted | +| [T14](#t14) | Self-application is not self-proof | nonentailment | accepted | +| [T15](#t15) | Support, strength and scope | theorem | accepted | +| [T16](#t16) | All applicable aspects retain duties | theorem | accepted | +| [T17](#t17) | Articulation, repetition and assertion are insufficient | nonentailment | accepted | +| [T18](#t18) | Adopted value positions and joint reasons | satisfiability | accepted | +| [T19](#t19) | Local evidence and omitted differences | nonentailment | accepted | +| [T20](#t20) | Observation, reproduction and stability | satisfiability | accepted | +| [T21](#t21) | Capability contracts and external assessment | nonentailment | accepted | +| [T22](#t22) | Relevant implementation reasons | theorem | accepted | +| [T23](#t23) | An accurate assessment does not enforce the extra choice norm | nonentailment | accepted | +| [T24](#t24) | Openness does not imply equivalence or plurality | nonentailment | accepted | +| [T25](#t25) | Mutual application in one system | theorem | accepted | +| [T26](#t26) | Distinct commitments and their combination | nonentailment | accepted | +| [T27](#t27) | Application duties and individual reasons | theorem | accepted | +| [T28](#t28) | Assessment without observation tests | satisfiability | accepted | + + +## T01 · Authority and boundaries + +The adopted English source, including its meanings, applicability and limits, remains the authority against which this formalization is compared. + +**Premises and representation:** This entry records the selected source and documentary boundary; it has no required Lean declaration. + +**Proof or check:** The target catalog records the source units and their boundary status. There is no mathematical derivation of the authority or adoption of the philosophy. + +**Limits:** Source correspondence and acceptance of a philosophical position are separate from kernel checking. Neither the catalog nor the proofs establish universal philosophical correctness. + +**State:** accepted (boundary). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.preamble#p1](#source-organon-preamble-p1), [organon.preamble#p2](#source-organon-preamble-p2), [organon.charter.overview#p1](#source-organon-charter-overview-p1), [organon.charter.overview#p2](#source-organon-charter-overview-p2), [organon.charter.overview#p3](#source-organon-charter-overview-p3) + +This boundary target has no Lean declaration. + + + +## T02 · A shared nonempty model + +One explicitly inhabited System and World jointly carry the charter, its own supported output capability, relevant implementation choice, and grounds for each of five represented commitments. + +**Premises and representation:** The witness is actualSystem at actual = (identity, apply). The world type independently varies two implementations and two governance modes. Its context includes the system theory, observation assumptions and application scope; the contracts and assessment adapters are explicit model choices. + +**Proof or check:** jointWitness supplies that same pair throughout, using actualAdmissible, charterChecked, ownCapabilityGrounded, identityJustified and reasonsBelongToCommitments. The existential conclusion also identifies the witnesses by equality. + +**Limits:** This proves coexistence in the disclosed application model, not correctness of every possible system or independent validation of the adopted normative criteria. + +**State:** accepted (satisfiability). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.preamble#p1](#source-organon-preamble-p1), [organon.preamble#p2](#source-organon-preamble-p2), [organon.charter.overview#p2](#source-organon-charter-overview-p2), [organon.charter.overview#p3](#source-organon-charter-overview-p3), [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +### `CoreReader.Integration.jointWitness` + +[leanified/CoreReader/Integration.lean:595](#line-code-leanified-corereader-integration-lean-595) · case + +Core dependencies: `propext`, `Classical.choice`, `Quot.sound`. + +```lean +theorem jointWitness : + ∃ s : System, ∃ w : World, + Admissible (systemHeld s) (systemContext s) w ∧ Charter s w ∧ + OwnCapabilityDuty s w [capabilityFacet] ∧ systemCapability s w ∧ + JustifiedChoice s.requirements (s.method.realize w) objectiveReason ∧ + (∀ c : Commitment, Grounds (commitmentClaim c) canonicalArticulation + (fun f => f = commitmentFacet c) [commitmentFacet c]) ∧ + s = actualSystem ∧ w = actual := by +``` + + + +## T03 · Generative commitment + +Generative is defined as valuing expanded understanding and construction, together with revisability of every form that the policy treats as current. + +**Premises and representation:** The parameter is a Policy with worthPursuing, current and revisable predicates. The revisability clause applies to forms satisfying current; permitsVersion is a separate field. + +**Proof or check:** The declaration is a conjunction defining an obligation. Later concrete policies instantiate it; the definition itself is not a theorem that any agent satisfies it. + +**Limits:** The representation does not establish that the valued aim is ultimately good, that every permitted edit advances it, or that a current form must be changed immediately. + +**State:** accepted (specification). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.overview#p2](#source-organon-charter-overview-p2), [organon.charter.overview#p3](#source-organon-charter-overview-p3), [organon.charter.self-transcendence#p1](#source-organon-charter-self-transcendence-p1), [organon.charter.self-transcendence.orientation#p1](#source-organon-charter-self-transcendence-orientation-p1), [organon.charter.self-transcendence.non-finality#p1](#source-organon-charter-self-transcendence-non-finality-p1), [organon.charter.self-transcendence.limits#p1](#source-organon-charter-self-transcendence-limits-p1), [organon.charter.self-transcendence.limits#p2](#source-organon-charter-self-transcendence-limits-p2) + +### `CoreReader.Agency.Generative` + +[leanified/CoreReader/Agency.lean:33](#line-code-leanified-corereader-agency-lean-33) · definition + +Core dependencies: none. + +```lean +def Generative (p : Policy) : Prop := +``` + + + +## T04 · Permission does not supply valuation + +Permission to change a version can hold while the generative valuation is absent. + +**Premises and representation:** The concrete neutral policy permits versions but assigns no worth to the expansion aim; Generative retains its valuation conjunct. + +**Proof or check:** permissionNotValuation evaluates the permission and unfolds Generative to refute its missing valuation clause. + +**Limits:** This is a counterexample to an implication between represented predicates; it does not justify either policy or classify all real permissions. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.self-transcendence.orientation#p1](#source-organon-charter-self-transcendence-orientation-p1) + +### `CoreReader.Agency.permissionNotValuation` + +[leanified/CoreReader/Agency.lean:49](#line-code-leanified-corereader-agency-lean-49) · case + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem permissionNotValuation : + neutralPolicy.permitsVersion 0 1 ∧ (0 : Nat) ≠ 1 ∧ ¬ Generative neutralPolicy := by +``` + + + +## T05 · Revisability and progress + +Generative policies leave current forms revisable, while the concrete open policy can remain generative through a trace with no capability expansion. + +**Premises and representation:** The general revisability result assumes Generative and that the selected form is current. The example covers organization, method, principle, appearance and artifact, and uses a constant base-state trace. + +**Proof or check:** revisabilityCovers projects the revisability obligation. revisionWithoutProgress instantiates the open policy and shows that adjacent identical states contain no newly understood or constructed operation. + +**Limits:** Revisability and permission are not evidence that revision occurred or improved capability. The result is not a universal claim that revision never yields progress. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.self-transcendence.non-finality#p1](#source-organon-charter-self-transcendence-non-finality-p1), [organon.relationships.terms#p1](#source-organon-relationships-terms-p1) + +### `CoreReader.Agency.revisabilityCovers` + +[leanified/CoreReader/Agency.lean:58](#line-code-leanified-corereader-agency-lean-58) · theorem + +Core dependencies: none. + +```lean +theorem revisabilityCovers (p : Policy) (h : Generative p) (k : FormKind) (v : Nat) + (hc : p.current ⟨k, v⟩) : p.revisable ⟨k, v⟩ := h.2 _ hc +``` + +### `CoreReader.Agency.revisionWithoutProgress` + +[leanified/CoreReader/Agency.lean:123](#line-code-leanified-corereader-agency-lean-123) · case + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem revisionWithoutProgress : + Generative openPolicy ∧ + (∀ k : FormKind, openPolicy.revisable ⟨k, 0⟩) ∧ + (∀ t, ¬ Expanded (stableTrace t) (stableTrace (t + 1))) := by +``` + + + +## T06 · Generation has limits + +One generating system illustrates non-progressing inflation, dependence on three external resources, a justified stable action within its application budget, and a false expansion report about its own actual transition. + +**Premises and representation:** The system combines openPolicy, baseState, assistedExecution, required copy capability and an inventory budget of 1. inflatedState duplicates artifacts, abstraction layers and vocabulary without adding understood or constructed operations. Its report names this owner, before/after states and successor at input 0 with expected output 1. + +**Proof or check:** generationLimits evaluates the same system interface: available resources yield 6, deleting any of experience/knowledge/collaborator or all three yields none; the stable action preserves the current state, required capability and budget. Inflation exceeds that budget, and the system-generated report fails because its claimed new operation is absent. + +**Limits:** The resource dependence and budget are declared application conditions. These content-bearing examples do not establish universal laws of learning, mandatory austerity, or the adequacy of any real expansion report. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.self-transcendence.limits#p1](#source-organon-charter-self-transcendence-limits-p1), [organon.charter.self-transcendence.limits#p2](#source-organon-charter-self-transcendence-limits-p2) + +### `CoreReader.Agency.generationLimits` + +[leanified/CoreReader/Agency.lean:222](#line-code-leanified-corereader-agency-lean-222) · case + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem generationLimits : + Generative generatingSystem.policy ∧ + generatingSystem.policy.permitsVersion 0 0 ∧ + ¬ Expanded generatingSystem.current inflatedState ∧ + generatingSystem.current.inventory.length < inflatedState.inventory.length ∧ + generatingSystem.current.abstractionLayers.length < inflatedState.abstractionLayers.length ∧ + generatingSystem.current.vocabulary.length < inflatedState.vocabulary.length ∧ + generatingSystem.execute availableResources = some 6 ∧ + generatingSystem.execute { availableResources with experience := none } = none ∧ +``` + + + +## T07 · Achievement needs matching grounds + +AchievementAccountability requires Grounds for the very achievement claim. Given support and an actual evidence-compatible world, that claim holds there; a concrete expansion case has matching grounds, while its positive self-report alone does not support it. + +**Premises and representation:** The general theorem takes a world type, achievement predicate, records, actual world, Compatible records actual and Supports records achievement. Separately, the concrete alternatives share baseState and input 0: extend adds successor, whereas inflate only duplicates content. + +**Proof or check:** achievementNeedsSupport applies support to the compatible actual world and includes ConcreteAchievementExample. Actual after-state performance distinguishes extend and supplies canonical matched grounds; the positive report is also compatible with inflate, where Expanded before after is false. + +**Limits:** The definition expresses normative accountability without making observation universally mandatory. The theorem assumes support in its general branch and does not infer it from an arbitrary assertion or prove real achievement from record labels. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.self-transcendence.limits#p1](#source-organon-charter-self-transcendence-limits-p1), [organon.charter.self-transcendence.limits#p2](#source-organon-charter-self-transcendence-limits-p2), [organon.grounds#p1](#source-organon-grounds-p1), [organon.grounds.capabilities#p1](#source-organon-grounds-capabilities-p1), [organon.grounds.capabilities#p2](#source-organon-grounds-capabilities-p2) + +### `CoreReader.Evidence.AchievementAccountability` + +[leanified/CoreReader/Evidence.lean:125](#line-code-leanified-corereader-evidence-lean-125) · definition + +Core dependencies: none. + +```lean +def AchievementAccountability {W : Type} (achievement : Claim W) (articulations : Facet W → Articulation W) + (actualApplicable : Facet W → Prop) (facets : List (Facet W)) : Prop := +``` + +### `CoreReader.Evidence.achievementNeedsSupport` + +[leanified/CoreReader/Evidence.lean:217](#line-code-leanified-corereader-evidence-lean-217) · theorem + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem achievementNeedsSupport {W : Type} (achievement : Claim W) (records : List (Record W)) + (actual : W) (reliableHere : Compatible records actual) (support : Supports records achievement) : + achievement actual ∧ ConcreteAchievementExample := +``` + + + +## T08 · Whole-theory consistency + +An inhabited common theory and context cannot semantically yield both answers to one question. Separately satisfiable assumptions may nevertheless become inconsistent when held together. + +**Premises and representation:** consequenceConsistency quantifies over world and question types, a held theory and one Context, and assumes an Admissible world satisfying the entire held theory, contextual assumptions and scope simultaneously. + +**Proof or check:** The general proof evaluates both consequences at the same witness to obtain a contradiction. jointConflict combines P, P implies Q, and not Q: each singleton has a model, but their union has none. + +**Limits:** The nonempty witness is essential to this semantic consistency argument. Pairwise or isolated checks do not establish joint satisfiability, and no empirical truth of the assumptions is inferred. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency#p1](#source-organon-charter-consistency-p1) + +### `CoreReader.Logic.consequenceConsistency` + +[leanified/CoreReader/Logic.lean:31](#line-code-leanified-corereader-logic-lean-31) · theorem + +Core dependencies: none. + +```lean +theorem consequenceConsistency {W Q : Type} (t : Theory W) (c : Context W Q) + (inhabited : ∃ w, Admissible t c w) : Consistent t c := by +``` + +### `CoreReader.Logic.jointConflict` + +[leanified/CoreReader/Logic.lean:59](#line-code-leanified-corereader-logic-lean-59) · case + +Core dependencies: none. + +```lean +theorem jointConflict : + Satisfiable (singleton premiseP) ∧ Satisfiable (singleton premiseRule) ∧ + Satisfiable (singleton premiseNotQ) ∧ ¬ Satisfiable jointTheory := by +``` + + + +## T09 · Revision and context changes + +Different time-indexed theories can give opposite answers without either being unsatisfiable; changing assumptions, question meaning or scope can likewise change the answer. + +**Premises and representation:** The examples fix explicit Boolean interpretations and separately inhabited contexts. The positive and negative answers belong to different theory slices or contexts, not one unchanged conjunction. + +**Proof or check:** revisionCanReverse constructs the two slices and shows their simultaneous union fails. contextDifferences separately changes the assumptions, meaning and scope components while evaluating the corresponding consequences. + +**Limits:** These examples distinguish revision and contextual difference from simultaneous contradiction. They do not establish that a particular revision is warranted, truthful or progressive. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency.meaning#p1](#source-organon-charter-consistency-meaning-p1), [organon.charter.consistency.meaning#p2](#source-organon-charter-consistency-meaning-p2) + +### `CoreReader.Logic.revisionCanReverse` + +[leanified/CoreReader/Logic.lean:78](#line-code-leanified-corereader-logic-lean-78) · case + +Core dependencies: none. + +```lean +theorem revisionCanReverse : + Satisfiable (revisionSlice 0) ∧ Satisfiable (revisionSlice 1) ∧ + ¬ Satisfiable (union (revisionSlice 0) (revisionSlice 1)) := by +``` + +### `CoreReader.Logic.contextDifferences` + +[leanified/CoreReader/Logic.lean:102](#line-code-leanified-corereader-logic-lean-102) · case + +Core dependencies: none. + +```lean +theorem contextDifferences : + (Consequence emptyTheory (assumptionContext true) () true ∧ + Consequence emptyTheory (assumptionContext false) () false) ∧ + (Consequence emptyTheory (meaningContext true) () true ∧ + Consequence emptyTheory (meaningContext false) () false) ∧ + (Consequence emptyTheory (scopeContext true) () true ∧ + Consequence emptyTheory (scopeContext false) () false) ∧ + (∀ b, ∃ w, Admissible emptyTheory (assumptionContext b) w) ∧ + (∀ b, ∃ w, Admissible emptyTheory (meaningContext b) w) ∧ + (∀ b, ∃ w, Admissible emptyTheory (scopeContext b) w) := by +``` + + + +## T10 · Changes must be acknowledged + +Under TruthfulReport, a semantic change or a different revision identity requires a positive change report. Reordering the same held content does not change that content, and honest reporting does not make revised assumptions true. + +**Premises and representation:** The general result assumes two snapshots, a report flag, the TruthfulReport obligation and an actual semantic-or-identity change. SameContent compares held claims, contextual assumptions, meaning and scope extensionally. + +**Proof or check:** semanticChangeMustBeReported applies the assumed reporting obligation; representationOrderIrrelevant proves union commutativity. hiddenContextChangeRejected evaluates separate hidden assumption, meaning, scope and identity changes, and an acknowledged revision false at the designated actual world. + +**Limits:** The reporting rule is adopted, not derived from logic alone. The cases do not decide every possible form of revision or certify the quality of an acknowledged change. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency.meaning#p1](#source-organon-charter-consistency-meaning-p1), [organon.charter.consistency.meaning#p2](#source-organon-charter-consistency-meaning-p2) + +### `CoreReader.Logic.semanticChangeMustBeReported` + +[leanified/CoreReader/Logic.lean:142](#line-code-leanified-corereader-logic-lean-142) · theorem + +Core dependencies: none. + +```lean +theorem semanticChangeMustBeReported {W Q : Type} (a b : Snapshot W Q) (reported : Bool) + (changed : ¬ SameContent a b ∨ a.revisionIdentity ≠ b.revisionIdentity) + (h : TruthfulReport a b reported) : reported = true := h changed +``` + +### `CoreReader.Logic.representationOrderIrrelevant` + +[leanified/CoreReader/Logic.lean:150](#line-code-leanified-corereader-logic-lean-150) · theorem + +Core dependencies: none. + +```lean +theorem representationOrderIrrelevant {W : Type} (p q : Claim W) : + ∀ r, union (singleton p) (singleton q) r ↔ union (singleton q) (singleton p) r := by +``` + +### `CoreReader.Logic.hiddenContextChangeRejected` + +[leanified/CoreReader/Logic.lean:160](#line-code-leanified-corereader-logic-lean-160) · case + +Core dependencies: none. + +```lean +theorem hiddenContextChangeRejected : + ¬ TruthfulReport (contextSnapshot (assumptionContext true)) (contextSnapshot (assumptionContext false)) false ∧ + ¬ TruthfulReport (contextSnapshot (meaningContext true)) (contextSnapshot (meaningContext false)) false ∧ + ¬ TruthfulReport (contextSnapshot (scopeContext true)) (contextSnapshot (scopeContext false)) false ∧ + ¬ TruthfulReport (contextSnapshot (scopeContext true) 0) (contextSnapshot (scopeContext true) 1) false ∧ + (TruthfulReport (contextSnapshot (assumptionContext true)) (contextSnapshot (assumptionContext false)) true ∧ + ¬ Models (assumptionContext false).assumptions true) := by +``` + + + +## T11 · Tension and contradiction + +Distinct resource objectives can be jointly satisfiable. In contrast, positive and negative consequences for the same question in the same theory and context violate Consistent. + +**Premises and representation:** The tension example uses the predicates 4 ≤ budget and budget ≤ 6. conflictRequiresChange takes an arbitrary theory, context and question together with both opposed consequences. + +**Proof or check:** tensionWithoutContradiction supplies budget 5 and proves the predicates are different. conflictRequiresChange applies the definition of Consistent to the given pair of consequences. + +**Limits:** The latter theorem proves inconsistency; it neither constructs a repair nor determines which commitment should change. The resource example does not classify every practical tension. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency.limits#p1](#source-organon-charter-consistency-limits-p1) + +### `CoreReader.Logic.tensionWithoutContradiction` + +[leanified/CoreReader/Logic.lean:186](#line-code-leanified-corereader-logic-lean-186) · case + +Core dependencies: none. + +```lean +theorem tensionWithoutContradiction : + (∃ budget : Nat, 4 ≤ budget ∧ budget ≤ 6) ∧ + ¬ ((fun n : Nat => 4 ≤ n) = (fun n : Nat => n ≤ 6)) := by +``` + +### `CoreReader.Logic.conflictRequiresChange` + +[leanified/CoreReader/Logic.lean:195](#line-code-leanified-corereader-logic-lean-195) · theorem + +Core dependencies: none. + +```lean +theorem conflictRequiresChange {W Q : Type} (t : Theory W) (c : Context W Q) (q : Q) + (positive : Consequence t c q true) (negative : Consequence t c q false) : + ¬ Consistent t c := fun h => h q ⟨positive,negative⟩ +``` + + + +## T12 · Consistency is not truth or coverage + +Satisfiability does not establish truth at a designated actual world, and a satisfiable theory can leave an explicit question undecided. + +**Premises and representation:** The examples use Boolean worlds: the singleton assumption that the world is true, and the empty theory with the question whether the world is true. + +**Proof or check:** consistentFalse supplies the true model and refutes the singleton assumption at false. consistentIncomplete supplies models of the empty theory and uses opposite worlds to refute entailment of each answer. + +**Limits:** These are explicit satisfiability and non-entailment results, not an empirical classification of actual beliefs or a general incompleteness theorem for formal arithmetic. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency.limits#p1](#source-organon-charter-consistency-limits-p1), [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +### `CoreReader.Logic.consistentFalse` + +[leanified/CoreReader/Logic.lean:205](#line-code-leanified-corereader-logic-lean-205) · case + +Core dependencies: none. + +```lean +theorem consistentFalse : Satisfiable (singleton (fun w : Bool => w = true)) ∧ + ¬ Models (singleton (fun w : Bool => w = true)) false := by +``` + +### `CoreReader.Logic.consistentIncomplete` + +[leanified/CoreReader/Logic.lean:216](#line-code-leanified-corereader-logic-lean-216) · case + +Core dependencies: none. + +```lean +theorem consistentIncomplete : Satisfiable (emptyTheory : Theory Bool) ∧ + ¬ Entails emptyTheory (fun w : Bool => w = true) ∧ + ¬ Entails emptyTheory (fun w : Bool => w ≠ true) := by +``` + + + +## T13 · Reflexive work with actual inquiry and reasons + +Reflexive requires coherent principle registration and valid applications to every owned subject where each registered principle actually applies. A valid application carries the principle’s inquiry, reasons, limits and a result satisfying its independently specified meaning. + +**Premises and representation:** The parameters are an owner, registered principles and work records. ValidApplication binds principle identity, subject, generation/assessment activity, resolved target method, exact inquiry, nonempty target-matched reasons, limits and semantic result; applicability and ownership are explicit conditions. + +**Proof or check:** This declaration defines the obligation. The shared model’s completeOwnWork_reflexive supplies content-checked work for the system, two principles and their formation/application/revision processes; the evaluator uses actual samples, declared scope and counterexamples, and accepts an insufficient verdict for revision. + +**Limits:** Generation is required only for generationEligible subjects; application-phase processes receive assessment in this model. Valid work, including a negative verdict, does not prove the assessed principles correct or exhaust real reflexive inquiry. + +**State:** accepted (specification). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.reflexivity#p1](#source-organon-charter-reflexivity-p1), [organon.charter.reflexivity.meaning#p1](#source-organon-charter-reflexivity-meaning-p1), [organon.charter.reflexivity.limits#p1](#source-organon-charter-reflexivity-limits-p1) + +### `CoreReader.Agency.Reflexive` + +[leanified/CoreReader/Reflexivity.lean:151](#line-code-leanified-corereader-reflexivity-lean-151) · definition + +Core dependencies: none. + +```lean +def Reflexive (owner : Nat) (rules : List Principle) (records : List WorkRecord) : Prop := +``` + + + +## T14 · Self-application is not self-proof + +An applicable owned subject cannot be omitted from a Reflexive work set, while inapplicable subjects need not receive work. Passing a selected self-test and generating a revision oneself do not establish universal correctness. + +**Premises and representation:** noSelfExemption assumes Reflexive, principle membership, matching owner and applicability. applicabilityRetained preserves those conditions. The counterexamples use the same arithmetic principle across test and claim, and a GeneratingProcess with owner 17, a false prior, seed 0 and its actual output revision. + +**Proof or check:** The general proofs extract valid work and its scope. The arithmetic principle passes at 1 but fails at 0. selfOriginDoesNotSupport includes the actual producer/prior/output relationship: its revision passes the input-0 observation but fails at 1, giving an evidence-compatible counterworld to allTrue. + +**Limits:** Scope coverage is weaker than full valid Reflexive work. The examples reject self-certification implications; they do not show all self-tests or self-generated revisions are worthless. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.reflexivity.limits#p1](#source-organon-charter-reflexivity-limits-p1) + +### `CoreReader.Agency.noSelfExemption` + +[leanified/CoreReader/Reflexivity.lean:165](#line-code-leanified-corereader-reflexivity-lean-165) · theorem + +Core dependencies: none. + +```lean +theorem noSelfExemption (owner : Nat) (rules : List Principle) (records : List WorkRecord) + (h : Reflexive owner rules records) (rule : Principle) (hr : rule ∈ rules) + (s : Subject) (hs : s.owner = owner) (ha : rule.applicable s) : + Performed records s rule.activity := h.toScope rule hr s hs ha +``` + +### `CoreReader.Agency.applicabilityRetained` + +[leanified/CoreReader/Reflexivity.lean:407](#line-code-leanified-corereader-reflexivity-lean-407) · theorem + +Core dependencies: `propext`, `Classical.choice`, `Quot.sound`. + +```lean +theorem applicabilityRetained (owner : Nat) (rules : List Principle) (records : List WorkRecord) : + (Reflexive owner rules records → ReflexiveScope owner rules records) ∧ + (ReflexiveScope owner rules records ↔ + ∀ rule ∈ rules, ∀ s, s.owner = owner → (¬ rule.applicable s ∨ Performed records s rule.activity)) ∧ + (Reflexive 0 [applicationRule] applicationWork ∧ + ¬ Performed applicationWork (.system 0) .assessment) := by +``` + +### `CoreReader.Agency.selfTestDoesNotProve` + +[leanified/CoreReader/Agency.lean:275](#line-code-leanified-corereader-agency-lean-275) · case + +Core dependencies: none. + +```lean +theorem selfTestDoesNotProve : + selfTest [1] = true ∧ ownArithmeticPrinciple 0 = false ∧ + ¬ (∀ n, ownArithmeticPrinciple n = true) := by +``` + +### `CoreReader.Evidence.selfOriginDoesNotSupport` + +[leanified/CoreReader/Evidence.lean:616](#line-code-leanified-corereader-evidence-lean-616) · case + +Core dependencies: `propext`. + +```lean +theorem selfOriginDoesNotSupport : + localGenerator 0 0 = true ∧ localGenerator 0 1 = false ∧ + Compatible [zeroRecord] (localGenerator 0) ∧ + ¬ Supports [zeroRecord] allTrue ∧ OwnedRevisionExample := by +``` + + + +## T15 · Support, strength and scope + +Grounds binds the same claim to all actually applicable represented facets and their actual articulations. With evidence fixed, support is preserved when the conclusion is weakened or its quantified scope is restricted. + +**Premises and representation:** Grounds takes a claim, facet-indexed articulations, an actualApplicable predicate and a nonempty list covering that predicate. Each listed facet must have that claim, be articulated, match its actual premises/reasons/limits, and pass its disclosed assessment adapter. supportWeakening assumes Supports records p and pointwise p implies q; scopeRestriction assumes a supported broad-domain conclusion and inclusion of the narrower domain. + +**Proof or check:** The obligation is defined, not universally proved. Both preservation proofs apply the original support at the same compatible world and then the implication or scope inclusion. The empirical, inferential and value articulation adapters expose the corresponding real record compatibility, theory or option-indexed reasons. + +**Limits:** These theorems weaken conclusions, not evidence. FacetDischarged and the canonical articulation are application-specific semantic adapters, not a complete definition or proof of all source-level empirical or value adequacy. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds#p1](#source-organon-grounds-p1), [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +### `CoreReader.Evidence.Grounds` + +[leanified/CoreReader/Evidence.lean:112](#line-code-leanified-corereader-evidence-lean-112) · definition + +Core dependencies: none. + +```lean +def Grounds {W : Type} (claim : Claim W) (articulations : Facet W → Articulation W) + (actualApplicable : Facet W → Prop) (facets : List (Facet W)) : Prop := +``` + +### `CoreReader.Evidence.supportWeakening` + +[leanified/CoreReader/Evidence.lean:228](#line-code-leanified-corereader-evidence-lean-228) · theorem + +Core dependencies: none. + +```lean +theorem supportWeakening {W : Type} (records : List (Record W)) (p q : Claim W) + (support : Supports records p) (weaker : ∀ w, p w → q w) : Supports records q := +``` + +### `CoreReader.Evidence.scopeRestriction` + +[leanified/CoreReader/Evidence.lean:245](#line-code-leanified-corereader-evidence-lean-245) · theorem + +Core dependencies: none. + +```lean +theorem scopeRestriction {W X : Type} (records : List (Record W)) (p : W → X → Prop) + (wide narrow : X → Prop) (included : ∀ x, narrow x → wide x) + (support : Supports records (fun w => ∀ x, wide x → p w x)) : + Supports records (fun w => ∀ x, narrow x → p w x) := +``` + + + +## T16 · All applicable aspects retain duties + +Duties for two sets of applicable aspects combine exactly as their union, and an added label cannot waive them. A claim with empirical and value aspects can pass the represented empirical check while failing its value procedure. + +**Premises and representation:** assessmentUnion uses two actual facet predicates; labelsCannotWaive uses a label that does not alter those predicates or FacetDischarged. The mixed switch example concerns the same selected-on claim: an actual observation assesses the selection fact, while adoption also invokes the value procedure. + +**Proof or check:** The general proofs distribute universal obligations over disjunction and unfold the label wrapper. mixedMissingResponsibility combines discharged switch evidence with an unsupportedPosition whose empty reason list fails ValueProcedure. + +**Limits:** The empty-list failure establishes missing recorded procedural responsibility, not that no adequate value reason could exist. Which aspects actually apply remains an explicit input requiring source-faithful judgment. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +### `CoreReader.Evidence.assessmentUnion` + +[leanified/CoreReader/Evidence.lean:261](#line-code-leanified-corereader-evidence-lean-261) · theorem + +Core dependencies: none. + +```lean +theorem assessmentUnion {W : Type} (a b : Facet W → Prop) : + Duties (fun f => a f ∨ b f) ↔ Duties a ∧ Duties b := by +``` + +### `CoreReader.Evidence.labelsCannotWaive` + +[leanified/CoreReader/Evidence.lean:272](#line-code-leanified-corereader-evidence-lean-272) · theorem + +Core dependencies: none. + +```lean +theorem labelsCannotWaive {W : Type} (xs ys : List String) (a : Facet W → Prop) : + LabeledDuties xs a ↔ LabeledDuties ys a := Iff.rfl +``` + +### `CoreReader.Evidence.mixedMissingResponsibility` + +[leanified/CoreReader/Evidence.lean:362](#line-code-leanified-corereader-evidence-lean-362) · case + +Core dependencies: `propext`. + +```lean +theorem mixedMissingResponsibility : + FacetDischarged switchEmpirical ∧ + ¬ LabeledDuties [] (fun f : Facet Bool => f = switchEmpirical ∨ f = .value unsupportedPosition) := by +``` + + + +## T17 · Articulation, repetition and assertion are insufficient + +Articulation, repeated irrelevant observations, compatibility with a theory and self-assertion each fail to establish the stronger claim in explicit counterexamples. A nonempty announcement can coexist with a real budget violation. + +**Premises and representation:** The examples distinguish observable temperature from another output and observed selection from available budget. The budget model evaluates the same adopted option with cost 3; starting assumptions fix selection without guaranteeing budget. A true activation announcement is compatible with budget 0. + +**Proof or check:** articulationNotSupport supplies a nonempty but uninformative articulation. measurementRepeatNotSupport retains counterworlds after repeating the same actual tests. compatibilityNotEntailment contrasts an existing joint model with a failed universal consequence. selfAssertionNotReason includes both missing reasons and the nonempty announcement case whose joint adoption is possible but whose actual cost exceeds its budget. + +**Limits:** These are failures for specified claims and grounds, not a dismissal of articulation, repetition or compatibility. The missing-reasons branch is procedural; the budget branch additionally gives a substantive counterexample within its chosen objective/constraint adapter. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +### `CoreReader.Evidence.articulationNotSupport` + +[leanified/CoreReader/Evidence.lean:377](#line-code-leanified-corereader-evidence-lean-377) · case + +Core dependencies: `propext`. + +```lean +theorem articulationNotSupport : Articulated uninformativeArgument ∧ + ¬ Entails uninformativeArgument.assumptions (fun w : Bool => w = true) := by +``` + +### `CoreReader.Evidence.measurementRepeatNotSupport` + +[leanified/CoreReader/Evidence.lean:451](#line-code-leanified-corereader-evidence-lean-451) · case + +Core dependencies: `propext`. + +```lean +theorem measurementRepeatNotSupport : + temperatureRecord.test (true,false) = true ∧ + Compatible [temperatureRecord,temperatureRecord] (true,false) ∧ + Compatible [temperatureRecord,temperatureRecord] (true,true) ∧ + ¬ Supports [temperatureRecord] (fun w : Bool × Bool => w.2 = true) ∧ + ¬ Supports [temperatureRecord,temperatureRecord] (fun w : Bool × Bool => w.2 = true) ∧ + Compatible [actionRecord,actionRecord] (true,0) ∧ + Compatible [actionRecord,actionRecord] (true,3) ∧ + ¬ Supports [actionRecord] announcementPosition.consequence ∧ + ¬ Supports [actionRecord,actionRecord] announcementPosition.consequence ∧ + ¬ ValueProcedure announcementPosition := by +``` + +### `CoreReader.Logic.compatibilityNotEntailment` + +[leanified/CoreReader/Logic.lean:229](#line-code-leanified-corereader-logic-lean-229) · case + +Core dependencies: none. + +```lean +theorem compatibilityNotEntailment : + Satisfiable (union emptyTheory (singleton (fun w : Bool => w = true))) ∧ + ¬ Entails emptyTheory (fun w : Bool => w = true) := by +``` + +### `CoreReader.Evidence.selfAssertionNotReason` + +[leanified/CoreReader/Evidence.lean:478](#line-code-leanified-corereader-evidence-lean-478) · case + +Core dependencies: `propext`. + +```lean +theorem selfAssertionNotReason : + (unsupportedPosition.commitment true ∧ ¬ ValueProcedure unsupportedPosition) ∧ + (announcementPosition.reasons ≠ [] ∧ announcementPosition.commitment (true,0) ∧ + ¬ announcementPosition.consequence (true,0) ∧ ¬ ValueProcedure announcementPosition) ∧ + JointAdoption announcementPosition := +``` + + + +## T18 · Adopted value positions and joint reasons + +A value-assessment procedure can be fulfilled from a satisfiable adopted starting position that is not entailed by the empty theory. Joint reasons can support the adopted option’s actual consequence even when neither reason alone suffices. + +**Premises and representation:** ValueProcedure requires nonempty option-indexed reasons; one world satisfying starting assumptions, limits, adoption and all reasons together; joint reason support for that option’s objective and constraints within starting/limits; and a nonempty response to relevant criticism. These are the declared option–outcome assessment conditions. + +**Proof or check:** valueWithoutSelfProof constructs the beneficial on option, shows its starting theory satisfiable and its commitment not entailed by emptyTheory, and rejects opposite, contradictory and impossible adoption variants. heterogeneousReasons includes actual empirical/inferential/value cases and a benefit-4/cost-at-most-3 example: the reasons together pass, but worlds (4,5) and (0,3) defeat each reason separately. + +**Limits:** The procedure checks a disclosed application adapter, not ultimate value justification or a mandatory deductive form for every value reason. A response string is recorded engagement, not proof of a satisfactory reply; non-self-derived starting points are distinguished from inconsistent starts. + +**State:** accepted (satisfiability). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +### `CoreReader.Evidence.valueWithoutSelfProof` + +[leanified/CoreReader/Evidence.lean:493](#line-code-leanified-corereader-evidence-lean-493) · case + +Core dependencies: `propext`, `Classical.choice`, `Quot.sound`. + +```lean +theorem valueWithoutSelfProof : ValueProcedure switchPosition ∧ + Satisfiable switchPosition.starting ∧ + ¬ Entails (emptyTheory : Theory Bool) switchPosition.commitment ∧ + (JointAdoption oppositePosition ∧ ¬ ValueProcedure oppositePosition) ∧ + (¬ ValueProcedure contradictoryStartingPosition ∧ ¬ ValueProcedure impossibleAdoptionPosition) := +``` + +### `CoreReader.Evidence.heterogeneousReasons` + +[leanified/CoreReader/Evidence.lean:564](#line-code-leanified-corereader-evidence-lean-564) · case + +Core dependencies: `propext`, `Classical.choice`, `Quot.sound`. + +```lean +theorem heterogeneousReasons : + FacetDischarged switchEmpirical ∧ + FacetDischarged (Facet.inferential (singleton (fun w : Bool => w = true)) (fun w => w = true)) ∧ + FacetDischarged (Facet.value switchPosition) ∧ JointReasonsExample := by +``` + + + +## T19 · Local evidence and omitted differences + +Agreement on the observed input can conceal disagreement elsewhere, so input-specific evidence does not support a universal claim. + +**Premises and representation:** Worlds are Boolean-valued functions on natural-number inputs. zeroRecord observes only that input 0 returns true; the compared functions are constant true and localGenerator 0. + +**Proof or check:** localNotUniversal retains localGenerator 0 as a record-compatible counterworld to allTrue. hiddenDifference proves agreement wherever n = 0 and evaluates the differing outputs at n = 1. + +**Limits:** The conclusion concerns the stated observation scope. It does not rule out justified generalization from additional premises or establish a general statistical inference rule. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.scope#p1](#source-organon-grounds-scope-p1), [organon.grounds.scope#p2](#source-organon-grounds-scope-p2), [organon.grounds.scope#p3](#source-organon-grounds-scope-p3) + +### `CoreReader.Evidence.localNotUniversal` + +[leanified/CoreReader/Evidence.lean:630](#line-code-leanified-corereader-evidence-lean-630) · case + +Core dependencies: `propext`. + +```lean +theorem localNotUniversal : + (∃ outside : Nat, outside ≠ 0) ∧ + Compatible [zeroRecord] (fun _ => true) ∧ + Compatible [zeroRecord] (localGenerator 0) ∧ + allTrue (fun _ => true) ∧ ¬ allTrue (localGenerator 0) ∧ + ¬ Supports [zeroRecord] allTrue := by +``` + +### `CoreReader.Evidence.hiddenDifference` + +[leanified/CoreReader/Evidence.lean:645](#line-code-leanified-corereader-evidence-lean-645) · case + +Core dependencies: none. + +```lean +theorem hiddenDifference : + (∀ n : Nat, n = 0 → (fun _ : Nat => true) n = localGenerator 0 n) ∧ + (fun _ : Nat => true) 1 ≠ localGenerator 0 1 := by +``` + + + +## T20 · Observation, reproduction and stability + +One observation can support a bounded claim without repetition; a valid inferential assessment need not use observation at all. Record accuracy, reproduced conditions and stability of a conclusion are distinct, and different outcomes can preserve the same bound. + +**Premises and representation:** The observation concerns input 0 only. The non-observational facet assumes n = 2 and concludes n + 1 = 3. Trial explicitly separates setting, actualOutcome and recordedOutcome; Verified compares actual and recorded values, Reproduced compares settings, and Bounded means actualOutcome ≤ 2. + +**Proof or check:** singleObservation proves local support and refutes allTrue. noUniversalChain supplies a discharged arithmetic facet without observation. variableOutcomesStableBound uses actual outcomes 1 and 2 under setting 0; verificationReproductionStability supplies separate cases with changed settings, inaccurate records and an outcome above the bound. + +**Limits:** This is a finite possible-trial model, not a probability theorem, empirical reproducibility study or guarantee about future runs. It refutes a universally mandatory observation chain only within the represented assessment interfaces. + +**State:** accepted (satisfiability). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.scope#p1](#source-organon-grounds-scope-p1), [organon.grounds.scope#p2](#source-organon-grounds-scope-p2), [organon.grounds.scope#p3](#source-organon-grounds-scope-p3) + +### `CoreReader.Evidence.singleObservation` + +[leanified/CoreReader/Evidence.lean:656](#line-code-leanified-corereader-evidence-lean-656) · case + +Core dependencies: `propext`. + +```lean +theorem singleObservation : [zeroRecord].length = 1 ∧ + (∃ f, Compatible [zeroRecord] f) ∧ + Supports [zeroRecord] (fun f => f 0 = true) ∧ + ¬ Supports [zeroRecord] allTrue := +``` + +### `CoreReader.Evidence.noUniversalChain` + +[leanified/CoreReader/Evidence.lean:673](#line-code-leanified-corereader-evidence-lean-673) · case + +Core dependencies: `propext`. + +```lean +theorem noUniversalChain : FacetDischarged arithmeticFacet ∧ usesObservation arithmeticFacet = false := by +``` + +### `CoreReader.Evidence.variableOutcomesStableBound` + +[leanified/CoreReader/Evidence.lean:694](#line-code-leanified-corereader-evidence-lean-694) · case + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem variableOutcomesStableBound : + let a : Trial := ⟨0,1,1⟩ +``` + +### `CoreReader.Evidence.verificationReproductionStability` + +[leanified/CoreReader/Evidence.lean:705](#line-code-leanified-corereader-evidence-lean-705) · case + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem verificationReproductionStability : + (Verified ⟨0,1,1⟩ ∧ Verified ⟨1,1,1⟩ ∧ ¬ Reproduced ⟨0,1,1⟩ ⟨1,1,1⟩) ∧ + (Reproduced ⟨0,1,1⟩ ⟨0,3,2⟩ ∧ ¬ Verified ⟨0,3,2⟩ ∧ ¬ Bounded ⟨0,3,2⟩) ∧ + (Bounded ⟨0,1,1⟩ ∧ Bounded ⟨0,2,0⟩ ∧ ¬ Verified ⟨0,2,0⟩) := by +``` + + + +## T21 · Capability contracts and external assessment + +Correct outputs and an explanation contract are distinct for the same Process. Output-only and explanation-requiring applications have actual, scoped grounds; an external assessor can certify the former without the process providing an internal explanation. Duplicating inventory does not add represented operations. + +**Premises and representation:** OutputContract requires n + n for every natural input. ExplanationContract requires a provided Program whose evaluation equals that very process’s output at every input. processScope fixes the assessed process by equality; its canonical articulation and facet use that same scope and contract. ExternalCertificate is indexed by the actual process and distinguishes assessor 42 from assessed participant 7. + +**Proof or check:** Concrete evaluation proves both processes double their inputs; outputOnlyProcess has none, while explainedProcess supplies doubleInput. The same output-only process refutes the stronger full contract under its inhabited object scope. externalAssessment constructs the full output proof rather than assuming its truth; inventoryNotCapability proves available-operation membership unchanged by duplication. + +**Limits:** These arithmetic contracts are application choices, not a universal definition of capability or understanding. The explanation contract concerns an explicit certificate, not unobserved mental understanding; external participant identifiers do not establish real-world provenance. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.capabilities#p1](#source-organon-grounds-capabilities-p1), [organon.grounds.capabilities#p2](#source-organon-grounds-capabilities-p2) + +### `CoreReader.Evidence.outputNotExplanation` + +[leanified/CoreReader/Evidence.lean:793](#line-code-leanified-corereader-evidence-lean-793) · case + +Core dependencies: `propext`. + +```lean +theorem outputNotExplanation : OutputContract outputOnlyProcess ∧ + ¬ ExplanationContract outputOnlyProcess ∧ OutputContractEvidence := +``` + +### `CoreReader.Evidence.applicationContractsDiffer` + +[leanified/CoreReader/Evidence.lean:801](#line-code-leanified-corereader-evidence-lean-801) · case + +Core dependencies: `propext`. + +```lean +theorem applicationContractsDiffer : + (OutputContract outputOnlyProcess ∧ ¬ (OutputContract outputOnlyProcess ∧ ExplanationContract outputOnlyProcess)) ∧ + (OutputContract explainedProcess ∧ ExplanationContract explainedProcess) ∧ + ScopedApplicationEvidence := +``` + +### `CoreReader.Evidence.externalAssessment` + +[leanified/CoreReader/Evidence.lean:821](#line-code-leanified-corereader-evidence-lean-821) · case + +Core dependencies: `propext`. + +```lean +theorem externalAssessment : + (∃ certificate : ExternalCertificate outputOnlyProcess, + certificate.assessorId = 42 ∧ certificate.assessedId = 7 ∧ + certificate.assessorId ≠ certificate.assessedId ∧ OutputContract outputOnlyProcess) ∧ + ProcessGrounds outputOnlyProcess OutputContract ∧ + ¬ ExplanationContract outputOnlyProcess := +``` + +### `CoreReader.Agency.inventoryNotCapability` + +[leanified/CoreReader/Agency.lean:85](#line-code-leanified-corereader-agency-lean-85) · theorem + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem inventoryNotCapability (kind : InventoryKind) (ops : List Operation) (op : Operation) : + Available ((ops.map fun x => Item.mk kind x) ++ (ops.map fun x => Item.mk kind x)) op ↔ + Available (ops.map fun x => Item.mk kind x) op := by +``` + + + +## T22 · Relevant implementation reasons + +Status alone cannot satisfy the represented implementation-choice norm. An existing conventional implementation can satisfy it when its actual behavior supplies a relevant reason and it meets the requirements. + +**Premises and representation:** JustifiedChoice requires feasibility plus a listed Relevant reason. The adopted Relevant definition excludes status reasons and checks actual method content against requirements. The concrete identity application requires identity outputs, budget 1 and admits the output reason. + +**Proof or check:** statusOnlyFails unfolds the status branch for any requirements, implementation and status reason. conventionWithReason evaluates the conventional/established identity implementation and constructs its output-based justification. + +**Limits:** The exclusion is an explicitly adopted choice norm, not a value-neutral theorem. This case neither rejects all existing implementations nor proves the chosen requirements universally adequate. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.implementations#p1](#source-organon-grounds-implementations-p1), [organon.grounds.implementations#p2](#source-organon-grounds-implementations-p2) + +### `CoreReader.Choice.statusOnlyFails` + +[leanified/CoreReader/Choice.lean:58](#line-code-leanified-corereader-choice-lean-58) · theorem + +Core dependencies: `propext`. + +```lean +theorem statusOnlyFails (req : Requirements) (i : Implementation) (k : StatusKind) : + ¬ JustifiedChoice req i [.status k] := by +``` + +### `CoreReader.Choice.conventionWithReason` + +[leanified/CoreReader/Choice.lean:116](#line-code-leanified-corereader-choice-lean-116) · case + +Core dependencies: `propext`. + +```lean +theorem conventionWithReason : + identityImpl.conventional = true ∧ identityImpl.established = true ∧ + JustifiedChoice identityRequirements identityImpl [.status .convention, .method .output] := by +``` + + + +## T23 · An accurate assessment does not enforce the extra choice norm + +Two independently specified choice policies complete the same accurate negative status-priority audit yet differ on the additional choice norm: the status-only policy fails and the output-reason policy passes. + +**Premises and representation:** Both policies select identity and share the true conventional/established facts, the exact question whether those facts entail identity priority, and report false. Only priorityReasons changes. GeneralAssessmentFulfilled records articulation and accurate completion of this audit; AdditionalChoiceNorm separately checks JustifiedChoice. + +**Proof or check:** generalGroundsNotChoice retains the status non-entailment countermodel and includes PolicyIndependenceExample. The successor interpretation satisfies the same status facts but refutes priority; statusOnlyFails and identityJustified then establish the opposed policy results without changing that audit. + +**Limits:** The result concerns fulfillment of the specified assessment procedure, not full philosophical Grounds. Continuing to prioritize unsupported status can also violate general support proportionality; this theorem does not claim otherwise or prove the choice norm independent of every core obligation. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.implementations#p1](#source-organon-grounds-implementations-p1), [organon.grounds.implementations#p2](#source-organon-grounds-implementations-p2), [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +### `CoreReader.Choice.generalGroundsNotChoice` + +[leanified/CoreReader/Choice.lean:284](#line-code-leanified-corereader-choice-lean-284) · case + +Core dependencies: `propext`. + +```lean +theorem generalGroundsNotChoice : + (Articulated priorityArticulation ∧ AssessmentAccurate false ∧ + (∀ selected, Models statusFacts selected) ∧ + priorityClaim .identity ∧ ¬ priorityClaim .successor ∧ + ¬ Entails statusFacts priorityClaim ∧ + ¬ JustifiedChoice identityRequirements identityImpl [.status .standing]) ∧ + PolicyIndependenceExample := +``` + + + +## T24 · Openness does not imply equivalence or plurality + +An open choice setting may have only one feasible represented candidate. Local agreement does not make implementations equivalent, and eligible internal-method reasons need not suffice for selection when a required output is wrong. + +**Premises and representation:** The candidate type contains identity and successor, evaluated against identity outputs and budget 1. Relevant internal reasons are selected by Requirements.values and checked for faithful explanation, applicability, cost or procedure. A separate cheap successor costs 1 but still returns n + 1. + +**Proof or check:** singleFeasible identifies the unique feasible candidate. localNotGlobal contrasts agreement at 0 with disagreement at 1. internalReasons validates four real reasons for identity and includes a cheap-but-wrong counterexample. openNotEquivalent retains justified identity choice while proving its output differs from successor. + +**Limits:** Uniqueness is relative to these two candidates and stated requirements. Relevance is not sufficient feasibility, and openness does not entail equal merit, mandatory plurality or rejection of the existing option. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.implementations.limits#p1](#source-organon-grounds-implementations-limits-p1) + +### `CoreReader.Choice.singleFeasible` + +[leanified/CoreReader/Choice.lean:132](#line-code-leanified-corereader-choice-lean-132) · case + +Core dependencies: `propext`, `Classical.choice`, `Quot.sound`. + +```lean +theorem singleFeasible : + (∀ candidate, Feasible identityRequirements (implementation candidate) ↔ candidate = .identity) ∧ + JustifiedChoice identityRequirements identityImpl objectiveReason := by +``` + +### `CoreReader.Choice.localNotGlobal` + +[leanified/CoreReader/Choice.lean:146](#line-code-leanified-corereader-choice-lean-146) · case + +Core dependencies: none. + +```lean +theorem localNotGlobal : + (∀ x, x = 0 → identityImpl.run x = changedOutsideZero.run x) ∧ + identityImpl.run 1 ≠ changedOutsideZero.run 1 := by +``` + +### `CoreReader.Choice.internalReasons` + +[leanified/CoreReader/Choice.lean:168](#line-code-leanified-corereader-choice-lean-168) · case + +Core dependencies: none. + +```lean +theorem internalReasons : + Relevant identityRequirements identityImpl (.method .explanation) ∧ + Relevant identityRequirements identityImpl (.method .applicability) ∧ + Relevant identityRequirements identityImpl (.method .simplicity) ∧ + Relevant identityRequirements identityImpl (.method .procedure) ∧ + (Relevant identityRequirements cheapSuccessor (.method .simplicity) ∧ + ¬ JustifiedChoice identityRequirements cheapSuccessor [.method .simplicity]) := by +``` + +### `CoreReader.Choice.openNotEquivalent` + +[leanified/CoreReader/Choice.lean:182](#line-code-leanified-corereader-choice-lean-182) · case + +Core dependencies: `propext`. + +```lean +theorem openNotEquivalent : + JustifiedChoice identityRequirements identityImpl objectiveReason ∧ + identityImpl.run 0 ≠ successorImpl.run 0 := by +``` + + + +## T25 · Mutual application in one system + +The shared system maintains consistency through an acknowledged revision, carries owned assessment work and grounds for its own capability, assesses its general grounds provision, and evaluates its current philosophical method using relevant proposal decisions rather than status. + +**Premises and representation:** The examples use actualSystem and actual. The revised theory adds the same method’s input-0 fact and changes revision identity. GroundsProvision quantifies over arbitrary represented claims and facet packages under apply/waive permissions. The current philosophy method shares the system’s principle form and governance mode and is assessed on two specified proposal inputs. + +**Proof or check:** revisionKeepsConsistency reuses the same admissible witness and rejects a false change report. ownCapabilityGrounded combines owned assessment work with matching output grounds. groundsSelfAssessment evaluates the general provision through the grounds commitment’s actual acceptance/rejection consequences and relevant criticism. existingPhilosophyNotPrivileged proves acceptance of the valid proposal, rejection of the cheap wrong one, status-only failure and output-based justification for this actual method. + +**Limits:** These are constructed results for one system. Owned assessment work and capability grounds are separately checked components, not a claim that one work record contains the entire capability proof. Classical decision definitions are mathematical devices; the value adapter does not establish ultimate justification of the philosophy. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +### `CoreReader.Integration.revisionKeepsConsistency` + +[leanified/CoreReader/Integration.lean:144](#line-code-leanified-corereader-integration-lean-144) · theorem + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem revisionKeepsConsistency : + Charter actualSystem actual ∧ Consistent revisedHeld context ∧ + TruthfulReport initialSnapshot revisedSnapshot true ∧ + ¬ TruthfulReport initialSnapshot revisedSnapshot false := by +``` + +### `CoreReader.Integration.ownCapabilityGrounded` + +[leanified/CoreReader/Integration.lean:165](#line-code-leanified-corereader-integration-lean-165) · theorem + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem ownCapabilityGrounded : + OwnCapabilityDuty actualSystem actual [capabilityFacet] ∧ capability actual := by +``` + +### `CoreReader.Integration.groundsSelfAssessment` + +[leanified/CoreReader/Integration.lean:443](#line-code-leanified-corereader-integration-lean-443) · theorem + +Core dependencies: `propext`, `Classical.choice`, `Quot.sound`. + +```lean +theorem groundsSelfAssessment : + Grounds (fun w => GroundsProvision w.2) canonicalArticulation + (fun f => f = commitmentFacet .grounds) [commitmentFacet .grounds] ∧ + (commitmentPosition .grounds).limits actual ∧ + (commitmentPosition .grounds).relevantCriticism actual ∧ + ¬ ValueProcedure (commitmentPositionFor .grounds .waive) := by +``` + +### `CoreReader.Integration.existingPhilosophyNotPrivileged` + +[leanified/CoreReader/Integration.lean:497](#line-code-leanified-corereader-integration-lean-497) · theorem + +Core dependencies: `propext`, `Classical.choice`, `Quot.sound`. + +```lean +theorem existingPhilosophyNotPrivileged : + (currentPhilosophy actualSystem actual).form = actualSystem.principleForm ∧ + (currentPhilosophy actualSystem actual).mode = actualSystem.governance actual ∧ + ¬ JustifiedChoice proposalRequirements + (currentPhilosophy actualSystem actual).implementation [.status .standing] ∧ + JustifiedChoice proposalRequirements + (currentPhilosophy actualSystem actual).implementation [.method .output] ∧ + (currentPhilosophy actualSystem actual).review 0 = 1 ∧ + (currentPhilosophy actualSystem actual).review 1 = 0 := by +``` + + + +## T26 · Distinct commitments and their combination + +Generative orientation alone does not ensure Reflexive work, and a charter-satisfying system can still present inadequate evidence for its own capability. A shared witness also shows the represented commitments can all be met together. + +**Premises and representation:** The first counterexample combines openPolicy with an empty work list despite an applicable system assessment. The second retains actualSystem, actual and its charter, but substitutes true cost-allowance evidence for the output-capability claim. jointWitness uses the matching capability evidence and complete owned work instead. + +**Proof or check:** generationNotReflexivity derives the missing applicable work from a supposed Reflexive proof. charterNotGrounds keeps a wrong-output world compatible with the cost record. jointWitness supplies one actual pair with admissibility, charter, capability duty, justified choice and each commitment’s grounds. + +**Limits:** These results establish the stated separations and coexistence, not complete pairwise logical independence of all commitments, a priority hierarchy, or automatic grounds for every charter-compliant claim. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +### `CoreReader.Agency.generationNotReflexivity` + +[leanified/CoreReader/Agency.lean:257](#line-code-leanified-corereader-agency-lean-257) · case + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem generationNotReflexivity : + Generative openPolicy ∧ ¬ Reflexive 0 (ownRules 0) [] := by +``` + +### `CoreReader.Integration.charterNotGrounds` + +[leanified/CoreReader/Integration.lean:577](#line-code-leanified-corereader-integration-lean-577) · case + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem charterNotGrounds : + Charter actualSystem actual ∧ + Compatible [costAllowanceRecord] actual ∧ + ¬ Grounds capability canonicalArticulation + (fun f => f = unsupportedCapabilityFacet) [unsupportedCapabilityFacet] := by +``` + +### `CoreReader.Integration.jointWitness` + +[leanified/CoreReader/Integration.lean:595](#line-code-leanified-corereader-integration-lean-595) · case + +Core dependencies: `propext`, `Classical.choice`, `Quot.sound`. + +```lean +theorem jointWitness : + ∃ s : System, ∃ w : World, + Admissible (systemHeld s) (systemContext s) w ∧ Charter s w ∧ + OwnCapabilityDuty s w [capabilityFacet] ∧ systemCapability s w ∧ + JustifiedChoice s.requirements (s.method.realize w) objectiveReason ∧ + (∀ c : Commitment, Grounds (commitmentClaim c) canonicalArticulation + (fun f => f = commitmentFacet c) [commitmentFacet c]) ∧ + s = actualSystem ∧ w = actual := by +``` + + + +## T27 · Application duties and individual reasons + +An application that satisfies the adopted ApplicationDuties retains Reflexive work and all actually applicable, correctly articulated grounds for its own contract claim. Each of the five shared commitments separately has matched value grounds, joint adoption and relevant criticism, while its waive variant fails the chosen procedure. In the registered variation, the same evidence still supports the identity contract but does not support the changed successor contract. + +**Premises and representation:** applicationRetainsDuties takes a System, World, Requirements, arbitrary contract, facet-indexed articulations, applicability predicate and facet list, and assumes ApplicationDuties for those exact parameters. reasonsBelongToCommitments takes one of generation, consistency, reflexivity, grounds or choice; each position shares the governance choice but has its own actual consequence, reasons, constraints and criticism. + +**Proof or check:** The application theorem projects the assumed obligation, including same-claim equality and FacetArticulated for every listed facet. The commitment theorem constructs canonical grounds and joint witnesses, checks nonvacuous criticism, and contrasts apply with waive using actual operation expansion, contradiction handling, self-test coverage, evidence acceptance and implementation decisions. The supplementary applicationVariation case holds the system and observation fixed: the identity contract has matching grounds, whereas the successor contract fails at actual input 0 and its attempted empirical facet is rejected. + +**Limits:** The general application result does not prove arbitrary applications comply. The five reasons belong to distinct commitment positions in one selected option/outcome adapter; their checks do not derive normative authority from facts or prove all possible value reasons deductively sufficient. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +### `CoreReader.Integration.applicationRetainsDuties` + +[leanified/CoreReader/Integration.lean:529](#line-code-leanified-corereader-integration-lean-529) · theorem + +Core dependencies: `propext`. + +```lean +theorem applicationRetainsDuties (s : System) (w : World) (req : Requirements) + (contract : Requirements → Implementation → Prop) + (articulations : Facet World → Articulation World) + (applicable : Facet World → Prop) (facets : List (Facet World)) + (h : ApplicationDuties s w req contract articulations applicable facets) : + Reflexive s.owner (s.rules w) (s.work w) ∧ + (∀ f, applicable f → f ∈ facets) ∧ + (∀ f ∈ facets, f.claim = applicationClaim s req contract ∧ + Articulated (articulations f) ∧ FacetArticulated (articulations f) f ∧ FacetDischarged f) := +``` + +### `CoreReader.Integration.reasonsBelongToCommitments` + +[leanified/CoreReader/Integration.lean:423](#line-code-leanified-corereader-integration-lean-423) · theorem + +Core dependencies: `propext`, `Classical.choice`, `Quot.sound`. + +```lean +theorem reasonsBelongToCommitments (c : Commitment) : + Grounds (commitmentClaim c) canonicalArticulation + (fun f => f = commitmentFacet c) [commitmentFacet c] ∧ + JointAdoption (commitmentPosition c) ∧ + (commitmentPosition c).relevantCriticism actual ∧ + ¬ ValueProcedure (commitmentPositionFor c .waive) := by +``` + +### `CoreReader.Integration.applicationVariation` + +[leanified/CoreReader/Integration.lean:556](#line-code-leanified-corereader-integration-lean-556) · supplementary case + +Core dependencies: `propext`, `Quot.sound`. + +```lean +theorem applicationVariation : + ApplicationDuties actualSystem actual identityRequirements outputContract + canonicalArticulation (fun f => f = capabilityFacet) [capabilityFacet] ∧ + ¬ applicationClaim actualSystem successorRequirements outputContract actual ∧ + ¬ Grounds (applicationClaim actualSystem successorRequirements outputContract) + canonicalArticulation (fun f => f = changedObjectiveFacet) [changedObjectiveFacet] := by +``` + + + +## T28 · Assessment without observation tests + +A matched inferential assessment can have Grounds without an observation test, while a separately applicable empirical facet still uses observations. + +**Premises and representation:** The inferential facet explicitly assumes n = 2 and concludes n + 1 = 3, with canonical articulation and a nonempty model. The empirical comparison is the actual switch observation facet; usesObservation classifies the facet form. + +**Proof or check:** nonExecutableAssessment builds Grounds for the arithmetic claim from its satisfiable premise and semantic entailment, proves usesObservation is false there, and includes the discharged empirical switch facet with usesObservation true. + +**Limits:** The theorem separates assessment from observational testing; it does not prove this arithmetic reasoning uncomputable, classify every non-executable method or waive applicable empirical responsibilities. + +**State:** accepted (satisfiability). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.relationships.terms#p1](#source-organon-relationships-terms-p1), [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +### `CoreReader.Evidence.nonExecutableAssessment` + +[leanified/CoreReader/Evidence.lean:840](#line-code-leanified-corereader-evidence-lean-840) · case + +Core dependencies: `propext`. + +```lean +theorem nonExecutableAssessment : + Grounds (fun n : Nat => n + 1 = 3) canonicalArticulation (fun f => f = arithmeticFacet) [arithmeticFacet] ∧ + usesObservation arithmeticFacet = false ∧ + FacetDischarged switchEmpirical ∧ usesObservation switchEmpirical = true := by +``` + + +## Source tracing appendix + + + + +### `organon.preamble#p1` + +```text +This is the authoritative statement of Organon’s philosophy. It expresses adopted commitments, not factual assertions about every system or a proof of universal correctness. +``` + +State: **not_applicable**; Lean: passed; fidelity: not_applicable. + + + +This paragraph is cited as authority and interpretive context. The linked declarations do not prove the meta-level statement; its conditions remain in force. + +This declares textual authority and adopted-commitment scope, not a mathematical proposition about all systems. The review retains this boundary without manufacturing a Lean theorem of authority. + +Related targets: [T01](#t01), [T02](#t02). + + + + + + +### `organon.preamble#p2` + +```text +The quoted provisions, their meanings, and their conditions of application form the core. The charter and Grounds constrain one another; their grouping establishes neither a deductive hierarchy nor an order of priority. [Rationale](rationale/README.md) supplies arguments and cases without adding obligations to this core. Skills are revisable applications under the repository’s stated objectives and constraints, not part of the philosophical commitments themselves. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The shared model exhibits compatible constraints without a chapter-priority inference. Authority of meanings and limits, the role of Rationale and revisability of actual skills remain textual commitments outside this finite witness. + +Related targets: [T01](#t01), [T02](#t02). + + + + + + +### `organon.charter` + +```text + + +``` + +State: **not_applicable**; Lean: not_checked; fidelity: not_applicable. + +Structural heading without substantive direct-body content; no theorem is assigned. + + + + + + +### `organon.charter.overview#p1` + +```text +**Self-Transcendence · Internal Consistency · Reflexivity** +``` + +State: **not_applicable**; Lean: not_checked; fidelity: not_applicable. + +This is a structural list of three headings. It organizes substantive provisions and requires no fabricated theorem. + +Related targets: [T01](#t01). + + + + + + +### `organon.charter.overview#p2` + +```text +> A system is intrinsically oriented toward expanding what it can understand and construct. It brings itself and its principles within the scope of generation and assessment, with internal consistency constraining this process. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +jointWitness combines valued expansion, revisability, contextual consistency and contentful owned principle work in one inhabited system. It proves model satisfiability, not actual compliance by arbitrary systems. + +Related targets: [T01](#t01), [T02](#t02), [T03](#t03). + + + + + + +### `organon.charter.overview#p3` + +```text +The overview connects three distinct requirements: self-transcendence establishes a generative orientation and refuses to treat existing forms as final, internal consistency constrains judgments held simultaneously, and reflexivity brings the system and its principles within the scope of their own generation and assessment. The provisions below specify the conditions for each. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The three requirements remain distinct predicates with a shared example and specific nonentailments. Their interpretation as philosophical obligations and their full conditions in arbitrary applications are not derived from the example. + +Related targets: [T01](#t01), [T02](#t02), [T03](#t03). + + + + + + +### `organon.charter.self-transcendence#p1` + +```text +> A system is intrinsically oriented toward expanding what it can understand and construct. It does not regard any existing form as the endpoint of generation. +``` + +State: **incomplete**; Lean: passed; fidelity: partial. + +Generative specifies valuation and revisability of current forms. The finite tags and state examples do not characterize every form of understanding, construction or intrinsic orientation. + +Related targets: [T03](#t03). + + + + + + +### `organon.charter.self-transcendence.orientation#p1` + +```text +A commitment to keeping generative possibilities open is distinct from valuing their expansion. A system has an intrinsic orientation when it regards that expansion as worth pursuing. Merely permitting change does not fully express this orientation. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The neutral-policy counterexample separates permission for distinct versions from the adopted valuation predicate. It does not establish what every real system values or justify the adopted value universally. + +Related targets: [T03](#t03), [T04](#t04). + + + + + + +### `organon.charter.self-transcendence.non-finality#p1` + +```text +Refusing to regard an existing form as an endpoint keeps it open to being surpassed. “Existing form” includes a system’s current organization, methods, and principles, not only its appearance or artifacts. These remain within the scope of possible change; their revisability does not guarantee actual progress. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +All five represented form kinds, including organization, method and principle, fall under conditional revisability; a constant trace shows no progress guarantee. The chosen representation is not an exhaustive ontology or an executed revision. + +Related targets: [T03](#t03), [T05](#t05). + + + + + + +### `organon.charter.self-transcendence.limits#p1` + +```text +Whether progress has actually occurred remains a separate judgment. Having the orientation does not guarantee progress. Progress cannot be established merely by an increase in the number of artifacts, levels of abstraction, or terms. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The same before/after states increase inventory, abstraction and vocabulary without adding represented capabilities. Actual performance records can distinguish a genuine extension in a two-case world; empirical reliability beyond that world is not proved. + +Related targets: [T03](#t03), [T06](#t06), [T07](#t07). + + + + + + +### `organon.charter.self-transcendence.limits#p2` + +```text +- “Intrinsic orientation” expresses Organon’s philosophical commitment; it does not assert that all systems in fact develop autonomously. +- Self-transcendence does not imply independence from external experience, knowledge, or collaboration, nor does it guarantee autonomous execution or self-improvement. +- Refusing to regard an existing form as an endpoint does not require every action to produce change. Justified stability can coexist with a generative orientation. +- Whether transcendence expands what can be understood and constructed requires discernible grounds; a system’s own claim of generation does not establish actual achievement. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Bound execution exhibits separate external dependencies, grounded stability, a nonimproving trace and a refuted owned announcement. These are finite compatibility and failure examples; philosophical adoption and real autonomous development remain outside their conclusions. + +Related targets: [T03](#t03), [T06](#t06), [T07](#t07). + + + + + + +### `organon.charter.consistency#p1` + +```text +> The principles and judgments a system holds simultaneously, together with their implications, must not yield contradictory judgments on the same question under the same assumptions, meanings of terms, and scope of application. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The general semantic theorem prevents opposite consequences under one theory/context when an admissible world exists. Existence of such a world, choice of questions and interpretation of held judgments are explicit modeling conditions, not guaranteed for reality. + +Related targets: [T08](#t08). + + + + + + +### `organon.charter.consistency.meaning#p1` + +```text +“Held simultaneously” specifies which principles, judgments, and implications must hold together. Revision may withdraw an earlier judgment; old and new principles need not remain compatible forever. When a change has occurred, that change cannot be represented as though it had not occurred. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Concrete retraction slices can reverse judgments, and a conditional reporting specification disallows concealing recognized change. No automatic detector, adequate report generator or real revision history is established. + +Related targets: [T09](#t09), [T10](#t10). + + + + + + +### `organon.charter.consistency.meaning#p2` + +```text +“The same assumptions, meanings of terms, and scope of application” specifies the basis for comparing judgments. Divergent judgments under different conditions do not automatically constitute contradictions. Nor can unacknowledged changes in assumptions, meanings, or scope be used to conceal an existing contradiction. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Separate assumption, meaning and scope changes admit different judgments; hidden changes fail the adopted report condition. This covers explicit semantic models, not every practical ambiguity or method of concealment. + +Related targets: [T09](#t09), [T10](#t10). + + + + + + +### `organon.charter.consistency.limits#p1` + +```text +- Tension between different assessments or values does not directly constitute a contradiction. Revision or qualification is needed when they require incompatible conclusions under the same conditions. +- Internal consistency is not correctness or sufficiency. A set of principles may be internally consistent while relying on false assumptions or neglecting important questions. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Finite witnesses distinguish tension from contradiction and consistency from truth or completeness. Refusing to retain a demonstrated conflict is a conditional consequence of an adopted consistency requirement, not an implemented revision strategy. + +Related targets: [T11](#t11), [T12](#t12). + + + + + + +### `organon.charter.reflexivity#p1` + +```text +> A system’s principles of generation and assessment also apply to the system itself and to the formation, application, and revision of those principles. +``` + +State: **incomplete**; Lean: passed; fidelity: partial. + +Reflexive quantifies applicable owned rules and subjects, with coherent keys and meaningful application records. The concrete rule set has generation and assessment work but does not cover every possible real principle. + +Related targets: [T13](#t13). + + + + + + +### `organon.charter.reflexivity.meaning#p1` + +```text +Reflexivity encompasses both the system itself and its principles. Assessment concerns not only whether the system conforms to its principles, but also how those principles are formed, where they apply, and why they may need revision. The formation and revision of principles thus also become objects of generation and assessment. +``` + +State: **incomplete**; Lean: passed; fidelity: partial. + +The revised module models formation purposes, requested applicability scopes and revision counterexamples with actual evaluation and generation outcomes. These finite inquiry contracts do not establish the correctness or completeness of every assessment methodology. + +Related targets: [T13](#t13). + + + + + + +### `organon.charter.reflexivity.limits#p1` + +```text +- Applying principles equally retains their conditions of application. When the relevant conditions hold, being the system itself is not a basis for exemption. Nor does the requirement of reflexivity establish that every principle can be applied to itself without examining its applicability. +- Self-application does not constitute self-proof. Subjecting a principle to its own assessment does not thereby establish its correctness. +- That a revision is produced by the system itself does not give it sufficient grounds. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Applicability is retained, self-exemption fails where conditions hold, and finite self-tests plus a produced revision fail to establish universal support. The owned records and source identities are mathematical objects, not authenticated execution histories. + +Related targets: [T13](#t13), [T14](#t14). + + + + + + +### `organon.grounds#p1` + +```text +> The grounds of principles and judgments must be articulable and subject to assessment appropriate to the nature of the claim. The strength and scope of a claim must be proportionate to the support provided by its grounds. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Grounds checks identified applicable facets of the same claim; support, entailment and an option-indexed value procedure carry distinct responsibilities. This is a chosen formal interface and finite fulfillment examples, not a universal sufficient criterion for all philosophical grounds. + +Related targets: [T07](#t07), [T15](#t15). + + + + + + +### `organon.grounds.assessment#p1` + +```text +Articulation and assessment have distinct responsibilities. Articulability requires that concepts, assumptions, reasons, and limits can be identified. Assessment requires examining whether those grounds support the corresponding claim. Clearly expressed grounds are not thereby sufficiently established. When a claim has more than one applicable aspect, the corresponding assessment responsibilities apply to each aspect. Omitting a classification does not waive an applicable responsibility. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Articulation content is linked to each facet and separated from its discharge; union and missing-aspect examples prevent labels from waiving represented duties. Identifying every actually relevant aspect remains an application responsibility not solved by the datatype. + +Related targets: [T15](#t15), [T16](#t16), [T17](#t17), [T18](#t18), [T28](#t28). + + + + + + +### `organon.grounds.assessment#p2` + +```text +| Type of claim | Responsibility of assessment | What cannot substitute for that responsibility | +| --- | --- | --- | +| Empirical claim | Examine observations, evidence, and performance, together with the conditions, scope, and uncertainty of their support for the claim. | Treating measurability or repeatability itself as proof of relevance, correctness, or value. | +| Inferential claim | Examine whether the conclusion is supported by the stated assumptions and inferential relations. | Treating the absence of conflict between a conclusion and its assumptions as sufficient to establish that the conclusion follows from them. | +| Value commitment | State the position taken, its reasons, limits of application, and consequences, and remain open to relevant criticism. | Presenting a commitment as an empirical fact or a necessary inference, or substituting self-assertion for reasons. | +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The three modeled adapters check observational compatibility/support, semantic entailment, and value reasons with limits/consequences/criticism. Actual relevance, empirical uncertainty and the adequacy of value criticism beyond the chosen cases are not exhaustively formalized. + +Related targets: [T15](#t15), [T16](#t16), [T17](#t17), [T18](#t18), [T28](#t28). + + + + + + +### `organon.grounds.assessment#p3` + +```text +Initial value commitments may be stated explicitly as commitments; they need not prove all their own starting assumptions. The strength and scope of a claim do not require conversion to a common numerical scale. Different types of claims specify their support and limits in accordance with their nature. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +JointAdoption requires consistent instantiated starting commitments without proving all starting assumptions. A two-reason example and heterogeneous facets avoid a universal numerical scale. They demonstrate procedural consistency, not ultimate value justification. + +Related targets: [T15](#t15), [T16](#t16), [T17](#t17), [T18](#t18), [T28](#t28). + + + + + + +### `organon.grounds.scope#p1` + +```text +Performance is discerned within particular relations, conditions, and scopes of observation. A boundary helps specify what a comparison concerns, but local examples do not automatically support unconditional universal conclusions. A judgment cannot establish that relevant differences do not exist merely because its chosen scope omits them. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +A proper local observation scope supports a local function claim while admitting a counterexample outside it. This establishes the specified nonentailment; it neither identifies all relevant real differences nor rules out justified wider evidence. + +Related targets: [T19](#t19), [T20](#t20). + + + + + + +### `organon.grounds.scope#p2` + +```text +Measurement can make some differences comparable. Repeated assessment can help examine the stability of corresponding conclusions. Their roles, and the role of any assessment framework, must be explained relative to the claim and its context. Measurement, repeatability, and an assessment framework do not form a universally necessary chain on which all judgments must depend. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Repeated irrelevant measurements fail support, while a valid inferential assessment needs no empirical chain. This refutes a universal mandatory chain within the represented responsibilities but does not characterize every framework or measurement practice. + +Related targets: [T19](#t19), [T20](#t20). + + + + + + +### `organon.grounds.scope#p3` + +```text +An observation that has not been reproduced may still offer limited support, and random outcomes need not be identical on every occasion. The verifiability of observations, reproducibility of conditions, and stability of conclusions must be distinguished. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +A single observation has limited support and distinct trial outcomes preserve a fixed bound. Verification, reproducible conditions and conclusion stability use separate predicates; no probability distribution or general reproducibility law is proved. + +Related targets: [T19](#t19), [T20](#t20). + + + + + + +### `organon.grounds.capabilities#p1` + +```text +Capability claims are subject to Grounds: the capability claimed, its conditions, and the support for it must be identifiable. The core does not prescribe uniform definitions of method mastery, method generation, or capability levels. Applications specify the capabilities they assess and may require understanding, explanation, or performance under relevant variations. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Output-only and explanation-bearing contracts concern the same process and each has its own checked Grounds; applicationVariation changes the actual objective and invalidates old evidence. No uniform real mastery or capability-level definition is derived. + +Related targets: [T07](#t07), [T21](#t21). + + + + + + +### `organon.grounds.capabilities#p2` + +```text +Grounds for a capability claim may be supplied by an external assessor. Their articulability does not by itself require the assessed system to understand or explain its internal generation process. Evidence of reliable output must be assessed against the capability actually claimed; it does not automatically establish understanding of that process. Nor can the number of method documents, terms, tools, or artifacts alone establish a capability beyond what that evidence supports. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +A distinct assessor role supplies a proof about the exact output process while no explanation certificate is attached; duplicating four inventory kinds leaves represented capability unchanged. Role numbers and certificates do not prove external provenance or human-like understanding. + +Related targets: [T07](#t07), [T21](#t21). + + + + + + +### `organon.grounds.implementations#p1` + +```text +> The choice of an implementation must be supported by reasons connected to the objectives and values pursued and to the relevant constraints. Its name, conventional use, or established status alone does not provide sufficient grounds for giving it priority. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The adopted choice interface requires feasibility and an objective/value/constraint-linked reason and rejects status-only reasons. Its finite reason vocabulary and concrete feasibility checks do not supply a general theory of warranted real implementation choice. + +Related targets: [T22](#t22), [T23](#t23). + + + + + + +### `organon.grounds.implementations#p2` + +```text +This choice provision adds an additional evaluative commitment: name, conventional use, or established status alone is insufficient to establish priority. Grouping it under Grounds does not mean that it follows from the general requirement to assess reasons, or merely from the discernibility of performance. Conventions and existing arrangements may have practical significance, but that significance must be connected to the objectives and values pursued and to the relevant constraints. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Two independent policies share a correct negative audit but differ on the added choice norm, establishing independence from the represented assessment procedure. This does not show an unsupported priority claim fully satisfies general Grounds, or derive a value commitment from neutral facts. + +Related targets: [T22](#t22), [T23](#t23). + + + + + + +### `organon.grounds.implementations.limits#p1` + +```text +- Openness does not make all implementations equivalent, nor does it guarantee multiple feasible implementations for the same objective. +- A method’s explanatory power, limits of application, simplicity, and explicit process requirements may all provide grounded reasons for assessment. They cannot be excluded merely because they concern methods internal to the implementation. +- Identical local performance does not establish overall equivalence. Relations, conditions, and the scope of comparison are constrained by the provisions of Grounds. +- Openness does not reject an implementation merely because it already exists or is conventionally used. Relevant reasons may still give it priority. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Concrete cases have one feasible candidate, unequal implementations, local agreement with wider difference and four eligible internal reasons. A cheap wrong-output method shows eligibility alone is insufficient. These results concern selected candidates and contracts, not all methods. + +Related targets: [T24](#t24). + + + + + + +### `organon.relationships` + +```text + + +``` + +State: **not_applicable**; Lean: not_checked; fidelity: not_applicable. + +Structural heading without substantive direct-body content; no theorem is assigned. + + + + + + +### `organon.relationships.roles#p1` + +```text +The charter states the generative orientation, the consistency constraint, and reflexive application. Grounds specifies support requirements for judgments and includes an additional commitment concerning implementation choices. Both parts belong to the core and constrain one another. Their placement neither makes Grounds a deduction from the charter nor gives the charter priority over it. Each commitment needs its own reasons. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +One shared model combines the charter and Grounds and assigns five commitments distinct operational reasons, limits and live criticism. Specified nonentailments prevent chapter order from doing logical work; neither the universal adoption nor ultimate justification of all commitments follows. + +Related targets: [T02](#t02), [T12](#t12), [T23](#t23), [T25](#t25), [T26](#t26), [T27](#t27). + + + + + + +### `organon.relationships.roles#p2` + +```text +Internal Consistency concerns whether simultaneously held judgments can hold together; Grounds concerns whether and how far a claim is supported. A conclusion may fail to conflict with its assumptions without being supported by them. Self-Transcendence specifies a generative orientation and non-finality; neither establishes actual capability. Applications may supply objectives, values, and capability definitions; claims made under those objectives, values, and definitions remain subject to the relevant core provisions. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Consistency/support and orientation/capability remain separate; changing an application objective changes its actual claim and can defeat retained evidence. Universal application compliance is only an assumed conditional interface, not an achieved fact. + +Related targets: [T02](#t02), [T12](#t12), [T23](#t23), [T25](#t25), [T26](#t26), [T27](#t27). + + + + + + +### `organon.relationships.roles#p3` + +```text +Self-Transcendence does not substitute for Reflexivity: keeping existing forms open to being surpassed differs from applying relevant principles to the system and to their own formation, application, and revision. Reflexivity extends these requirements to the system and to the formation, application, and revision of its principles. The grounds and limits of the Grounds provisions must themselves be articulable. The system’s own capability claims remain subject to assessment, and this philosophy’s existing form cannot gain priority merely from its established status. Such mutual application provides no self-proof and does not remove conditions of application. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Contentful self-application, exact own-capability assessment, the general Grounds provision and the same current philosophy method are linked in the model. Their checked coexistence supplies no self-proof, real execution guarantee or unconditional applicability. + +Related targets: [T02](#t02), [T12](#t12), [T23](#t23), [T25](#t25), [T26](#t26), [T27](#t27). + + + + + + +### `organon.relationships.terms#p1` + +```text +| Term | Meaning in this philosophy | +| --- | --- | +| Existing form | The system’s current organization, methods, and principles, not only its appearance or artifacts. | +| Assessment | Examination of reasons, applicability, and observed performance; not limited to executable tests. | +``` + +State: **limited**; Lean: passed; fidelity: partial. + +FormKind includes organization, methods and principles, and an inferential assessment has no executable-test requirement. These representations illustrate the terms without exhaustively defining every existing form or every non-test assessment. + +Related targets: [T05](#t05), [T28](#t28). + + + +## Complete code and line explanations + +Each file retains its exact checked contents. These line explanations are informed translations of the revised object; the initial blind account and rejected earlier judgments are retained separately. + + +### `leanified/CoreReader/Agency.lean` + + +```lean +import CoreReader.Reflexivity + +namespace CoreReader.Agency + +inductive FormKind | organization | method | principle | appearance | artifact + deriving DecidableEq, Repr + +structure Form where + kind : FormKind + version : Nat + deriving DecidableEq, Repr + +inductive Aim | expandUnderstandingAndConstruction | preserveSafeOperation + deriving DecidableEq, Repr + +/- A policy records an adopted valuation, current forms, and permission. It does not assert that valuation is correct or enacted. -/ +structure Policy where + worthPursuing : Aim → Prop + current : Form → Prop + revisable : Form → Prop + permitsVersion : Nat → Nat → Prop + +/- The normative specification keeps valuation and revisability separate from realized transitions. -/ +/-- organon-map CoreReader.Agency.Generative +organon.charter.overview#p2 sha256 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c +organon.charter.overview#p3 sha256 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c +organon.charter.self-transcendence#p1 sha256 f4ca590e2ae15e3882f70c7b2bc46a8911c97cee547c8b137b5493fbf862c8c0 +organon.charter.self-transcendence.orientation#p1 sha256 7f9b85c0816b3d69e417cf3cbe17b7b59931388f84d799ce6730c998037358bf +organon.charter.self-transcendence.non-finality#p1 sha256 4ae4497523e79e0606ab3849c47b6ea16f8888a952e063e6966eb36b750f3df8 +organon.charter.self-transcendence.limits#p1 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.charter.self-transcendence.limits#p2 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +-/ +def Generative (p : Policy) : Prop := + p.worthPursuing .expandUnderstandingAndConstruction ∧ + ∀ f, p.current f → p.revisable f + +def openPolicy : Policy where + worthPursuing a := a = .expandUnderstandingAndConstruction ∨ a = .preserveSafeOperation + current f := f.version = 0 + revisable _ := True + permitsVersion _ _ := True + +def neutralPolicy : Policy := { openPolicy with worthPursuing := fun _ => False } + +/- Permitting a real version change does not supply an adopted value position. -/ +/-- organon-map CoreReader.Agency.permissionNotValuation +organon.charter.self-transcendence.orientation#p1 sha256 7f9b85c0816b3d69e417cf3cbe17b7b59931388f84d799ce6730c998037358bf +-/ +theorem permissionNotValuation : + neutralPolicy.permitsVersion 0 1 ∧ (0 : Nat) ≠ 1 ∧ ¬ Generative neutralPolicy := by + simp [neutralPolicy, openPolicy, Generative] + +/- This is an explicit consequence of the adopted specification, not evidence of actual revision. -/ +/-- organon-map CoreReader.Agency.revisabilityCovers +organon.charter.self-transcendence.non-finality#p1 sha256 4ae4497523e79e0606ab3849c47b6ea16f8888a952e063e6966eb36b750f3df8 +organon.relationships.terms#p1 sha256 0d22f818e4466a5ab4272607ac0ab26997270cf05c64ce9ac547e866068907d1 +-/ +theorem revisabilityCovers (p : Policy) (h : Generative p) (k : FormKind) (v : Nat) + (hc : p.current ⟨k, v⟩) : p.revisable ⟨k, v⟩ := h.2 _ hc + +inductive Operation | copy | successor + deriving DecidableEq, Repr + +def Operation.run : Operation → Nat → Nat + | .copy, n => n + | .successor, n => n + 1 + +inductive InventoryKind | document | term | tool | artifact + deriving DecidableEq, Repr + +structure Item where + kind : InventoryKind + content : Operation + deriving DecidableEq, Repr + +/- Available represented operations are the contents present, not their number of occurrences. -/ +def Available (xs : List Item) (op : Operation) : Prop := + ∃ item ∈ xs, item.content = op + +/- Duplicating any inventory category preserves exactly the represented operation content. -/ +/-- organon-map CoreReader.Agency.inventoryNotCapability +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem inventoryNotCapability (kind : InventoryKind) (ops : List Operation) (op : Operation) : + Available ((ops.map fun x => Item.mk kind x) ++ (ops.map fun x => Item.mk kind x)) op ↔ + Available (ops.map fun x => Item.mk kind x) op := by + simp only [Available, List.mem_append] + constructor + · rintro ⟨x, hx | hx, hop⟩ <;> exact ⟨x, hx, hop⟩ + · rintro ⟨x, hx, hop⟩ + exact ⟨x, Or.inl hx, hop⟩ + +structure State where + understood : List Operation + constructed : List Operation + inventory : List Item + abstractionLayers : List Operation + vocabulary : List Operation + deriving DecidableEq, Repr + +/- A gain must identify an operation newly understood or constructed; this is a disclosed finite capability representation. -/ +def Expanded (before after : State) : Prop := + (∃ op, op ∈ after.understood ∧ op ∉ before.understood) ∨ + (∃ op, op ∈ after.constructed ∧ op ∉ before.constructed) + +def baseState : State := + ⟨[.copy], [.copy], [⟨.artifact, .copy⟩], [.copy], [.copy]⟩ + +def inflatedState : State := + { baseState with + inventory := baseState.inventory ++ baseState.inventory + abstractionLayers := [.copy, .copy] + vocabulary := [.copy, .copy] } + +def stableTrace (_time : Nat) : State := baseState + +/- A revisable policy can govern an unchanged trace; no improvement is hidden in revisability. -/ +/-- organon-map CoreReader.Agency.revisionWithoutProgress +organon.charter.self-transcendence.non-finality#p1 sha256 4ae4497523e79e0606ab3849c47b6ea16f8888a952e063e6966eb36b750f3df8 +organon.relationships.terms#p1 sha256 0d22f818e4466a5ab4272607ac0ab26997270cf05c64ce9ac547e866068907d1 +-/ +theorem revisionWithoutProgress : + Generative openPolicy ∧ + (∀ k : FormKind, openPolicy.revisable ⟨k, 0⟩) ∧ + (∀ t, ¬ Expanded (stableTrace t) (stableTrace (t + 1))) := by + simp [Generative, openPolicy, stableTrace, Expanded] + +structure ExternalResources where + experience : Option Nat + knowledge : Option Nat + collaborator : Option Nat + deriving DecidableEq, Repr + +/- This interpreter actually needs all three external inputs to produce the modeled result. -/ +def assistedExecution (r : ExternalResources) : Option Nat := do + let e ← r.experience + let k ← r.knowledge + let c ← r.collaborator + pure (Operation.copy.run (e + k + c)) + +def availableResources : ExternalResources := ⟨some 1, some 2, some 3⟩ + +/- Stability has a concrete stated reason in this workload: preserve its operation while staying within the one-item budget. -/ +def StableReason (before proposed : State) : Prop := + before.constructed = proposed.constructed ∧ + before.inventory.length ≤ 1 ∧ ¬ proposed.inventory.length ≤ 1 + +/- The policy, current capabilities, execution interface and workload constraints belong to one generating system. -/ +structure GeneratingSystem where + owner : Nat + policy : Policy + current : State + execute : ExternalResources → Option Nat + applicationBudget : Nat + requiredOperations : List Operation +/- The modeled system uses the assisted interpreter under a one-item budget and a copy-operation requirement. -/ +def generatingSystem : GeneratingSystem where + owner := 0 + policy := openPolicy + current := baseState + execute := assistedExecution + applicationBudget := 1 + requiredOperations := [.copy] +/- A stable action retains this system's own current state. -/ +def GeneratingSystem.stableAction (system : GeneratingSystem) : State := system.current +def GeneratingSystem.requirementsMet (system : GeneratingSystem) (state : State) : Prop := + ∀ operation, operation ∈ system.requiredOperations → operation ∈ state.constructed +def GeneratingSystem.withinBudget (system : GeneratingSystem) (state : State) : Prop := + state.inventory.length ≤ system.applicationBudget +/- An expansion report identifies the actual before/after states and the operation/performance it asserts was added. -/ +structure Announcement where + owner : Nat + before : State + after : State + reportedNewOperation : Operation + input : Nat + expectedOutput : Nat + deriving DecidableEq, Repr +/- Reports are generated by this system and identify its actual current state as their baseline. -/ +def GeneratingSystem.report (system : GeneratingSystem) (after : State) + (operation : Operation) (input expectedOutput : Nat) : Announcement := + ⟨system.owner, system.current, after, operation, input, expectedOutput⟩ +/- Report content is interpreted against those very states and the named operation's actual behavior. -/ +def Announcement.claim (report : Announcement) : Prop := + report.reportedNewOperation ∈ report.after.constructed ∧ + report.reportedNewOperation ∉ report.before.constructed ∧ + report.reportedNewOperation.run report.input = report.expectedOutput +/- A true report of this form entails a represented construction expansion. -/ +theorem announcementClaimImpliesExpansion (report : Announcement) (h : report.claim) : + Expanded report.before report.after := Or.inr ⟨report.reportedNewOperation, h.1, h.2.1⟩ +/- This concrete self-report asserts a successor operation for the actual inventory-only inflation. -/ +def inflatedAnnouncement : Announcement := generatingSystem.report inflatedState .successor 0 1 +/- The report asserts a real successor result but its named operation is absent from its own after-state. -/ +theorem inflatedAnnouncementRefuted : + inflatedAnnouncement.before = baseState ∧ inflatedAnnouncement.after = inflatedState ∧ + inflatedAnnouncement.reportedNewOperation = .successor ∧ + inflatedAnnouncement.input = 0 ∧ inflatedAnnouncement.expectedOutput = 1 ∧ + ¬ inflatedAnnouncement.claim ∧ ¬ Expanded inflatedAnnouncement.before inflatedAnnouncement.after := by + simp [inflatedAnnouncement, GeneratingSystem.report, generatingSystem, Announcement.claim, Expanded, baseState, inflatedState] + +/- These transitions share one initial state; only extension adds an actual new operation. -/ +inductive TransitionCase | inflate | extend + deriving DecidableEq, Repr + +def extendedState : State := + { baseState with understood := [.copy, .successor], constructed := [.copy, .successor] } +def transitionBefore (_transition : TransitionCase) : State := baseState +def transitionAfter : TransitionCase → State + | .inflate => inflatedState + | .extend => extendedState +/- Both alternatives are assessed under the same concrete input condition. -/ +def transitionInput (_transition : TransitionCase) : Nat := 0 +def transitionAnnouncement (transition : TransitionCase) : Announcement := + generatingSystem.report (transitionAfter transition) .successor (transitionInput transition) 1 + +/- Eleven boundary branches share a content-bearing trace and executable dependency model. They do not assert a universal law of human capability. -/ +/-- organon-map CoreReader.Agency.generationLimits +organon.charter.self-transcendence.limits#p1 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.charter.self-transcendence.limits#p2 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +-/ +theorem generationLimits : + Generative generatingSystem.policy ∧ + generatingSystem.policy.permitsVersion 0 0 ∧ + ¬ Expanded generatingSystem.current inflatedState ∧ + generatingSystem.current.inventory.length < inflatedState.inventory.length ∧ + generatingSystem.current.abstractionLayers.length < inflatedState.abstractionLayers.length ∧ + generatingSystem.current.vocabulary.length < inflatedState.vocabulary.length ∧ + generatingSystem.execute availableResources = some 6 ∧ + generatingSystem.execute { availableResources with experience := none } = none ∧ + generatingSystem.execute { availableResources with knowledge := none } = none ∧ + generatingSystem.execute { availableResources with collaborator := none } = none ∧ + generatingSystem.execute ⟨none, none, none⟩ = none ∧ + ¬ Expanded generatingSystem.current generatingSystem.stableAction ∧ + generatingSystem.stableAction = generatingSystem.current ∧ + generatingSystem.requirementsMet generatingSystem.stableAction ∧ + generatingSystem.withinBudget generatingSystem.stableAction ∧ + ¬ generatingSystem.withinBudget inflatedState ∧ + StableReason generatingSystem.current inflatedState ∧ + (inflatedAnnouncement = generatingSystem.report inflatedState .successor 0 1 ∧ + inflatedAnnouncement.owner = generatingSystem.owner ∧ + inflatedAnnouncement.before = generatingSystem.current ∧ inflatedAnnouncement.after = inflatedState ∧ + inflatedAnnouncement.reportedNewOperation = .successor ∧ + inflatedAnnouncement.input = 0 ∧ inflatedAnnouncement.expectedOutput = 1 ∧ + ¬ inflatedAnnouncement.claim ∧ ¬ Expanded inflatedAnnouncement.before inflatedAnnouncement.after) := by + simp [generatingSystem, GeneratingSystem.stableAction, GeneratingSystem.requirementsMet, + GeneratingSystem.withinBudget, GeneratingSystem.report, Generative, openPolicy, Expanded, + baseState, inflatedState, assistedExecution, availableResources, Operation.run, + StableReason, inflatedAnnouncement, Announcement.claim] + +/- The empty work log omits an actually applicable system assessment despite an open generative policy. -/ +/-- organon-map CoreReader.Agency.generationNotReflexivity +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem generationNotReflexivity : + Generative openPolicy ∧ ¬ Reflexive 0 (ownRules 0) [] := by + constructor + · simp [Generative, openPolicy] + · intro h + have bad := noSelfExemption 0 (ownRules 0) [] h (assessingRule 0) (by simp [ownRules]) + (.system 0) rfl (by simp [assessingRule, ownSubjects]) + simp [Performed] at bad + +/- The same proposed arithmetic principle is used in the self-test and in the universal correctness claim. -/ +def ownArithmeticPrinciple (n : Nat) : Bool := decide (n + 1 = 2 * n) + +def selfTest (samples : List Nat) : Bool := samples.all ownArithmeticPrinciple + +/- A genuine evaluation on the selected sample succeeds, while the same principle fails at zero. -/ +/-- organon-map CoreReader.Agency.selfTestDoesNotProve +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +theorem selfTestDoesNotProve : + selfTest [1] = true ∧ ownArithmeticPrinciple 0 = false ∧ + ¬ (∀ n, ownArithmeticPrinciple n = true) := by + constructor + · decide + constructor + · decide + · intro h + have bad := h 0 + contradiction + +end CoreReader.Agency +``` + + + + **L1** Imports CoreReader.Reflexivity and its dependencies into this module. + + + **L3** Opens namespace CoreReader.Agency; file boundaries do not change declaration identity. + + + **L5** Defines exactly five form tags; their names carry no additional semantics. + + + **L6** Generates decidable equality and display instances for the preceding datatype. + + + **L8** A form is a kind tag and a natural-number version. + + + **L9** Stores whether this form is an organization, method, principle, appearance or artifact. + + + **L10** Stores a natural-number form version; it does not prove any change occurred. + + + **L11** Generates decidable equality and display instances for the preceding datatype. + + + **L13** Defines two aim tags: expanding understanding/construction and preserving safe operation; the datatype alone does not value either aim. + + + **L14** Generates decidable equality and display instances for the preceding datatype. + + + **L16** Documents the following definition or result: A policy supplies four unrelated predicate fields; no law ties version permission to valuation or revisability. + + + **L17** A policy supplies four unrelated predicate fields; no law ties version permission to valuation or revisability. + + + **L18** Specifies which of the two represented aims this policy regards as worth pursuing. + + + **L19** Specifies the form kind/version pairs currently held by this policy. + + + **L20** Specifies which form kind/version pairs this policy leaves revisable. + + + **L21** Specifies permission between version numbers independently of actual execution. + + + **L23** Documents the following definition or result: A policy satisfies this predicate when it values the designated expansion aim and declares every current form revisable. This states no actual progress condition. + + + **L24** Opens provenance metadata binding CoreReader.Agency.Generative to the following source references; this metadata is not a proof premise. + + + **L25** Records source reference organon.charter.overview#p2 with content digest 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c; matching a digest establishes source identity, not semantic fidelity. + + + **L26** Records source reference organon.charter.overview#p3 with content digest 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c; matching a digest establishes source identity, not semantic fidelity. + + + **L27** Records source reference organon.charter.self-transcendence#p1 with content digest f4ca590e2ae15e3882f70c7b2bc46a8911c97cee547c8b137b5493fbf862c8c0; matching a digest establishes source identity, not semantic fidelity. + + + **L28** Records source reference organon.charter.self-transcendence.orientation#p1 with content digest 7f9b85c0816b3d69e417cf3cbe17b7b59931388f84d799ce6730c998037358bf; matching a digest establishes source identity, not semantic fidelity. + + + **L29** Records source reference organon.charter.self-transcendence.non-finality#p1 with content digest 4ae4497523e79e0606ab3849c47b6ea16f8888a952e063e6966eb36b750f3df8; matching a digest establishes source identity, not semantic fidelity. + + + **L30** Records source reference organon.charter.self-transcendence.limits#p1 with content digest 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d; matching a digest establishes source identity, not semantic fidelity. + + + **L31** Records source reference organon.charter.self-transcendence.limits#p2 with content digest 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d; matching a digest establishes source identity, not semantic fidelity. + + + **L32** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L33** A policy satisfies this predicate when it values the designated expansion aim and declares every current form revisable. This states no actual progress condition. + + + **L34** Requires this policy to value expanding understanding and construction. + + + **L35** Requires every form currently held by this policy to remain revisable. + + + **L37** Constructs a policy valuing both aims, selecting version zero, and permitting every revision and version pair. + + + **L38** Values both expansion and preserving safe operation in openPolicy. + + + **L39** Treats precisely version-zero forms as current, regardless of kind. + + + **L40** Allows revision of every form, including forms not currently held. + + + **L41** Permits every pair of version numbers; this does not execute a change. + + + **L43** Copies the open policy but makes every aim unworthy of pursuit; the permission fields are unchanged. + + + **L45** Documents the following definition or result: Shows permission for version 0 to 1 and distinct versions coexist with failure of the generation predicate. + + + **L46** Opens provenance metadata binding CoreReader.Agency.permissionNotValuation to the following source references; this metadata is not a proof premise. + + + **L47** Records source reference organon.charter.self-transcendence.orientation#p1 with content digest 7f9b85c0816b3d69e417cf3cbe17b7b59931388f84d799ce6730c998037358bf; matching a digest establishes source identity, not semantic fidelity. + + + **L48** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L49** Shows permission for version 0 to 1 and distinct versions coexist with failure of the generation predicate. + + + **L50** States that neutralPolicy permits 0→1, the versions differ, and its missing valuation defeats Generative. + + + **L51** Unfolds the two policies: permission is true, 0≠1 computes true, and the required valuation is false. + + + **L53** Documents the following definition or result: Extracts revisability of a specified current kind/version from an assumed generation predicate; it does not revise that form. + + + **L54** Opens provenance metadata binding CoreReader.Agency.revisabilityCovers to the following source references; this metadata is not a proof premise. + + + **L55** Records source reference organon.charter.self-transcendence.non-finality#p1 with content digest 4ae4497523e79e0606ab3849c47b6ea16f8888a952e063e6966eb36b750f3df8; matching a digest establishes source identity, not semantic fidelity. + + + **L56** Records source reference organon.relationships.terms#p1 with content digest 0d22f818e4466a5ab4272607ac0ab26997270cf05c64ce9ac547e866068907d1; matching a digest establishes source identity, not semantic fidelity. + + + **L57** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L58** Extracts revisability of a specified current kind/version from an assumed generation predicate; it does not revise that form. + + + **L59** Uses h's revisability clause on the same kind/version form that hc identifies as current. + + + **L61** Defines the only two encoded operations: identity and successor on natural numbers. + + + **L62** Generates decidable equality and display instances for the preceding datatype. + + + **L64** Interprets an operation as a function on natural numbers. + + + **L65** Executing copy returns its input unchanged. + + + **L66** Executing successor returns the input plus one. + + + **L68** Defines four inventory tags whose operational content is stored separately. + + + **L69** Generates decidable equality and display instances for the preceding datatype. + + + **L71** An inventory item consists of a tag and one of the two operations. + + + **L72** Classifies this inventory item as a document, term, tool or artifact. + + + **L73** Records the operation represented by this item, independently of its category. + + + **L74** Generates decidable equality and display instances for the preceding datatype. + + + **L76** Documents the following definition or result: Availability means that some item in the supplied list has exactly the requested operation as its content. + + + **L77** Availability means that some item in the supplied list has exactly the requested operation as its content. + + + **L78** An operation is available exactly when some listed item contains that operation. + + + **L80** Documents the following definition or result: Proves that duplicating a uniformly tagged list of operations does not change which operations are available. + + + **L81** Opens provenance metadata binding CoreReader.Agency.inventoryNotCapability to the following source references; this metadata is not a proof premise. + + + **L82** Records source reference organon.grounds.capabilities#p1 with content digest 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0; matching a digest establishes source identity, not semantic fidelity. + + + **L83** Records source reference organon.grounds.capabilities#p2 with content digest 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0; matching a digest establishes source identity, not semantic fidelity. + + + **L84** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L85** Proves that duplicating a uniformly tagged list of operations does not change which operations are available. + + + **L86** Tests availability after duplicating the list of items built from ops and the fixed category. + + + **L87** Compares it with availability in the original single copy of that same list. + + + **L88** Expands availability and turns membership in the duplicated list into membership in either copy. + + + **L89** Proves both directions: duplication neither adds nor removes represented operations. + + + **L90** An item found in either copy is already an original-list witness for the same operation. + + + **L91** For the reverse direction, take an original item x with membership hx and matching content hop. + + + **L92** Places that same item in the first copy, preserving its matching operation. + + + **L94** A state is five lists; understanding and construction are represented only by membership in the two-operation datatype. + + + **L95** Lists operations represented as understood in this state. + + + **L96** Lists operations represented as constructed in this state. + + + **L97** Stores inventory items; their multiplicity is distinct from capability membership. + + + **L98** Stores abstraction-layer entries without identifying their count with understanding. + + + **L99** Stores vocabulary entries without identifying their count with constructed capability. + + + **L100** Generates decidable equality and display instances for the preceding datatype. + + + **L102** Documents the following definition or result: Expansion is the appearance of at least one previously absent operation in either understanding or construction. It allows losing other operations. + + + **L103** Expansion is the appearance of at least one previously absent operation in either understanding or construction. It allows losing other operations. + + + **L104** Expansion may be witnessed by an operation understood after the change but not before. + + + **L105** Alternatively, a newly constructed operation witnesses expansion. + + + **L107** Constructs a state with only copy in every operation list and one copy artifact. + + + **L108** The baseline understands and constructs copy, with one copy artifact, layer and vocabulary entry. + + + **L110** Constructs a larger inventory/layer/vocabulary state with unchanged understanding and construction. + + + **L111** Starts from baseState, retaining fields unless explicitly overwritten below. + + + **L112** Duplicates the one-item inventory while leaving understood and constructed operations unchanged. + + + **L113** Replaces one abstraction-layer entry with two copies of copy. + + + **L114** Similarly doubles the vocabulary list; no new operation is introduced. + + + **L116** Returns the same base state at every natural-number time. + + + **L118** Documents the following definition or result: Exhibits a policy meeting the generation interface and universal revisability while its independently chosen constant trace never expands. + + + **L119** Opens provenance metadata binding CoreReader.Agency.revisionWithoutProgress to the following source references; this metadata is not a proof premise. + + + **L120** Records source reference organon.charter.self-transcendence.non-finality#p1 with content digest 4ae4497523e79e0606ab3849c47b6ea16f8888a952e063e6966eb36b750f3df8; matching a digest establishes source identity, not semantic fidelity. + + + **L121** Records source reference organon.relationships.terms#p1 with content digest 0d22f818e4466a5ab4272607ac0ab26997270cf05c64ce9ac547e866068907d1; matching a digest establishes source identity, not semantic fidelity. + + + **L122** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L123** Exhibits a policy meeting the generation interface and universal revisability while its independently chosen constant trace never expands. + + + **L124** Asserts openPolicy meets the adopted valuation-and-revisability specification. + + + **L125** Additionally exposes revision permission for version zero of every form category. + + + **L126** Every adjacent pair in the constant trace lacks a newly understood or constructed operation. + + + **L127** Reduces the policy clauses to true and every expansion claim to impossible new membership in an unchanged list. + + + **L129** Stores three optional natural numbers representing external-resource slots. + + + **L130** An optional external experience value; none makes assistedExecution fail at its first read. + + + **L131** An optional knowledge value required after the experience input. + + + **L132** An optional collaborator value required before producing the result. + + + **L133** Generates decidable equality and display instances for the preceding datatype. + + + **L135** Documents the following definition or result: An Option computation succeeds only when all three slots are present, then returns their sum through identity. This dependency is programmed into the example. + + + **L136** An Option computation succeeds only when all three slots are present, then returns their sum through identity. This dependency is programmed into the example. + + + **L137** Reads experience into e, immediately returning none when that resource is absent. + + + **L138** Reads knowledge into k; absence aborts the same Option computation. + + + **L139** Reads the collaborator's value into c, also propagating absence. + + + **L140** Returns the sum e+k+c through the copy operation inside some. + + + **L142** Provides resource values 1, 2 and 3 for the concrete success case. + + + **L144** Documents the following definition or result: Defines a particular non-growth reason: construction lists match, the old inventory has length at most one, and the proposed one exceeds one. + + + **L145** Defines a particular non-growth reason: construction lists match, the old inventory has length at most one, and the proposed one exceeds one. + + + **L146** A reason to retain the old state requires both states to have exactly the same constructed operations. + + + **L147** The old inventory must fit the one-item limit while the proposed inventory exceeds it. + + + **L149** Documents the following definition or result: Binds one owner's policy, current state, resource-dependent executor, budget and required operations. + + + **L150** Binds one owner's policy, current state, resource-dependent executor, budget and required operations. + + + **L151** Identifies the owner of this generating system. + + + **L152** Attaches the valuation and revisability policy to this same system. + + + **L153** Stores the system's current represented capability and inventory state. + + + **L154** Stores this system's actual resource-consuming execution function. + + + **L155** Specifies the inventory-size budget used to evaluate stable and proposed states. + + + **L156** Specifies operations that the workload requires to remain constructed. + + + **L157** Documents the following definition or result: Instantiates owner zero with the open policy, base state, three-slot executor, budget one and required copy operation. + + + **L158** Instantiates owner zero with the open policy, base state, three-slot executor, budget one and required copy operation. + + + **L159** Assigns owner identifier zero to the concrete generating system. + + + **L160** Installs openPolicy in that same concrete system. + + + **L161** Sets its current capabilities and inventory to baseState. + + + **L162** Uses the three-resource assisted interpreter as this system's execution interface. + + + **L163** Sets this workload's inventory budget to exactly one item. + + + **L164** Requires the concrete workload to preserve the copy operation. + + + **L165** Documents the following definition or result: Returns this system's current state as its stability-preserving action. + + + **L166** Returns this system's current state as its stability-preserving action. + + + **L167** Checks every operation required by this same system is constructed in the assessed state. + + + **L168** For this system and proposed state, every required operation must occur in the state's constructed list. + + + **L169** Compares the assessed state's inventory length against this system's declared budget. + + + **L170** Checks the state's inventory count against this same system's declared application budget. + + + **L171** Documents the following definition or result: Stores reporting owner, exact before/after states, claimed new operation, tested input and expected output. + + + **L172** Stores reporting owner, exact before/after states, claimed new operation, tested input and expected output. + + + **L173** Records whose expansion announcement this is. + + + **L174** Stores the exact baseline state named by the announcement. + + + **L175** Stores the exact resulting state named by the announcement. + + + **L176** Names the operation alleged to be newly constructed. + + + **L177** Fixes the input at which the announced operation's behavior is claimed. + + + **L178** Stores the claimed output of that operation at the stated input. + + + **L179** Generates decidable equality and display instances for the preceding datatype. + + + **L180** Documents the following definition or result: Builds a report from this system's owner/current state and the supplied proposal and operation contract. + + + **L181** Builds a report from this system's owner/current state and the supplied proposal and operation contract. + + + **L182** Receives the allegedly new operation and the concrete input/output pair for this report. + + + **L183** Builds a report tied to the system's owner and current baseline, using the supplied after-state and claim data. + + + **L184** Documents the following definition or result: Requires the reported operation to be newly constructed and to produce the stated output at the stated input. + + + **L185** Requires the reported operation to be newly constructed and to produce the stated output at the stated input. + + + **L186** The reported new operation must actually occur in the announcement's after-state. + + + **L187** The same operation must be absent from the announcement's baseline constructed list. + + + **L188** Its actual run at the reported input must equal the announced expected output. + + + **L189** Documents the following definition or result: Uses the genuinely new constructed operation from an assumed report claim as the expansion witness. + + + **L190** Uses the genuinely new constructed operation from an assumed report claim as the expansion witness. + + + **L191** Uses the claim's after-membership and before-absence to construct Expanded's construction branch. + + + **L192** Documents the following definition or result: This system reports successor at input zero for an inventory-only inflation proposal. + + + **L193** This system reports successor at input zero for an inventory-only inflation proposal. + + + **L194** Documents the following definition or result: Computes the exact report objects and shows its claimed new operation and actual expansion both fail. + + + **L195** Computes the exact report objects and shows its claimed new operation and actual expansion both fail. + + + **L196** Confirms the concrete announcement refers to baseState and inflatedState themselves. + + + **L197** Confirms the alleged new operation is successor. + + + **L198** Confirms the announced test is input zero with expected output one. + + + **L199** States both that the announcement's substantive claim fails and that its own state pair has no expansion. + + + **L200** Computes the report fields and unchanged capability lists; successor is absent from the after-state despite its correct 0→1 behavior. + + + **L202** Documents the following definition or result: Restricts the achievement model to inventory inflation and genuine operation extension. + + + **L203** Restricts the achievement model to inventory inflation and genuine operation extension. + + + **L204** Generates decidable equality and display instances for the preceding datatype. + + + **L206** Adds successor to the base state's understanding and construction lists. + + + **L207** Adds successor to both understood and constructed lists while retaining the baseline's other fields. + + + **L208** Both modeled transitions share the same base-state baseline. + + + **L209** Chooses inflatedState or extendedState according to the transition constructor. + + + **L210** The inflate transition ends at the inventory-only inflated state. + + + **L211** The extend transition ends at the state with newly understood and constructed successor. + + + **L212** Documents the following definition or result: Uses zero as the explicit tested input for both transition cases. + + + **L213** Uses zero as the explicit tested input for both transition cases. + + + **L214** Reports successor output one at input zero for this same system and selected after-state. + + + **L215** Both alternatives announce successor at the shared input zero, but name their own actual after-state. + + + **L217** Documents the following definition or result: Checks all concrete branches on the bound system: unchanged capability despite list inflation, resource dependence, justified stable action and an untrue same-object achievement report. + + + **L218** Opens provenance metadata binding CoreReader.Agency.generationLimits to the following source references; this metadata is not a proof premise. + + + **L219** Records source reference organon.charter.self-transcendence.limits#p1 with content digest 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d; matching a digest establishes source identity, not semantic fidelity. + + + **L220** Records source reference organon.charter.self-transcendence.limits#p2 with content digest 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d; matching a digest establishes source identity, not semantic fidelity. + + + **L221** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L222** Checks all concrete branches on the bound system: unchanged capability despite list inflation, resource dependence, justified stable action and an untrue same-object achievement report. + + + **L223** The concrete system retains the adopted generative policy. + + + **L224** Its policy allows keeping version zero, so generativity does not require every action to change versions. + + + **L225** Inflating this system's inventory does not expand its represented capabilities. + + + **L226** The inflated state has strictly more inventory entries than this system's current state. + + + **L227** Its abstraction-layer count also strictly increases without capability expansion. + + + **L228** Its vocabulary count strictly increases under the same unchanged capability content. + + + **L229** With resources 1,2,3, this system's execution actually returns some 6. + + + **L230** Removing experience from that same resource bundle makes the system's execution fail. + + + **L231** Removing knowledge alone likewise makes its execution return none. + + + **L232** Removing the collaborator input alone also makes execution fail. + + + **L233** With all three external inputs absent, this same execution interface returns none. + + + **L234** The system's stable action yields no represented capability expansion. + + + **L235** That stable action is exactly retention of the system's current state. + + + **L236** Retention preserves the workload's required copy operation. + + + **L237** The retained one-item state fits this system's one-item application budget. + + + **L238** The duplicated inventory has two entries and exceeds this same system's one-item budget. + + + **L239** Stability has the stated reason: construction is unchanged, but only the current state fits the budget. + + + **L240** Identifies the report as this system's announcement about inflatedState, successor, input zero and output one. + + + **L241** The report's owner equals this generating system's owner. + + + **L242** The report uses this system's current state as baseline and inflatedState as result. + + + **L243** The operation this actual report calls new is successor. + + + **L244** The report's claimed performance remains the concrete pair 0→1. + + + **L245** Despite that report, its claim is false and its own before/after pair has no capability expansion. + + + **L246** Begins computing all generationLimits clauses by exposing the concrete system, retention action and required-operation check. + + + **L247** Also exposes the one-item budget, report constructor and policy/expansion predicates so their claims reduce to concrete data. + + + **L248** Uses the actual baseline/inflated lists and three-resource interpreter to decide the size, membership and execution results. + + + **L249** Finally unfolds the stability reason and owned announcement claim, completing all conjunction branches by computation. + + + **L251** Documents the following definition or result: Exhibits a policy meeting generation while empty records fail the nonempty concrete reflexivity requirements. + + + **L252** Opens provenance metadata binding CoreReader.Agency.generationNotReflexivity to the following source references; this metadata is not a proof premise. + + + **L253** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L254** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L255** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L256** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L257** Exhibits a policy meeting generation while empty records fail the nonempty concrete reflexivity requirements. + + + **L258** Combines a generative openPolicy with failure of owned reflexivity when the work log is empty. + + + **L259** Separates establishing Generative from refuting the empty-log Reflexive claim. + + + **L260** Computes openPolicy's expansion valuation and unconditional revisability. + + + **L261** Assumes, for contradiction, that the empty log satisfies the owned reflexivity contract. + + + **L262** Applies noSelfExemption to the registered assessingRule, forcing a performed assessment from the assumed empty-log compliance. + + + **L263** Chooses the very system subject with matching owner and proves that assessment is applicable to it. + + + **L264** Unfolding Performed reveals an impossible member of the empty work list. + + + **L266** Documents the following definition or result: Decides the arithmetic equation n+1=2*n for each natural number. + + + **L267** Decides the arithmetic equation n+1=2*n for each natural number. + + + **L269** Returns true precisely when the equation holds at every listed sample; no unlisted input is tested. + + + **L271** Documents the following definition or result: Computes success on sample 1 and failure at 0, refuting universal success. This concerns the particular arithmetic predicate, not a universal impossibility theorem about all self-tests. + + + **L272** Opens provenance metadata binding CoreReader.Agency.selfTestDoesNotProve to the following source references; this metadata is not a proof premise. + + + **L273** Records source reference organon.charter.reflexivity.limits#p1 with content digest ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc; matching a digest establishes source identity, not semantic fidelity. + + + **L274** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L275** Computes success on sample 1 and failure at 0, refuting universal success. This concerns the particular arithmetic predicate, not a universal impossibility theorem about all self-tests. + + + **L276** The same arithmetic principle passes sample 1 but evaluates false at 0. + + + **L277** Therefore that principle does not return true for every natural-number input. + + + **L278** Separates the passing sample computation from the two failure claims. + + + **L279** Evaluates the singleton sample: 1+1 equals 2×1, so selfTest [1] is true. + + + **L280** Separates the concrete failure at zero from refuting universal success. + + + **L281** Computes 0+1≠2×0, making ownArithmeticPrinciple 0 false. + + + **L282** Assumes the same principle succeeds for every input. + + + **L283** Specializes that universal assumption to input zero. + + + **L284** Contradicts the computed false result at zero, refuting universal correctness. + + + **L286** Closes the current namespace. + + +### `leanified/CoreReader/Choice.lean` + + +```lean +import CoreReader.Evidence + +namespace CoreReader.Choice +open CoreReader.Logic CoreReader.Evidence + +inductive StatusKind | name | convention | standing + deriving DecidableEq, Repr + +inductive MethodReason | output | explanation | applicability | simplicity | procedure + deriving DecidableEq, Repr + +inductive Reason | status (kind : StatusKind) | method (kind : MethodReason) + deriving DecidableEq, Repr + +/- An implementation has observable behavior, a stated domain, an explanation formula and an execution trace. -/ +structure Implementation where + name : String + conventional : Bool + established : Bool + run : Nat → Nat + cost : Nat + domain : Nat → Prop + explanation : Nat → Nat + trace : Nat → List Nat + +/- An application selects relevant objectives and constraints; no universal ranking or score is prescribed. -/ +structure Requirements where + inputs : Nat → Prop + expected : Nat → Nat + budget : Nat + values : MethodReason → Prop + +/- These are explicit, content-based interpretations of possible method reasons in this application. -/ +def MethodContent (req : Requirements) (i : Implementation) : MethodReason → Prop + | .output => ∀ x, req.inputs x → i.run x = req.expected x + | .explanation => ∀ x, req.inputs x → i.explanation x = i.run x + | .applicability => ∀ x, req.inputs x → i.domain x + | .simplicity => i.cost ≤ req.budget + | .procedure => ∀ x, req.inputs x → (i.trace x).getLast? = some (i.run x) + +/- The extra choice commitment requires both selected relevance and actual reason content; pure status supplies neither. -/ +def Relevant (req : Requirements) (i : Implementation) : Reason → Prop + | .status _ => False + | .method kind => req.values kind ∧ MethodContent req i kind + +def Feasible (req : Requirements) (i : Implementation) : Prop := + (∀ x, req.inputs x → i.run x = req.expected x) ∧ i.cost ≤ req.budget + +/- In this application, a relevant reason is eligible only after its stated output and budget requirements hold. -/ +def JustifiedChoice (req : Requirements) (i : Implementation) (reasons : List Reason) : Prop := + Feasible req i ∧ ∃ reason ∈ reasons, Relevant req i reason + +/- This proves the structural effect of the adopted choice commitment for each of its three status-only cases. -/ +/-- organon-map CoreReader.Choice.statusOnlyFails +organon.grounds.implementations#p1 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +organon.grounds.implementations#p2 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +-/ +theorem statusOnlyFails (req : Requirements) (i : Implementation) (k : StatusKind) : + ¬ JustifiedChoice req i [.status k] := by + rintro ⟨_, reason, hr, hv⟩ + simp only [List.mem_singleton] at hr + subst reason + exact hv + +def identityImpl : Implementation where + name := "Existing identity implementation" + conventional := true + established := true + run n := n + cost := 1 + domain _ := True + explanation n := n + trace n := [n] + +def successorImpl : Implementation where + name := "Successor implementation" + conventional := false + established := false + run n := n + 1 + cost := 2 + domain _ := True + explanation n := n + 1 + trace n := [n, n + 1] + +def changedOutsideZero : Implementation := + { identityImpl with + name := "Changed outside zero" + conventional := false + established := false + run := fun n => if n = 0 then 0 else n + 1 + explanation := fun n => if n = 0 then 0 else n + 1 + trace := fun n => [if n = 0 then 0 else n + 1] } + +def identityRequirements : Requirements where + inputs _ := True + expected n := n + budget := 1 + values _ := True + +def objectiveReason : List Reason := [.method .output] + +theorem identityOutputReason : Relevant identityRequirements identityImpl (.method .output) := by + exact ⟨trivial, fun _ _ => rfl⟩ + +theorem identityFeasible : Feasible identityRequirements identityImpl := + ⟨fun _ _ => rfl, by decide⟩ + +theorem identityJustified : JustifiedChoice identityRequirements identityImpl objectiveReason := + ⟨identityFeasible, .method .output, by simp [objectiveReason], identityOutputReason⟩ + +/- A conventional existing implementation can be selected for an actual requirement, not for status alone. -/ +/-- organon-map CoreReader.Choice.conventionWithReason +organon.grounds.implementations#p1 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +organon.grounds.implementations#p2 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +-/ +theorem conventionWithReason : + identityImpl.conventional = true ∧ identityImpl.established = true ∧ + JustifiedChoice identityRequirements identityImpl [.status .convention, .method .output] := by + exact ⟨rfl, rfl, identityFeasible, .method .output, by simp, identityOutputReason⟩ + +inductive Candidate | identity | successor + deriving DecidableEq, Repr + +def implementation : Candidate → Implementation + | .identity => identityImpl + | .successor => successorImpl + +/- Feasibility is decided by the same stated behavior and resource requirement for either candidate. -/ +/-- organon-map CoreReader.Choice.singleFeasible +organon.grounds.implementations.limits#p1 sha256 db9b5f1803baab0e1b05a3a9e068948667412afa7d692e1da3869ca54be4b870 +-/ +theorem singleFeasible : + (∀ candidate, Feasible identityRequirements (implementation candidate) ↔ candidate = .identity) ∧ + JustifiedChoice identityRequirements identityImpl objectiveReason := by + constructor + · intro candidate + cases candidate + · simp [Feasible, identityRequirements, implementation, identityImpl] + · simp [Feasible, identityRequirements, implementation, successorImpl] + · exact identityJustified + +/- The same observed input can conceal a relevant difference at another input. -/ +/-- organon-map CoreReader.Choice.localNotGlobal +organon.grounds.implementations.limits#p1 sha256 db9b5f1803baab0e1b05a3a9e068948667412afa7d692e1da3869ca54be4b870 +-/ +theorem localNotGlobal : + (∀ x, x = 0 → identityImpl.run x = changedOutsideZero.run x) ∧ + identityImpl.run 1 ≠ changedOutsideZero.run 1 := by + constructor + · intro x hx; subst x; rfl + · decide + +/- This candidate is cheap enough but misses the required identity output. -/ +def cheapSuccessor : Implementation := { successorImpl with cost := 1 } + +theorem eligibleInternalReasonNotSufficient : + Relevant identityRequirements cheapSuccessor (.method .simplicity) ∧ + ¬ JustifiedChoice identityRequirements cheapSuccessor [.method .simplicity] := by + refine ⟨⟨trivial, by change 1 ≤ 1; decide⟩, ?_⟩ + intro h + have bad := h.1.1 0 trivial + cases bad + +/- Each of the four internal-method reasons is eligible because of its actual selected requirement and content. -/ +/-- organon-map CoreReader.Choice.internalReasons +organon.grounds.implementations.limits#p1 sha256 db9b5f1803baab0e1b05a3a9e068948667412afa7d692e1da3869ca54be4b870 +-/ +theorem internalReasons : + Relevant identityRequirements identityImpl (.method .explanation) ∧ + Relevant identityRequirements identityImpl (.method .applicability) ∧ + Relevant identityRequirements identityImpl (.method .simplicity) ∧ + Relevant identityRequirements identityImpl (.method .procedure) ∧ + (Relevant identityRequirements cheapSuccessor (.method .simplicity) ∧ + ¬ JustifiedChoice identityRequirements cheapSuccessor [.method .simplicity]) := by + exact ⟨⟨trivial, fun _ _ => rfl⟩, ⟨trivial, fun _ _ => trivial⟩, + ⟨trivial, by change 1 ≤ 1; decide⟩, ⟨trivial, fun _ _ => rfl⟩, eligibleInternalReasonNotSufficient⟩ + +/- Openness about reasons does not make two actual behaviors identical or reject the existing implementation. -/ +/-- organon-map CoreReader.Choice.openNotEquivalent +organon.grounds.implementations.limits#p1 sha256 db9b5f1803baab0e1b05a3a9e068948667412afa7d692e1da3869ca54be4b870 +-/ +theorem openNotEquivalent : + JustifiedChoice identityRequirements identityImpl objectiveReason ∧ + identityImpl.run 0 ≠ successorImpl.run 0 := by + exact ⟨identityJustified, by decide⟩ + +/- A priority interpretation chooses one of the same two actual implementations. -/ +def priorityClaim : Claim Candidate := fun selected => selected = .identity + +def statusFacts : Theory Candidate := union + (singleton (fun _ => identityImpl.conventional = true)) + (singleton (fun _ => identityImpl.established = true)) + +/- Both interpretations have exactly the same true conventional and established status facts. -/ +theorem statusFactsModel (selected : Candidate) : Models statusFacts selected := by + exact (modelsUnion _ _ _).2 ⟨(modelsSingleton _ _).2 rfl, (modelsSingleton _ _).2 rfl⟩ + +def priorityArticulation : Articulation Candidate := + ⟨["priority", "conventional use", "established status"], statusFacts, + [fun _ => identityImpl.conventional = true, fun _ => identityImpl.established = true], + fun _ => True⟩ + +/- This procedure reports whether the actual status premises entail that very priority claim over its stated two-candidate scope. -/ +def AssessmentAccurate (report : Bool) : Prop := + report = true ↔ Entails statusFacts priorityClaim + +theorem statusDoesNotEntailPriority : ¬ Entails statusFacts priorityClaim := by + intro h + have bad := h .successor (statusFactsModel .successor) + cases bad + +theorem statusAssessmentNonEntailment : + Articulated priorityArticulation ∧ AssessmentAccurate false ∧ + (∀ selected, Models statusFacts selected) ∧ + priorityClaim .identity ∧ ¬ priorityClaim .successor ∧ + ¬ Entails statusFacts priorityClaim ∧ + ¬ JustifiedChoice identityRequirements identityImpl [.status .standing] := by + refine ⟨⟨by simp [priorityArticulation], by simp [priorityArticulation]⟩, + ⟨(by intro h; cases h), (fun h => False.elim (statusDoesNotEntailPriority h))⟩, + statusFactsModel, rfl, (by intro h; cases h), statusDoesNotEntailPriority, + statusOnlyFails _ _ _⟩ + +/- An assessment identifies the exact premises and priority question whose entailment it reports. -/ +structure PriorityAssessment where + premises : Theory Candidate + question : Claim Candidate + report : Bool +/- Accuracy concerns the actual reported entailment question, independently of a later choice policy. -/ +def PriorityAssessment.accurate (assessment : PriorityAssessment) : Prop := + assessment.report = true ↔ Entails assessment.premises assessment.question +/- Both policies receive this same correctly negative status-only priority audit. -/ +def statusPriorityAudit : PriorityAssessment := ⟨statusFacts, priorityClaim, false⟩ +/- Priority reasons are a policy component independent of the assessment's report and objects. -/ +structure ChoicePolicy where + selected : Candidate + priorityReasons : List Reason + assessment : PriorityAssessment +/- This is completion of the specified assessment procedure only, not full compliance with philosophical Grounds. -/ +def GeneralAssessmentFulfilled (policy : ChoicePolicy) : Prop := + Articulated priorityArticulation ∧ policy.assessment = statusPriorityAudit ∧ policy.assessment.accurate +/- The additional choice norm separately tests the reasons actually used to prioritize the selected implementation. -/ +def AdditionalChoiceNorm (policy : ChoicePolicy) : Prop := + JustifiedChoice identityRequirements (implementation policy.selected) policy.priorityReasons +/- This policy retains status alone as its priority reason despite receiving the correctly negative status audit. -/ +def statusPriorityPolicy : ChoicePolicy := ⟨.identity, [.status .standing], statusPriorityAudit⟩ +/- This policy selects the same implementation using its actual relevant output reason after the same audit. -/ +def outputPriorityPolicy : ChoicePolicy := ⟨.identity, objectiveReason, statusPriorityAudit⟩ +/- The shared negative result is mathematically accurate for its actual status premises and question. -/ +theorem statusPriorityAuditAccurate : statusPriorityAudit.accurate := by + constructor + · intro h; cases h + · intro h; exact False.elim (statusDoesNotEntailPriority h) +/- These independently variable policies share facts, selected implementation and completed audit, but differ on the extra choice norm. -/ +def PolicyIndependenceExample : Prop := + statusPriorityPolicy.selected = outputPriorityPolicy.selected ∧ + statusPriorityPolicy.assessment = outputPriorityPolicy.assessment ∧ + statusPriorityPolicy.assessment.premises = statusFacts ∧ + statusPriorityPolicy.assessment.question = priorityClaim ∧ + statusPriorityPolicy.assessment.report = false ∧ + (∀ selected, Models statusPriorityPolicy.assessment.premises selected) ∧ + statusPriorityPolicy.priorityReasons ≠ outputPriorityPolicy.priorityReasons ∧ + GeneralAssessmentFulfilled statusPriorityPolicy ∧ GeneralAssessmentFulfilled outputPriorityPolicy ∧ + ¬ AdditionalChoiceNorm statusPriorityPolicy ∧ AdditionalChoiceNorm outputPriorityPolicy +/- Changing the actual priority reasons changes choice compliance while the accurate audit remains identical. -/ +theorem policyIndependenceExample : PolicyIndependenceExample := by + have articulated : Articulated priorityArticulation := + ⟨by simp [priorityArticulation], by simp [priorityArticulation]⟩ + refine ⟨rfl,rfl,rfl,rfl,rfl,statusFactsModel,?_, + ⟨articulated,rfl,statusPriorityAuditAccurate⟩, + ⟨articulated,rfl,statusPriorityAuditAccurate⟩,?_,?_⟩ + · decide + · exact statusOnlyFails identityRequirements identityImpl .standing + · exact identityJustified + +/- A correctly articulated, completed negative assessment does not enforce the additional selection rule. +This is only independence from represented assessment procedures: keeping this unsupported priority would fail general support proportionality too. -/ +/-- organon-map CoreReader.Choice.generalGroundsNotChoice +organon.grounds.implementations#p1 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +organon.grounds.implementations#p2 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem generalGroundsNotChoice : + (Articulated priorityArticulation ∧ AssessmentAccurate false ∧ + (∀ selected, Models statusFacts selected) ∧ + priorityClaim .identity ∧ ¬ priorityClaim .successor ∧ + ¬ Entails statusFacts priorityClaim ∧ + ¬ JustifiedChoice identityRequirements identityImpl [.status .standing]) ∧ + PolicyIndependenceExample := + ⟨statusAssessmentNonEntailment, policyIndependenceExample⟩ + +end CoreReader.Choice +``` + + + + **L1** Import CoreReader.Evidence, making its checked declarations available to this module; this line states no new philosophical result. + + + **L3** Open namespace CoreReader.Choice so subsequent declarations receive this module-qualified name. + + + **L4** Make names from CoreReader.Logic CoreReader.Evidence available without qualification; this changes name resolution, not assumptions. + + + **L6** Declare the alternatives StatusKind. Defines three status tags; no ranking or evidential meaning is attached by the datatype alone. + + + **L7** Derive decidable equality and printable representations for these finite constructors; these are computational conveniences, not choice criteria. + + + **L9** Declare the alternatives MethodReason. Defines five method-reason tags whose actual content is supplied by MethodContent. + + + **L10** Derive decidable equality and printable representations for these finite constructors; these are computational conveniences, not choice criteria. + + + **L12** Declare the alternatives Reason. Separates tagged status reasons from tagged method reasons. + + + **L13** Derive decidable equality and printable representations for these finite constructors; these are computational conveniences, not choice criteria. + + + **L15** Document the intended scope of Implementation. The corresponding declaration concerns: Packages an implementation's metadata, behavior, cost, domain, explanation function and trace function as independently supplied fields. This comment is explanatory, not a proof premise. + + + **L16** Declare the data interface Implementation. Packages an implementation's metadata, behavior, cost, domain, explanation function and trace function as independently supplied fields. + + + **L17** Store the implementation’s descriptive name; it does not confer priority. + + + **L18** Record whether the implementation is conventional as a Boolean status fact. + + + **L19** Record whether the implementation is established, independently of its actual behavior. + + + **L20** Store the actual natural-number input/output function. + + + **L21** Store the cost checked against an application’s budget. + + + **L22** Store the implementation’s claimed domain as a predicate on inputs. + + + **L23** Store explanatory output content to be compared with actual run results. + + + **L24** Store an input-indexed execution trace whose last element can be compared with actual output. + + + **L26** Document the intended scope of Requirements. The corresponding declaration concerns: Packages the input scope, expected output, fixed budget and valued reason kinds. This comment is explanatory, not a proof premise. + + + **L27** Declare the data interface Requirements. Packages the input scope, expected output, fixed budget and valued reason kinds. + + + **L28** Specify which inputs the application actually requires. + + + **L29** Specify the expected output at each input. + + + **L30** Specify the application’s budget constraint. + + + **L31** Specify which method-reason categories this application values; this choice is an adopted input. + + + **L33** Document the intended scope of MethodContent. The corresponding declaration concerns: Assigns a proposition to each method tag, using these particular behavioral and cost proxies. This comment is explanatory, not a proof premise. + + + **L34** Define MethodContent. Assigns a proposition to each method tag, using these particular behavioral and cost proxies. + + + **L35** An output reason requires this implementation’s actual output to equal the application’s expected output at every required input. + + + **L36** An explanation reason requires explanatory output to match this very implementation’s actual run at every required input. + + + **L37** An applicability reason requires every application-required input to belong to this implementation’s domain. + + + **L38** The simplicity reason is the selected application’s actual cost-within-budget condition. + + + **L39** A procedure reason requires the actual trace’s last element to equal this implementation’s real output at every required input. + + + **L41** Document the intended scope of Relevant. The corresponding declaration concerns: A reason is relevant when it is an allowed method kind whose content holds; status kinds are excluded outright. This comment is explanatory, not a proof premise. + + + **L42** Define Relevant. A reason is relevant when it is an allowed method kind whose content holds; status kinds are excluded outright. + + + **L43** Status reasons are defined as irrelevant under this adopted choice norm, regardless of their status subtype. + + + **L44** A method reason must both belong to a category valued by these requirements and satisfy that category’s actual MethodContent. + + + **L46** Define Feasible. Feasibility requires universal requested-input output correctness and fixed cost within budget; it does not include explanation, domain or trace checks. + + + **L47** Feasibility requires correct actual output at every required input and actual cost within this application’s budget. + + + **L49** Document the intended scope of JustifiedChoice. The corresponding declaration concerns: Requires both output/budget feasibility and at least one listed valued method reason with its concrete content satisfied. This comment is explanatory, not a proof premise. + + + **L50** Define JustifiedChoice. Requires both output/budget feasibility and at least one listed valued method reason with its concrete content satisfied. + + + **L51** Require feasibility and at least one actually listed relevant reason; a relevant reason alone does not establish feasibility. + + + **L53** Document the intended scope of statusOnlyFails. The corresponding declaration concerns: For any requirements and implementation, a singleton status reason cannot justify choice because its relevance is defined as false. This comment is explanatory, not a proof premise. + + + **L54** Begin provenance metadata for CoreReader.Choice.statusOnlyFails; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L55** Register source unit organon.grounds.implementations#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L56** Register source unit organon.grounds.implementations#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L57** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L58** State the checked result statusOnlyFails. For any requirements and implementation, a singleton status reason cannot justify choice because its relevance is defined as false. + + + **L59** Deny justified selection when the only listed reason is status, for the supplied arbitrary requirements and implementation. + + + **L60** Unpack an alleged status-only justified choice, extracting its listed reason and proof of relevance; feasibility alone cannot supply the missing relevance. + + + **L61** Simplify singleton membership to show that the extracted reason is exactly the given status reason. + + + **L62** Substitute the identified status reason into its alleged relevance proof. + + + **L63** Relevance of a status reason is defined as False, so the extracted hv is already a contradiction. + + + **L65** Define identityImpl. Builds an identity implementation with both status flags true, cost one, unrestricted domain, matching explanation and singleton output trace. + + + **L66** Name the concrete existing identity implementation without using its name as a proof of quality. + + + **L67** Mark the identity implementation’s conventional and established status as true; these facts remain distinct from its actual method reasons. + + + **L68** Mark the identity implementation’s conventional and established status as true; these facts remain distinct from its actual method reasons. + + + **L69** Define actual identity output as the unchanged input n. + + + **L70** Set identity’s actual cost to 1. + + + **L71** Let identity’s applicability domain contain all natural inputs. + + + **L72** Provide an explanatory result equal to the input, matching identity’s actual output. + + + **L73** Use the singleton input as the actual trace, whose last element equals identity’s output. + + + **L75** Define successorImpl. Builds a successor implementation with false status flags, cost two, unrestricted domain, matching explanation and a two-entry trace. + + + **L76** Name the alternative successor implementation. + + + **L77** Mark successor as neither conventional nor established in this example; this status alone does not determine feasibility. + + + **L78** Mark successor as neither conventional nor established in this example; this status alone does not determine feasibility. + + + **L79** Define successor’s actual output as n+1. + + + **L80** Set its original cost to 2, above the identity application’s budget 1. + + + **L81** Let successor’s applicability domain also include every natural input. + + + **L82** Provide its explanatory result n+1, faithful to its own actual output. + + + **L83** Record input and then actual successor output in its trace. + + + **L85** Define changedOutsideZero. Copies identity metadata/fields except the explicitly replaced ones, producing an implementation equal at zero but different elsewhere. + + + **L86** Start from identityImpl’s fields and explicitly override the following components. + + + **L87** Name the modified implementation by its change outside input zero. + + + **L88** Change this modified implementation’s conventional/established flags to false. + + + **L89** Change this modified implementation’s conventional/established flags to false. + + + **L90** Keep output 0 at input 0 but return n+1 at every other input. + + + **L91** Make its explanation follow the same actual piecewise output function. + + + **L92** Use that same piecewise result as its singleton trace; finish the implementation override. + + + **L94** Define identityRequirements. Requires identity behavior at all natural inputs, budget one, and values every method-reason kind. + + + **L95** Require every natural-number input in the identity application. + + + **L96** Set the desired output to the unchanged input. + + + **L97** Adopt budget 1 for the application. + + + **L98** Admit all represented method-reason categories; their actual content must still be checked. + + + **L100** Define objectiveReason. Defines a reason list containing only the output-correctness method tag. + + + **L102** State the checked result identityOutputReason. Proves the identity implementation has a relevant output reason under universal identity requirements by definitional output equality. The following tactic block proves this explicit type. + + + **L103** The output reason is admitted by these requirements, and identityImpl’s actual output equals the expected output at every allowed input by reflexivity. + + + **L105** State the checked result identityFeasible. Proves universal identity output and cost one within budget one. The supplied proof term uses the displayed constructed witnesses or earlier lemmas, rather than adding an axiom. + + + **L106** For identity, every required output is correct by reflexivity; compute cost 1 within budget 1. + + + **L108** State the checked result identityJustified. Uses the output reason as the existential witness justifying identity under the given requirements. The supplied proof term uses the displayed constructed witnesses or earlier lemmas, rather than adding an axiom. + + + **L109** Combine identity’s feasibility with the actual output reason, prove it belongs to objectiveReason and supply its content-based relevance. + + + **L111** Document the intended scope of conventionWithReason. The corresponding declaration concerns: Shows conventional and established metadata can coexist with justified choice when the list also contains a valid output reason; status does not provide the witness. This comment is explanatory, not a proof premise. + + + **L112** Begin provenance metadata for CoreReader.Choice.conventionWithReason; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L113** Register source unit organon.grounds.implementations#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L114** Register source unit organon.grounds.implementations#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L115** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L116** State the checked result conventionWithReason. Shows conventional and established metadata can coexist with justified choice when the list also contains a valid output reason; status does not provide the witness. + + + **L117** Keep both actual status facts true for identity. + + + **L118** Claim justified selection using a list containing convention and an actual output reason; the output reason supplies relevance. + + + **L119** Compute the conventional/established status facts, retain actual feasibility, and select the listed output reason with its separately proved relevance. + + + **L121** Declare the alternatives Candidate. Closes the candidate universe to exactly identity and successor. + + + **L122** Derive decidable equality and printable representations for these finite constructors; these are computational conveniences, not choice criteria. + + + **L124** Define implementation. Maps each of the two candidate constructors to its concrete implementation. + + + **L125** Interpret the identity candidate as the actual identityImpl object. + + + **L126** Interpret the successor candidate as the actual successorImpl object. + + + **L128** Document the intended scope of singleFeasible. The corresponding declaration concerns: Proves identity is the sole feasible member of the two-constructor candidate type under identity requirements, and separately supplies its output justification. This comment is explanatory, not a proof premise. + + + **L129** Begin provenance metadata for CoreReader.Choice.singleFeasible; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L130** Register source unit organon.grounds.implementations.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L131** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L132** State the checked result singleFeasible. Proves identity is the sole feasible member of the two-constructor candidate type under identity requirements, and separately supplies its output justification. + + + **L133** Over the explicitly two-valued candidate type, require feasibility exactly for identity. + + + **L134** Also retain identity’s actual output-reason justification. + + + **L135** Separate the exact feasible-candidate characterization from the existing proof of identity’s justified selection. + + + **L136** Fix any candidate in the explicit identity/successor type before checking its feasibility equivalence. + + + **L137** Exhaust the actual two-candidate type: identity or successor; no unlisted implementation is considered. + + + **L138** For identity, unfold actual outputs and cost; the identity-output and budget conditions are satisfied. + + + **L139** For successor, unfold the same requirements; the candidate cannot meet identity outputs and its original cost also exceeds the budget. + + + **L140** Reuse identityJustified to finish the concrete selected-candidate obligation. + + + **L142** Document the intended scope of localNotGlobal. The corresponding declaration concerns: Shows identity and the piecewise implementation agree when input is zero but disagree at input one; this refutes inference from local agreement to global equality. This comment is explanatory, not a proof premise. + + + **L143** Begin provenance metadata for CoreReader.Choice.localNotGlobal; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L144** Register source unit organon.grounds.implementations.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L145** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L146** State the checked result localNotGlobal. Shows identity and the piecewise implementation agree when input is zero but disagree at input one; this refutes inference from local agreement to global equality. + + + **L147** Compare actual outputs only under the input-0 scope. + + + **L148** Separately require a real output difference at input 1. + + + **L149** Separate equality under the input-0 scope from actual inequality at input 1. + + + **L150** Substitute the local-scope assumption x=0; the two implementations then have definitionally equal outputs. + + + **L151** Compute their actual outputs at input 1 to verify the claimed inequality. + + + **L153** Document the intended scope of cheapSuccessor. The corresponding declaration concerns: Lowers successor's fixed cost to one without fixing its identity-output failure. This comment is explanatory, not a proof premise. + + + **L154** Define cheapSuccessor. Lowers successor's fixed cost to one without fixing its identity-output failure. + + + **L156** State the checked result eligibleInternalReasonNotSufficient. Shows cost simplicity is relevant for cheap successor, yet output infeasibility prevents justified choice. + + + **L157** Require that cheapSuccessor’s cost reason is actually relevant under the chosen requirements. + + + **L158** Nevertheless reject its justified choice with that reason alone because feasibility includes correct outputs. + + + **L159** Show the cheap successor has an admitted cost reason with cost 1 ≤ budget 1, then separately refute justified choice. + + + **L160** Assume cheapSuccessor is justified using its cost reason, in order to extract and refute its required output feasibility. + + + **L161** An alleged justified choice includes feasible outputs; apply that requirement at input 0, where successor returns 1 instead of expected 0. + + + **L162** Eliminate the resulting impossible output equality; a relevant cost reason did not repair the wrong output. + + + **L164** Document the intended scope of internalReasons. The corresponding declaration concerns: Provides four valid internal reasons for identity and a cost-relevant successor counterexample to automatic sufficiency. This comment is explanatory, not a proof premise. + + + **L165** Begin provenance metadata for CoreReader.Choice.internalReasons; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L166** Register source unit organon.grounds.implementations.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L167** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L168** State the checked result internalReasons. Provides four valid internal reasons for identity and a cost-relevant successor counterexample to automatic sufficiency. + + + **L169** Require a faithful explanation reason for the same actual identity implementation. + + + **L170** Require its actual applicability to cover the required inputs. + + + **L171** Require its actual cost to meet the valued simplicity/budget condition. + + + **L172** Require its actual trace content to meet the valued procedure condition. + + + **L173** Include a separate cheap-successor case where its cost reason is eligible. + + + **L174** That cheap candidate still fails justified selection; the combined theorem begins its proof here. + + + **L175** Provide admitted, actually faithful explanation and applicability reasons for identity, checking their content at every required input. + + + **L176** Provide the actual budget and trace reasons, then include the cheap-but-wrong example showing relevance alone is insufficient. + + + **L178** Document the intended scope of openNotEquivalent. The corresponding declaration concerns: Combines identity's justification with differing identity/successor outputs at zero. It proves behavioral distinction between these examples, not a general openness property. This comment is explanatory, not a proof premise. + + + **L179** Begin provenance metadata for CoreReader.Choice.openNotEquivalent; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L180** Register source unit organon.grounds.implementations.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L181** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L182** State the checked result openNotEquivalent. Combines identity's justification with differing identity/successor outputs at zero. It proves behavioral distinction between these examples, not a general openness property. + + + **L183** Retain justified selection of the existing identity implementation based on its actual output reason. + + + **L184** Also require that identity and successor actually produce different outputs at input 0. + + + **L185** Retain the existing identity justification and compute the distinct actual outputs of identity and successor at 0. + + + **L187** Document the intended scope of priorityClaim. The corresponding declaration concerns: Defines the priority claim as selection of the identity constructor. This comment is explanatory, not a proof premise. + + + **L188** Define priorityClaim. Defines the priority claim as selection of the identity constructor. + + + **L190** Define statusFacts. Forms a theory containing two status facts about identity that are constant across candidate worlds. + + + **L191** The first status premise records actual conventional status of identity, regardless of the candidate interpretation. + + + **L192** The second status premise records actual established status of that same implementation. + + + **L194** Document the intended scope of statusFactsModel. The corresponding declaration concerns: Proves every candidate world models these status facts because both concern fixed metadata, independent of selection. This comment is explanatory, not a proof premise. + + + **L195** State the checked result statusFactsModel. Proves every candidate world models these status facts because both concern fixed metadata, independent of selection. The following tactic block proves this explicit type. + + + **L196** Both status predicates concern the same actual identity implementation and are true independently of which candidate interpretation is selected; combine their singleton models. + + + **L198** Define priorityArticulation. Constructs a nonempty articulation of the constant status theory, with the same two status predicates as reasons and unrestricted limits. + + + **L199** Articulate priority and actual status concepts using statusFacts as the premise theory. + + + **L200** List the same actual conventional and established facts as articulated reasons. + + + **L201** Use unrestricted candidate scope for this status-priority articulation. + + + **L203** Document the intended scope of AssessmentAccurate. The corresponding declaration concerns: Defines report accuracy as equivalence between report=true and semantic entailment of the priority claim by status facts. This comment is explanatory, not a proof premise. + + + **L204** Define AssessmentAccurate. Defines report accuracy as equivalence between report=true and semantic entailment of the priority claim by status facts. + + + **L205** Define report accuracy by equivalence between report=true and semantic entailment of this exact priority question from these status facts. + + + **L207** State the checked result statusDoesNotEntailPriority. Refutes priority entailment using successor, which models all fixed identity-status facts but is not identity. The following tactic block proves this explicit type. + + + **L208** Assume the actual status facts entail identity priority across all candidate interpretations. + + + **L209** Apply alleged status-to-priority entailment to successor, which satisfies all the same true status facts but is not identity. + + + **L210** Distinct candidate constructors refute the priority equality derived at successor. + + + **L212** State the checked result statusAssessmentNonEntailment. Retains the original factual countermodel: status facts are articulated and accurately assessed but do not entail identity priority. + + + **L213** Require procedural articulation and a correctly negative report for the same status-priority assessment. + + + **L214** Keep all candidate interpretations as models of the same actual status facts. + + + **L215** The priority predicate holds at identity and fails at successor. + + + **L216** Deny entailment of that priority predicate from status facts alone. + + + **L217** Also reject selecting identity with standing as the only actual reason. + + + **L218** Check that priorityArticulation has nonempty concepts and actual status reasons. + + + **L219** Prove report=false is accurate: it cannot equal true, and any entailment assumption contradicts the actual successor countermodel. + + + **L220** Retain models of the same facts for both candidates, priority at identity but not successor, and the established failed entailment. + + + **L221** Reuse the general status-only failure theorem for the explicit identity choice with standing as its sole reason. + + + **L223** Document the intended scope of PriorityAssessment. The corresponding declaration concerns: Stores the actual premise theory, question and Boolean assessment report independently of a choice policy. This comment is explanatory, not a proof premise. + + + **L224** Declare the data interface PriorityAssessment. Stores the actual premise theory, question and Boolean assessment report independently of a choice policy. + + + **L225** Store the actual premise theory audited by this assessment. + + + **L226** Store the exact priority claim whose entailment is assessed. + + + **L227** Store the reported Boolean answer separately from facts and question. + + + **L228** Document the intended scope of PriorityAssessment.accurate. The corresponding declaration concerns: Matches the report to semantic entailment for this exact premise/question pair. This comment is explanatory, not a proof premise. + + + **L229** Define PriorityAssessment.accurate. Matches the report to semantic entailment for this exact premise/question pair. + + + **L230** Require this assessment’s actual report to agree exactly with entailment from its own premises to its own question. + + + **L231** Document the intended scope of statusPriorityAudit. The corresponding declaration concerns: Records a false entailment report for the actual fixed status facts and priority question. This comment is explanatory, not a proof premise. + + + **L232** Define statusPriorityAudit. Records a false entailment report for the actual fixed status facts and priority question. + + + **L233** Document the intended scope of ChoicePolicy. The corresponding declaration concerns: Separates chosen candidate, priority reasons and the independently stored assessment. This comment is explanatory, not a proof premise. + + + **L234** Declare the data interface ChoicePolicy. Separates chosen candidate, priority reasons and the independently stored assessment. + + + **L235** Store the candidate this policy actually selects. + + + **L236** Store the policy’s actual priority reasons independently of its assessment record. + + + **L237** Store the actual assessment whose procedure the policy completed. + + + **L238** Document the intended scope of GeneralAssessmentFulfilled. The corresponding declaration concerns: Requires nonempty actual articulation and the exact accurate status audit, without imposing the additional choice criterion. This comment is explanatory, not a proof premise. + + + **L239** Define GeneralAssessmentFulfilled. Requires nonempty actual articulation and the exact accurate status audit, without imposing the additional choice criterion. + + + **L240** Require nonempty articulation, exactly the shared statusPriorityAudit, and its accuracy; this is specified procedure fulfillment, not full philosophical Grounds. + + + **L241** Document the intended scope of AdditionalChoiceNorm. The corresponding declaration concerns: Applies the separate feasibility-and-relevance choice norm to this policy's selected implementation and reasons. This comment is explanatory, not a proof premise. + + + **L242** Define AdditionalChoiceNorm. Applies the separate feasibility-and-relevance choice norm to this policy's selected implementation and reasons. + + + **L243** Separately apply JustifiedChoice to the policy’s actual selected implementation and its actual reason list. + + + **L244** Document the intended scope of statusPriorityPolicy. The corresponding declaration concerns: Selects identity solely on standing while retaining the accurate non-entailment audit. This comment is explanatory, not a proof premise. + + + **L245** Define statusPriorityPolicy. Selects identity solely on standing while retaining the accurate non-entailment audit. + + + **L246** Document the intended scope of outputPriorityPolicy. The corresponding declaration concerns: Keeps the same choice and audit but uses the actual output reason. This comment is explanatory, not a proof premise. + + + **L247** Define outputPriorityPolicy. Keeps the same choice and audit but uses the actual output reason. + + + **L248** Document the intended scope of statusPriorityAuditAccurate. The corresponding declaration concerns: Uses the successor countermodel to establish the recorded false entailment report is accurate. This comment is explanatory, not a proof premise. + + + **L249** State the checked result statusPriorityAuditAccurate. Uses the successor countermodel to establish the recorded false entailment report is accurate. The following tactic block proves this explicit type. + + + **L250** Split accuracy of the negative audit into the two directions of its equivalence with entailment. + + + **L251** The audit’s actual false report cannot equal true, so this direction has an impossible premise. + + + **L252** Any asserted entailment contradicts statusDoesNotEntailPriority; this establishes the reverse accuracy direction for the false report. + + + **L253** Document the intended scope of PolicyIndependenceExample. The corresponding declaration concerns: Requires two policies with the same actual selection/audit but different reasons, both satisfying represented assessment duties and only the output policy satisfying the extra norm. This comment is explanatory, not a proof premise. + + + **L254** Define PolicyIndependenceExample. Requires two policies with the same actual selection/audit but different reasons, both satisfying represented assessment duties and only the output policy satisfying the extra norm. + + + **L255** Fix identical selected candidates in both policies. + + + **L256** Fix the same actual assessment in both policies. + + + **L257** Bind that assessment’s premises to the actual shared statusFacts. + + + **L258** Bind its question to the same priorityClaim. + + + **L259** Fix the common report to false, rather than allowing policy changes to alter the audit answer. + + + **L260** Retain models of these same assessment premises for every candidate interpretation. + + + **L261** Require the actual priority reason lists to differ despite the shared candidate and audit. + + + **L262** Require both policies to complete the same specified assessment procedure accurately. + + + **L263** Require opposite results under the additional choice norm: status fails, output passes. + + + **L264** Document the intended scope of policyIndependenceExample. The corresponding declaration concerns: Constructs both independent policy objects and combines actual audit accuracy with status rejection and output justification. This comment is explanatory, not a proof premise. + + + **L265** State the checked result policyIndependenceExample. Constructs both independent policy objects and combines actual audit accuracy with status rejection and output justification. The following tactic block proves this explicit type. + + + **L266** Construct one shared nonempty articulation of the actual status-priority question for both policies. + + + **L267** Construct one shared nonempty articulation of the actual status-priority question for both policies. + + + **L268** Fix identical selected candidate, audit, premises, question and false report; retain actual fact models and leave the difference in reason lists. + + + **L269** Show the status-only policy completed that exact articulated audit with its mathematically accurate report. + + + **L270** Supply the identical fulfilled audit for the output policy, leaving the two separate additional-choice-norm results. + + + **L271** Compute that status-only and output-based priority reason lists are distinct despite their shared selected candidate and audit. + + + **L272** Apply statusOnlyFails to the actual status policy’s priority reason, proving failure of AdditionalChoiceNorm. + + + **L273** Use identityJustified for the output policy’s actual relevant output reason, proving its AdditionalChoiceNorm. + + + **L275** Document the intended scope of generalGroundsNotChoice. The corresponding declaration concerns: Combines the factual non-entailment case with a separate policy-level countermodel to deriving the added choice norm from represented general assessment duties. This comment is explanatory, not a proof premise. + + + **L276** Document the intended scope of generalGroundsNotChoice. The corresponding declaration concerns: Combines the factual non-entailment case with a separate policy-level countermodel to deriving the added choice norm from represented general assessment duties. This comment is explanatory, not a proof premise. + + + **L277** Begin provenance metadata for CoreReader.Choice.generalGroundsNotChoice; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L278** Register source unit organon.grounds.implementations#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L279** Register source unit organon.grounds.implementations#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L280** Register source unit organon.relationships.roles#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L281** Register source unit organon.relationships.roles#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L282** Register source unit organon.relationships.roles#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L283** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L284** State the checked result generalGroundsNotChoice. Combines the factual non-entailment case with a separate policy-level countermodel to deriving the added choice norm from represented general assessment duties. + + + **L285** Retain the original articulated, accurately negative status assessment as part of the registered result. + + + **L286** Keep the same actual status premises modeled by every candidate. + + + **L287** Keep priority true for identity and false for successor. + + + **L288** Keep the demonstrated status-to-priority non-entailment. + + + **L289** Keep status-only choice failure, then join it to the stronger policy-independence example. + + + **L290** Include actual policy variation through PolicyIndependenceExample, rather than ending at status non-entailment. + + + **L291** Pair the preserved status non-entailment proof with policyIndependenceExample, thereby including actual independent priority-reason variation in the registered theorem. + + + **L293** Close namespace CoreReader.Choice; this adds no proof or premise. + + +### `leanified/CoreReader/Evidence.lean` + + +```lean +import CoreReader.Logic +import CoreReader.Agency + +namespace CoreReader.Evidence +open CoreReader.Logic +open CoreReader.Agency + +/- An observation records the outcome of a specified test on the represented world. -/ +structure Record (W : Type) where + test : W → Bool + observed : Bool +/- Compatible worlds reproduce the actual contents of every recorded observation. -/ +def Compatible {W : Type} (records : List (Record W)) (w : W) : Prop := + ∀ r, r ∈ records → r.test w = r.observed +/- Inferential support requires the same claim in every evidence-compatible world. -/ +def Supports {W : Type} (records : List (Record W)) (claim : Claim W) : Prop := + ∀ w, Compatible records w → claim w +/- Articulation identifies concepts, premises, reason contents and an application limit. -/ +structure Articulation (W : Type) where + concepts : List String + assumptions : Theory W + reasons : List (Claim W) + limits : Claim W +/- Nonempty identifiable concepts and reasons are procedural articulation requirements. -/ +def Articulated {W : Type} (a : Articulation W) : Prop := + a.concepts ≠ [] ∧ a.reasons ≠ [] +/- This application model interprets an adopted option through its actual outcomes and stated goals/constraints. -/ +structure ValuePosition (W : Type) where + Position : Type + Outcome : Type + adopted : Position + selected : W → Position + outcome : W → Position → Outcome + objective : Outcome → Prop + constraints : W → Position → Prop + starting : Theory W + reasons : List (W → Position → Prop) + limits : Claim W + relevantCriticism : Claim W + response : W → Option String +/- The adopted position's claim is derived from the same selected option used by the outcome interpretation. -/ +def ValuePosition.commitment {W : Type} (v : ValuePosition W) : Claim W := + fun w => v.selected w = v.adopted +/- Assessed consequences concern this adopted option's actual outcome, objective and constraints. -/ +def ValuePosition.consequence {W : Type} (v : ValuePosition W) : Claim W := + fun w => v.objective (v.outcome w v.adopted) ∧ v.constraints w v.adopted +/- Articulated reasons specialize the actual option-indexed premises to the adopted option. -/ +def ValuePosition.activeReasons {W : Type} (v : ValuePosition W) : List (Claim W) := + v.reasons.map (fun reason w => reason w v.adopted) +/- A joint witness excludes inconsistent starts and impossible adoption states. -/ +def JointAdoption {W : Type} (v : ValuePosition W) : Prop := + ∃ w, Models v.starting w ∧ v.limits w ∧ v.commitment w ∧ + ∀ reason, reason ∈ v.reasons → reason w v.adopted +/- This declared option/outcome adapter checks joint reasons for an assessed consequence; it is not a necessary deductive form for all value justification. -/ +def ValueProcedure {W : Type} (v : ValuePosition W) : Prop := + v.reasons ≠ [] ∧ JointAdoption v ∧ + (∀ w, Models v.starting w → v.limits w → + (∀ reason, reason ∈ v.reasons → reason w v.adopted) → v.consequence w) ∧ + (∀ w, v.limits w → v.relevantCriticism w → ∃ answer, v.response w = some answer ∧ answer ≠ "") +/- A facet carries its specific contents; several different facets can have the same conclusion. -/ +inductive Facet (W : Type) where + | empirical (records : List (Record W)) (scope conclusion uncertainty : Claim W) + | inferential (assumptions : Theory W) (conclusion : Claim W) + | value (position : ValuePosition W) +/- The claim referred to by each assessment facet is explicit. -/ +def Facet.claim {W : Type} : Facet W → Claim W + | .empirical _ _ p _ => p + | .inferential _ p => p + | .value v => v.commitment +/- These disclosed semantic adapters implement selected nature-specific checks; passing them does not establish all real empirical or value adequacy. -/ +def FacetDischarged {W : Type} : Facet W → Prop + | .empirical records scope p uncertainty => + (∃ w, Compatible records w ∧ scope w) ∧ + Supports records (fun w => scope w → p w) ∧ Supports records uncertainty + | .inferential assumptions p => Satisfiable assumptions ∧ Entails assumptions p + | .value v => ValueProcedure v +/- This model's semantic adapter identifies the actual assumptions, reason content and limit of a facet. -/ +def FacetArticulated {W : Type} (a : Articulation W) : Facet W → Prop + | .empirical records scope _ _ => + a.assumptions = singleton (Compatible records) ∧ a.reasons = [Compatible records] ∧ a.limits = scope + | .inferential assumptions _ => + a.assumptions = assumptions ∧ a.reasons = [Models assumptions] ∧ a.limits = (fun _ => True) + | .value v => a.assumptions = v.starting ∧ a.reasons = v.activeReasons ∧ a.limits = v.limits +/- A canonical articulation exposes this adapter; the source does not mandate this particular representation of grounds. -/ +def canonicalArticulation {W : Type} : Facet W → Articulation W + | .empirical records scope _ _ => + ⟨["recorded test outcomes", "observation conditions"], singleton (Compatible records), [Compatible records], scope⟩ + | .inferential assumptions _ => + ⟨["stated assumptions", "semantic consequence"], assumptions, [Models assumptions], fun _ => True⟩ + | .value v => + ⟨["adopted position", "reasons and consequences"], v.starting, v.activeReasons, v.limits⟩ +/- Canonical articulation is connected to the very facet whose grounds it identifies. -/ +theorem canonicalFacetArticulated {W : Type} (f : Facet W) : + FacetArticulated (canonicalArticulation f) f := by + cases f <;> exact ⟨rfl, rfl, rfl⟩ +/- A discharged facet has nonempty canonical reason articulation, including the value procedure's reason requirement. -/ +theorem canonicalArticulated {W : Type} (f : Facet W) (h : FacetDischarged f) : + Articulated (canonicalArticulation f) := by + cases f with + | empirical records scope p uncertainty => simp [Articulated, canonicalArticulation] + | inferential assumptions p => simp [Articulated, canonicalArticulation] + | value v => + refine ⟨by simp [canonicalArticulation], ?_⟩ + simpa [canonicalArticulation, ValuePosition.activeReasons] using h.1 +/- This model of the Grounds obligation binds each actual facet to its claim and articulation. Its disclosed FacetDischarged adapters do not replace all source-level assessment responsibilities or prove real adequacy. -/ +/-- organon-map CoreReader.Evidence.Grounds +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +def Grounds {W : Type} (claim : Claim W) (articulations : Facet W → Articulation W) + (actualApplicable : Facet W → Prop) (facets : List (Facet W)) : Prop := + facets ≠ [] ∧ (∀ facet, actualApplicable facet → facet ∈ facets) ∧ + ∀ facet, facet ∈ facets → facet.claim = claim ∧ Articulated (articulations facet) ∧ + FacetArticulated (articulations facet) facet ∧ FacetDischarged facet +/- The achievement obligation requires grounds for this very claim, without making observation a universal prerequisite. -/ +/-- organon-map CoreReader.Evidence.AchievementAccountability +organon.charter.self-transcendence.limits#p1 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.charter.self-transcendence.limits#p2 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +def AchievementAccountability {W : Type} (achievement : Claim W) (articulations : Facet W → Articulation W) + (actualApplicable : Facet W → Prop) (facets : List (Facet W)) : Prop := + Grounds achievement articulations actualApplicable facets +/- The concrete achievement claim refers to each transition's own before/after states. -/ +def transitionAchievement : Claim TransitionCase := + fun transition => Expanded (transitionBefore transition) (transitionAfter transition) +/- This observation inspects an actually constructed successor and its output under that transition's input condition. -/ +def transitionPerformanceRecord : Record TransitionCase := + ⟨fun transition => (transitionAfter transition).constructed.any + (fun operation => operation == .successor && decide (operation.run (transitionInput transition) = 1)), true⟩ +/- The positive report test reads its asserted operation, input and output; it does not verify their presence in the after-state. -/ +def transitionReportRecord : Record TransitionCase := + ⟨fun transition => + let report := transitionAnnouncement transition + report.reportedNewOperation == .successor && report.input == 0 && report.expectedOutput == 1, true⟩ +/- Only the genuine extension matches the operation/performance observation in this two-transition model. -/ +theorem transitionPerformanceCompatible : + ∀ transition, Compatible [transitionPerformanceRecord] transition ↔ transition = .extend := by + intro transition + constructor + · intro h + have observed := h transitionPerformanceRecord (List.mem_singleton.mpr rfl) + cases transition + · cases observed + · rfl + · intro h; cases h + intro record hr; have hr' := List.mem_singleton.mp hr; subst record + rfl +/- A compatible performance observation establishes the same transition's report content and hence its represented expansion. -/ +theorem transitionSupported : Supports [transitionPerformanceRecord] transitionAchievement := by + intro transition compatible + have h := (transitionPerformanceCompatible transition).1 compatible + subst transition + have reportTrue : (transitionAnnouncement .extend).claim := by + simp [transitionAnnouncement, transitionAfter, transitionInput, + Announcement.claim, GeneratingSystem.report, generatingSystem, extendedState, baseState, Operation.run] + exact announcementClaimImpliesExpansion _ reportTrue +/- The actual scope is the shared input-zero condition, with no probabilistic inference introduced. -/ +def transitionFacet : Facet TransitionCase := + .empirical [transitionPerformanceRecord] (fun transition => transitionInput transition = 0) + transitionAchievement (fun _ => True) +/- The empirical assessment has a real compatible witness and supports this scoped achievement. -/ +theorem transitionFacetDischarged : FacetDischarged transitionFacet := by + refine ⟨⟨.extend, (transitionPerformanceCompatible _).2 rfl, rfl⟩, ?_, ?_⟩ + · intro transition compatible _; exact transitionSupported transition compatible + · intro _ _; trivial +/- Every applicable facet of this specified achievement has matching articulation and actual discharged evidence. -/ +theorem transitionAccountable : + AchievementAccountability transitionAchievement canonicalArticulation + (fun facet => facet = transitionFacet) [transitionFacet] := by + refine ⟨by simp, ?_, ?_⟩ + · intro facet hf; subst facet; exact List.mem_singleton.mpr rfl + · intro facet hf; have hf' := List.mem_singleton.mp hf; subst facet + exact ⟨rfl, canonicalArticulated _ transitionFacetDischarged, + canonicalFacetArticulated _, transitionFacetDischarged⟩ +/- Both actual transitions issue the same positive report about their own identified state pair. -/ +theorem transitionReportCompatible (transition : TransitionCase) : + Compatible [transitionReportRecord] transition := by + intro record hr; have hr' := List.mem_singleton.mp hr; subst record + rfl +/- Inflation is a concrete report-compatible counterworld, so the positive report alone does not support the same achievement claim. -/ +theorem transitionReportDoesNotSupport : + Compatible [transitionReportRecord] .inflate ∧ ¬ transitionAchievement .inflate ∧ + ¬ Supports [transitionReportRecord] transitionAchievement := by + have noExpansion : ¬ transitionAchievement .inflate := by + simp [transitionAchievement, transitionBefore, transitionAfter, Expanded, baseState, inflatedState] + exact ⟨transitionReportCompatible _, noExpansion, fun h => noExpansion (h _ (transitionReportCompatible _))⟩ +/- These concrete obligations, positive evidence and negative report case all refer to the same state-pair and input semantics. -/ +def ConcreteAchievementExample : Prop := + AchievementAccountability transitionAchievement canonicalArticulation + (fun facet => facet = transitionFacet) [transitionFacet] ∧ + Compatible [transitionPerformanceRecord] .extend ∧ + Supports [transitionPerformanceRecord] transitionAchievement ∧ transitionAchievement .extend ∧ + (Compatible [transitionReportRecord] .inflate ∧ ¬ transitionAchievement .inflate ∧ + ¬ Supports [transitionReportRecord] transitionAchievement) ∧ + (∀ transition, (transitionAnnouncement transition).before = transitionBefore transition ∧ + (transitionAnnouncement transition).after = transitionAfter transition ∧ + (transitionAnnouncement transition).input = transitionInput transition ∧ transitionInput transition = 0) +/- The concrete example jointly inhabits accountability, evidence compatibility, actual gain, and the report-only countermodel. -/ +theorem concreteAchievementExample : ConcreteAchievementExample := by + refine ⟨transitionAccountable, (transitionPerformanceCompatible _).2 rfl, transitionSupported, + transitionSupported .extend ((transitionPerformanceCompatible _).2 rfl), + transitionReportDoesNotSupport, ?_⟩ + intro transition; exact ⟨rfl,rfl,rfl,rfl⟩ +/- Semantic evidence yields truth only at a world that actually satisfies those evidence conditions. -/ +/-- organon-map CoreReader.Evidence.achievementNeedsSupport +organon.charter.self-transcendence.limits#p1 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.charter.self-transcendence.limits#p2 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem achievementNeedsSupport {W : Type} (achievement : Claim W) (records : List (Record W)) + (actual : W) (reliableHere : Compatible records actual) (support : Supports records achievement) : + achievement actual ∧ ConcreteAchievementExample := + ⟨support actual reliableHere, concreteAchievementExample⟩ +/- Weakening a conclusion preserves support; this makes no claim about weakening the evidence. -/ +/-- organon-map CoreReader.Evidence.supportWeakening +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem supportWeakening {W : Type} (records : List (Record W)) (p q : Claim W) + (support : Supports records p) (weaker : ∀ w, p w → q w) : Supports records q := + fun w hw => weaker w (support w hw) +/- Discarding the only informative observation loses support for the unchanged switch claim. -/ +theorem evidenceWeakeningCanLoseSupport : + Supports ([⟨id, true⟩] : List (Record Bool)) (fun w => w = true) ∧ + ¬ Supports ([] : List (Record Bool)) (fun w => w = true) := by + refine ⟨?_, ?_⟩ + · intro w hw; exact hw ⟨id,true⟩ (by simp) + · intro h; have bad := h false (by intro r hr; cases hr); cases bad +/- Restricting the quantified application domain preserves a supported universal conclusion. -/ +/-- organon-map CoreReader.Evidence.scopeRestriction +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem scopeRestriction {W X : Type} (records : List (Record W)) (p : W → X → Prop) + (wide narrow : X → Prop) (included : ∀ x, narrow x → wide x) + (support : Supports records (fun w => ∀ x, wide x → p w x)) : + Supports records (fun w => ∀ x, narrow x → p w x) := + fun w hw x hx => support w hw x (included x hx) +/- Actual applicability, rather than an optional classifier label, determines facet responsibility. -/ +def Duties {W : Type} (applicable : Facet W → Prop) : Prop := + ∀ f, applicable f → FacetDischarged f +def LabeledDuties {W : Type} (_labels : List String) (applicable : Facet W → Prop) : Prop := + Duties applicable +/- Combining applicable facets requires both sets of substantive duties. -/ +/-- organon-map CoreReader.Evidence.assessmentUnion +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem assessmentUnion {W : Type} (a b : Facet W → Prop) : + Duties (fun f => a f ∨ b f) ↔ Duties a ∧ Duties b := by + constructor + · intro h; exact ⟨fun f hf => h f (Or.inl hf), fun f hf => h f (Or.inr hf)⟩ + · rintro ⟨ha,hb⟩ f (hf|hf); exact ha f hf; exact hb f hf +/- Omitting or changing labels does not remove an applicable duty. -/ +/-- organon-map CoreReader.Evidence.labelsCannotWaive +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem labelsCannotWaive {W : Type} (xs ys : List String) (a : Facet W → Prop) : + LabeledDuties xs a ↔ LabeledDuties ys a := Iff.rfl +/- The observed switch is the outcome itself, not a record identifier. -/ +def switchRecord : Record Bool := ⟨id, true⟩ +theorem switchCompatible (w : Bool) : Compatible [switchRecord] w ↔ w = true := by + constructor + · intro h; exact h switchRecord (by simp) + · intro hw r hr; simp only [List.mem_singleton] at hr; cases hr; exact hw +theorem switchSupported : Supports [switchRecord] (fun w : Bool => w = true) := + fun w hw => (switchCompatible w).1 hw +/- The candidate action has specific benefit and cost outcomes; its inactive alternative has neither. -/ +def optionBenefit (selected : Bool) : Nat := if selected then 4 else 0 +def optionCost (selected : Bool) : Nat := if selected then 3 else 0 +/- The report describes each option's actual cost and benefit; it does not itself assert which option ought to be selected. -/ +def optionReport (selected : Bool) : Prop := + optionCost selected ≤ 3 ∧ optionBenefit selected = (if selected then 4 else 0) +/- The on position connects its own selected option to that option's benefit/cost outcome. -/ +def switchPosition : ValuePosition Bool where + Position := Bool + Outcome := Nat × Nat + adopted := true + selected := id + outcome := fun _ option => (optionBenefit option, optionCost option) + objective := fun result => result.2 < result.1 + constraints := fun _ option => optionCost option ≤ 3 + starting := singleton (fun w => w = true) + reasons := [fun _ option => optionReport option] + limits := fun _ => True + relevantCriticism := fun w => w = false + response := fun w => if w then some "benefit exceeds cost within budget" else some "reconsider if the budget no longer permits this cost" +theorem switchValueProcedure : ValueProcedure switchPosition := by + refine ⟨by simp [switchPosition], ?_, ?_, ?_⟩ + · refine ⟨true, (modelsSingleton _ _).2 rfl, trivial, rfl, ?_⟩ + intro reason hr + have hr' : reason = (fun (_ : Bool) (option : Bool) => optionReport option) := List.mem_singleton.mp hr + subst reason + exact ⟨by decide, rfl⟩ + · intro w _ _ allReasons + have evidence := allReasons (fun (_ : Bool) (option : Bool) => optionReport option) (List.mem_singleton.mpr rfl) + change optionReport true at evidence + have benefitAboveBudget : 3 < optionBenefit true := by rw [evidence.2]; decide + exact ⟨Nat.lt_of_le_of_lt evidence.1 benefitAboveBudget, evidence.1⟩ + · intro w _ _; cases w <;> simp [switchPosition] +/- Adopting the other option updates the adopted starting state too, so rejection cannot be blamed on an inconsistent start. -/ +def oppositePosition : ValuePosition Bool := + { switchPosition with adopted := false, starting := singleton (fun w => w = false) } +/- The alternative has a joint adoption witness but its actual zero benefit/cost fails the adopted strict-benefit objective. -/ +theorem oppositePositionRejected : JointAdoption oppositePosition ∧ ¬ ValueProcedure oppositePosition := by + have witness : JointAdoption oppositePosition := by + refine ⟨false, (modelsSingleton _ _).2 rfl, trivial, rfl, ?_⟩ + intro reason hr + have hr' : reason = (fun (_ : Bool) (option : Bool) => optionReport option) := List.mem_singleton.mp hr + subst reason + exact ⟨by decide, rfl⟩ + refine ⟨witness, ?_⟩ + intro h + have allReasons : ∀ reason, reason ∈ oppositePosition.reasons → reason false oppositePosition.adopted := by + intro reason hr + have hr' : reason = (fun (_ : Bool) (option : Bool) => optionReport option) := List.mem_singleton.mp hr + subst reason + exact ⟨by decide, rfl⟩ + have bad := h.2.2.1 false ((modelsSingleton _ _).2 rfl) trivial allReasons + exact Nat.lt_irrefl 0 bad.1 +/- Contradictory starting assumptions and an impossible selected/adopted equality are separate inadmissible variants. -/ +def contradictoryStartingPosition : ValuePosition Bool := + { switchPosition with starting := singleton (fun _ => False) } +def impossibleAdoptionPosition : ValuePosition Bool := + { switchPosition with selected := fun _ => false } +/- The common-world witness rejects both contradiction and an impossible commitment instead of proving them vacuously. -/ +theorem inadmissibleValuePositionsRejected : + ¬ ValueProcedure contradictoryStartingPosition ∧ ¬ ValueProcedure impossibleAdoptionPosition := by + constructor + · intro h; obtain ⟨w,hw,_,_,_⟩ := h.2.1 + exact (modelsSingleton _ _).1 hw + · intro h; obtain ⟨w,_,_,hw,_⟩ := h.2.1 + cases hw +/- Removing the reasons leaves only a position and assertion, which fails this value procedure. -/ +def unsupportedPosition : ValuePosition Bool := { switchPosition with reasons := [] } +def switchEmpirical : Facet Bool := + .empirical [switchRecord] (fun _ => True) (fun w => w = true) (fun _ => True) +theorem switchEmpiricalDischarged : FacetDischarged switchEmpirical := by + refine ⟨⟨true, (switchCompatible true).2 rfl, trivial⟩, ?_, ?_⟩ + · intro w hw _; exact switchSupported w hw + · intro w _; trivial +/- A mixed empirical/value position has actual empirical evidence but still lacks its value-reason duty. -/ +/-- organon-map CoreReader.Evidence.mixedMissingResponsibility +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem mixedMissingResponsibility : + FacetDischarged switchEmpirical ∧ + ¬ LabeledDuties [] (fun f : Facet Bool => f = switchEmpirical ∨ f = .value unsupportedPosition) := by + refine ⟨switchEmpiricalDischarged, ?_⟩ + intro h + have bad := (h (.value unsupportedPosition) (Or.inr rfl)).1 + exact bad rfl +/- A fully identified argument may still fail to entail the stated conclusion. -/ +def uninformativeArgument : Articulation Bool := + ⟨["switch state"], emptyTheory, [fun _ => True], fun _ => True⟩ +/-- organon-map CoreReader.Evidence.articulationNotSupport +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem articulationNotSupport : Articulated uninformativeArgument ∧ + ¬ Entails uninformativeArgument.assumptions (fun w : Bool => w = true) := by + exact ⟨⟨by simp [uninformativeArgument], by simp [uninformativeArgument]⟩, + consistentIncomplete.2.1⟩ +/- Identifiable but unrelated argument fields cannot replace the actual observation grounds under the connected adapter. -/ +theorem unrelatedArticulationRejected : + Articulated uninformativeArgument ∧ FacetDischarged switchEmpirical ∧ + ¬ FacetArticulated uninformativeArgument switchEmpirical := by + refine ⟨articulationNotSupport.1, switchEmpiricalDischarged, ?_⟩ + intro h + have relation := congrFun h.1 (Compatible [switchRecord]) + have bad : False := relation.mpr rfl + exact bad +/- Repetition of the same unrelated temperature observation leaves the switch state undetermined. -/ +def temperatureRecord : Record (Bool × Bool) := ⟨Prod.fst, true⟩ +theorem temperatureCompatible (b : Bool) : + Compatible [temperatureRecord, temperatureRecord] (true,b) := by + intro r hr + simp at hr + cases hr + rfl +/- The world identifies a selected action and its budget; the action costs three units. -/ +abbrev BudgetWorld := Bool × Nat +/- A real issued announcement asserts the selected action, but says nothing about affordability. -/ +def announcement : String := "activate" +def announcementPosition : ValuePosition BudgetWorld where + Position := Bool + Outcome := Nat × Nat + adopted := true + selected := Prod.fst + outcome := fun _ option => (optionBenefit option, optionCost option) + objective := fun result => result.2 < result.1 + constraints := fun w option => optionCost option ≤ w.2 + starting := singleton (fun w => w.1 = true) + reasons := [fun _ option => announcement = (if option then "activate" else "disable")] + limits := fun _ => True + relevantCriticism := fun w => w.2 < 3 + response := fun _ => some "reconsider the action when its cost exceeds budget" +/- The zero-budget counterworld satisfies the stated starts, adoption and all announced reasons jointly. -/ +theorem announcementHasJointAdoption : JointAdoption announcementPosition := by + refine ⟨(true,0), (modelsSingleton _ _).2 rfl, trivial, rfl, ?_⟩ + intro reason hr + have hr' : reason = (fun (_ : BudgetWorld) (option : Bool) => announcement = (if option then "activate" else "disable")) := + List.mem_singleton.mp hr + subst reason + rfl +/- A nonempty announcement remains true in a jointly admissible zero-budget world but cannot support the action's affordability. -/ +theorem announcementNotBudgetReason : + announcementPosition.reasons ≠ [] ∧ announcementPosition.commitment (true,0) ∧ + (∀ reason, reason ∈ announcementPosition.reasons → reason (true,0) announcementPosition.adopted) ∧ + ¬ announcementPosition.consequence (true,0) ∧ ¬ ValueProcedure announcementPosition := by + refine ⟨by simp [announcementPosition], rfl, ?_, (by intro h; cases h.2), ?_⟩ + · intro reason hr + have hr' : reason = (fun (_ : BudgetWorld) (option : Bool) => announcement = (if option then "activate" else "disable")) := List.mem_singleton.mp hr + subst reason + rfl + · intro h + have allReasons : ∀ reason, reason ∈ announcementPosition.reasons → reason (true,0) announcementPosition.adopted := by + intro reason hr + have hr' : reason = (fun (_ : BudgetWorld) (option : Bool) => announcement = (if option then "activate" else "disable")) := List.mem_singleton.mp hr + subst reason + rfl + have bad := h.2.2.1 (true,0) ((modelsSingleton _ _).2 rfl) trivial allReasons + cases bad.2 +/- A repeated actual selection observation contains no budget information. -/ +def actionRecord : Record BudgetWorld := ⟨Prod.fst, true⟩ +theorem actionCompatible (budget : Nat) : Compatible [actionRecord, actionRecord] (true,budget) := by + intro r hr; simp at hr; cases hr; rfl +/- Single and repeated irrelevant observations cannot establish the other outcome or the same action's budget adequacy. -/ +/-- organon-map CoreReader.Evidence.measurementRepeatNotSupport +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem measurementRepeatNotSupport : + temperatureRecord.test (true,false) = true ∧ + Compatible [temperatureRecord,temperatureRecord] (true,false) ∧ + Compatible [temperatureRecord,temperatureRecord] (true,true) ∧ + ¬ Supports [temperatureRecord] (fun w : Bool × Bool => w.2 = true) ∧ + ¬ Supports [temperatureRecord,temperatureRecord] (fun w : Bool × Bool => w.2 = true) ∧ + Compatible [actionRecord,actionRecord] (true,0) ∧ + Compatible [actionRecord,actionRecord] (true,3) ∧ + ¬ Supports [actionRecord] announcementPosition.consequence ∧ + ¬ Supports [actionRecord,actionRecord] announcementPosition.consequence ∧ + ¬ ValueProcedure announcementPosition := by + refine ⟨rfl, temperatureCompatible false, temperatureCompatible true, ?_, ?_, + actionCompatible 0, actionCompatible 3, ?_, ?_, announcementNotBudgetReason.2.2.2.2⟩ + · intro h + have bad := h (true,false) (by intro r hr; simp only [List.mem_singleton] at hr; cases hr; rfl) + cases bad + · intro h; have bad := h (true,false) (temperatureCompatible false); cases bad + · intro h + have bad := h (true,0) (by intro r hr; simp only [List.mem_singleton] at hr; cases hr; rfl) + cases bad.2 + · intro h; have bad := h (true,0) (actionCompatible 0); cases bad.2 +/- Missing reason records fail a procedure; independently, a present announcement fails the explicit budget-support criterion. -/ +/-- organon-map CoreReader.Evidence.selfAssertionNotReason +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem selfAssertionNotReason : + (unsupportedPosition.commitment true ∧ ¬ ValueProcedure unsupportedPosition) ∧ + (announcementPosition.reasons ≠ [] ∧ announcementPosition.commitment (true,0) ∧ + ¬ announcementPosition.consequence (true,0) ∧ ¬ ValueProcedure announcementPosition) ∧ + JointAdoption announcementPosition := + ⟨⟨rfl, fun h => h.1 rfl⟩, + ⟨announcementNotBudgetReason.1, announcementNotBudgetReason.2.1, + announcementNotBudgetReason.2.2.2.1, announcementNotBudgetReason.2.2.2.2⟩, + announcementHasJointAdoption⟩ +/- The value procedure is satisfiable although the adopted starting commitment is not entailed by empty facts. -/ +/-- organon-map CoreReader.Evidence.valueWithoutSelfProof +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem valueWithoutSelfProof : ValueProcedure switchPosition ∧ + Satisfiable switchPosition.starting ∧ + ¬ Entails (emptyTheory : Theory Bool) switchPosition.commitment ∧ + (JointAdoption oppositePosition ∧ ¬ ValueProcedure oppositePosition) ∧ + (¬ ValueProcedure contradictoryStartingPosition ∧ ¬ ValueProcedure impossibleAdoptionPosition) := + ⟨switchValueProcedure, ⟨true, (modelsSingleton _ _).2 rfl⟩, consistentIncomplete.2.1, + oppositePositionRejected, inadmissibleValuePositionsRejected⟩ +/- The world records the selected option and its actual benefit/cost outcomes. -/ +abbrev BenefitCostWorld := Bool × (Nat × Nat) +def measuredOutcome (world : BenefitCostWorld) (option : Bool) : Nat × Nat := + if option then world.2 else (0,0) +def benefitReason (world : BenefitCostWorld) (option : Bool) : Prop := + (measuredOutcome world option).1 = 4 +def costReason (world : BenefitCostWorld) (option : Bool) : Prop := + (measuredOutcome world option).2 ≤ 3 +/- Neither recorded benefit nor recorded cost alone establishes the selected option's joint consequence. -/ +def jointReasonPosition : ValuePosition BenefitCostWorld where + Position := Bool + Outcome := Nat × Nat + adopted := true + selected := Prod.fst + outcome := measuredOutcome + objective := fun result => result.2 < result.1 + constraints := fun world option => (measuredOutcome world option).2 ≤ 3 + starting := singleton (fun world => world.1 = true) + reasons := [benefitReason, costReason] + limits := fun _ => True + relevantCriticism := fun world => 3 < world.2.2 + response := fun _ => some "reassess the option when its cost exceeds the budget" +/- These two content constraints jointly establish the consequence in a nonempty adopted world. -/ +theorem jointReasonProcedure : ValueProcedure jointReasonPosition := by + refine ⟨by simp [jointReasonPosition], ?_, ?_, ?_⟩ + · refine ⟨(true,(4,3)), (modelsSingleton _ _).2 rfl, trivial, rfl, ?_⟩ + intro reason hr + change reason ∈ [benefitReason,costReason] at hr + rcases List.mem_cons.mp hr with hr | hr + · subst reason; rfl + · have hr' := List.mem_singleton.mp hr + subst reason + change 3 ≤ 3; exact Nat.le_refl 3 + · intro world _ _ reasons + have benefit := reasons benefitReason (by change benefitReason ∈ [benefitReason,costReason]; simp) + have cost := reasons costReason (by change costReason ∈ [benefitReason,costReason]; simp) + change (measuredOutcome world true).1 = 4 at benefit + change (measuredOutcome world true).2 ≤ 3 at cost + refine ⟨?_, cost⟩ + have bigger : 3 < (measuredOutcome world true).1 := by rw [benefit]; decide + exact Nat.lt_of_le_of_lt cost bigger + · intro world _ _ + exact ⟨"reassess the option when its cost exceeds the budget", rfl, by decide⟩ +/- Each separate reason has a concrete same-start/limit/adoption counterworld; their conjunction is sufficient. -/ +def JointReasonsExample : Prop := + ValueProcedure jointReasonPosition ∧ + (Models jointReasonPosition.starting (true,(4,5)) ∧ jointReasonPosition.limits (true,(4,5)) ∧ + jointReasonPosition.commitment (true,(4,5)) ∧ benefitReason (true,(4,5)) true ∧ + ¬ jointReasonPosition.consequence (true,(4,5))) ∧ + (Models jointReasonPosition.starting (true,(0,3)) ∧ jointReasonPosition.limits (true,(0,3)) ∧ + jointReasonPosition.commitment (true,(0,3)) ∧ costReason (true,(0,3)) true ∧ + ¬ jointReasonPosition.consequence (true,(0,3))) +theorem jointReasonsExample : JointReasonsExample := by + refine ⟨jointReasonProcedure, + ⟨(modelsSingleton _ _).2 rfl, trivial, rfl, rfl, ?_⟩, + ⟨(modelsSingleton _ _).2 rfl, trivial, rfl, Nat.le_refl 3, ?_⟩⟩ + · intro h; have bad : 5 ≤ 3 := h.2; omega + · intro h; have bad : 3 < 0 := h.1; omega +/- Empirical observations, semantic inference and criticism-responsive reasons coexist without a scalar score. -/ +/-- organon-map CoreReader.Evidence.heterogeneousReasons +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem heterogeneousReasons : + FacetDischarged switchEmpirical ∧ + FacetDischarged (Facet.inferential (singleton (fun w : Bool => w = true)) (fun w => w = true)) ∧ + FacetDischarged (Facet.value switchPosition) ∧ JointReasonsExample := by + refine ⟨switchEmpiricalDischarged, ⟨⟨true, (modelsSingleton _ _).2 rfl⟩, ?_⟩, switchValueProcedure, jointReasonsExample⟩ + intro w hw; exact (modelsSingleton (fun x : Bool => x = true) w).1 hw + +/- This local observation checks the actual output on input zero. -/ +def zeroRecord : Record (Nat → Bool) := ⟨fun f => f 0, true⟩ +def localGenerator (seed : Nat) : Nat → Bool := fun n => n == seed +/- All outputs being true is a stronger, explicitly quantified capability claim. -/ +def allTrue : Claim (Nat → Bool) := fun f => ∀ n, f n = true +theorem zeroCompatible (f : Nat → Bool) : Compatible [zeroRecord] f ↔ f 0 = true := by + constructor + · intro h; exact h zeroRecord (by simp) + · intro hf r hr; simp only [List.mem_singleton] at hr; cases hr; exact hf +/- A generating subject owns an earlier predicate and a seed used to revise that actual predicate. -/ +structure GeneratingProcess where + owner : Nat + prior : Nat → Bool + generateSeed : Nat +/- The revision preserves prior successes and adds the seed-selected case through the actual generator. -/ +def GeneratingProcess.outputRevision (process : GeneratingProcess) : Nat → Bool := + fun input => process.prior input || localGenerator process.generateSeed input +/- A produced revision retains its producer and exact old/new objects. -/ +structure ProducedRevision where + producer : Nat + before : Nat → Bool + after : Nat → Bool +/- The subject itself constructs the owned before/after revision object. -/ +def GeneratingProcess.produce (process : GeneratingProcess) : ProducedRevision := + ⟨process.owner, process.prior, process.outputRevision⟩ +def sampleGeneratingProcess : GeneratingProcess := ⟨17, fun _ => false, 0⟩ +/- This same-owner revision actually changes input zero, while its produced predicate still fails at input one. -/ +def OwnedRevisionExample : Prop := + sampleGeneratingProcess.produce.producer = sampleGeneratingProcess.owner ∧ + sampleGeneratingProcess.produce.before = sampleGeneratingProcess.prior ∧ + sampleGeneratingProcess.produce.after = sampleGeneratingProcess.outputRevision ∧ + sampleGeneratingProcess.produce.before 0 = false ∧ sampleGeneratingProcess.produce.after 0 = true ∧ + sampleGeneratingProcess.produce.after 1 = false ∧ + Compatible [zeroRecord] sampleGeneratingProcess.produce.after ∧ + ¬ Supports [zeroRecord] allTrue +/- Actual producer/old/new links and the compatible failing revision witness the insufficiency of self-origin. -/ +theorem ownedRevisionExample : OwnedRevisionExample := by + refine ⟨rfl,rfl,rfl,rfl,rfl,rfl,(zeroCompatible _).2 rfl, ?_⟩ + intro h + have bad := h sampleGeneratingProcess.produce.after ((zeroCompatible _).2 rfl) 1 + cases bad +/- The generator's own sample succeeds, but its generated revision has a concrete unsupported global claim. -/ +/-- organon-map CoreReader.Evidence.selfOriginDoesNotSupport +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +theorem selfOriginDoesNotSupport : + localGenerator 0 0 = true ∧ localGenerator 0 1 = false ∧ + Compatible [zeroRecord] (localGenerator 0) ∧ + ¬ Supports [zeroRecord] allTrue ∧ OwnedRevisionExample := by + refine ⟨rfl, rfl, (zeroCompatible _).2 rfl, ?_, ownedRevisionExample⟩ + intro h + have bad := h (localGenerator 0) ((zeroCompatible _).2 rfl) 1 + cases bad +/- A proper local observation allows both a universally successful and a failing extension. -/ +/-- organon-map CoreReader.Evidence.localNotUniversal +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem localNotUniversal : + (∃ outside : Nat, outside ≠ 0) ∧ + Compatible [zeroRecord] (fun _ => true) ∧ + Compatible [zeroRecord] (localGenerator 0) ∧ + allTrue (fun _ => true) ∧ ¬ allTrue (localGenerator 0) ∧ + ¬ Supports [zeroRecord] allTrue := by + refine ⟨⟨1, by decide⟩, (zeroCompatible _).2 rfl, (zeroCompatible _).2 rfl, + (fun _ => rfl), ?_, selfOriginDoesNotSupport.2.2.2.1⟩ + intro h; have bad := h 1; cases bad +/- Two implementations agree on the actual observed input and differ on a specified relevant omitted input. -/ +/-- organon-map CoreReader.Evidence.hiddenDifference +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem hiddenDifference : + (∀ n : Nat, n = 0 → (fun _ : Nat => true) n = localGenerator 0 n) ∧ + (fun _ : Nat => true) 1 ≠ localGenerator 0 1 := by + refine ⟨?_, by decide⟩ + intro n hn; cases hn; rfl +/- One observation supplies only its actual input-specific consequence, without repetition. -/ +/-- organon-map CoreReader.Evidence.singleObservation +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem singleObservation : [zeroRecord].length = 1 ∧ + (∃ f, Compatible [zeroRecord] f) ∧ + Supports [zeroRecord] (fun f => f 0 = true) ∧ + ¬ Supports [zeroRecord] allTrue := + ⟨rfl, ⟨localGenerator 0, (zeroCompatible _).2 rfl⟩, + (fun f hf => (zeroCompatible f).1 hf), selfOriginDoesNotSupport.2.2.2.1⟩ +/- This inferential assessment derives a successor value from its explicit numeric premise without observation. -/ +def arithmeticFacet : Facet Nat := .inferential (singleton (fun n => n = 2)) (fun n => n + 1 = 3) +def usesObservation {W : Type} : Facet W → Bool + | .empirical _ _ _ _ => true + | _ => false +/- An actual valid inferential assessment refutes a mandatory measurement/repetition/framework chain. -/ +/-- organon-map CoreReader.Evidence.noUniversalChain +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem noUniversalChain : FacetDischarged arithmeticFacet ∧ usesObservation arithmeticFacet = false := by + refine ⟨⟨⟨2, (modelsSingleton _ _).2 rfl⟩, ?_⟩, rfl⟩ + intro n hn + have premise := (modelsSingleton (fun x : Nat => x = 2) n).1 hn + change n + 1 = 3 + rw [premise] +/- A trial has a reproducible setting, an actual outcome and a separately recorded outcome. -/ +structure Trial where + setting : Nat + actualOutcome : Nat + recordedOutcome : Nat +/- Verifying a record, reproducing settings and retaining a conclusion are separate predicates. -/ +def Verified (t : Trial) : Prop := t.recordedOutcome = t.actualOutcome +def Reproduced (a b : Trial) : Prop := a.setting = b.setting +def Bounded (t : Trial) : Prop := t.actualOutcome ≤ 2 +/- Same-setting possible trials can differ while preserving the chosen bound; no probability semantics is claimed. -/ +/-- organon-map CoreReader.Evidence.variableOutcomesStableBound +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem variableOutcomesStableBound : + let a : Trial := ⟨0,1,1⟩ + let b : Trial := ⟨0,2,2⟩ + Reproduced a b ∧ a.actualOutcome ≠ b.actualOutcome ∧ Bounded a ∧ Bounded b := by + simp [Reproduced, Bounded] +/- Concrete records distinguish record accuracy, condition reproduction and conclusion stability. -/ +/-- organon-map CoreReader.Evidence.verificationReproductionStability +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem verificationReproductionStability : + (Verified ⟨0,1,1⟩ ∧ Verified ⟨1,1,1⟩ ∧ ¬ Reproduced ⟨0,1,1⟩ ⟨1,1,1⟩) ∧ + (Reproduced ⟨0,1,1⟩ ⟨0,3,2⟩ ∧ ¬ Verified ⟨0,3,2⟩ ∧ ¬ Bounded ⟨0,3,2⟩) ∧ + (Bounded ⟨0,1,1⟩ ∧ Bounded ⟨0,2,0⟩ ∧ ¬ Verified ⟨0,2,0⟩) := by + simp [Verified, Reproduced, Bounded] +/- Explanation certificates are executable syntax for this same arithmetic process. -/ +inductive Program where + | doubleInput + | constant (value : Nat) +def Program.eval : Program → Nat → Nat + | .doubleInput, n => n + n + | .constant value, _ => value +/- A process exposes outputs and an explanation response, whose certificate can be checked against those outputs. -/ +structure Process where + output : Nat → Nat + explanation : Option Program +/- The output-only application contract checks every relevant input. -/ +def OutputContract (p : Process) : Prop := ∀ n, p.output n = n + n +/- The explanation application contract requires a provided certificate faithful to this very process. -/ +def ExplanationContract (p : Process) : Prop := + ∃ program, p.explanation = some program ∧ ∀ n, program.eval n = p.output n +/- This process produces doubled values but returns no explanatory certificate. -/ +def outputOnlyProcess : Process := ⟨fun n => n + n, none⟩ +def explainedProcess : Process := ⟨fun n => n + n, some .doubleInput⟩ +/- Object scope fixes the very process whose contract is assessed; contract inputs themselves still range over all naturals. -/ +def processScope (assessed : Process) : Theory Process := + singleton (fun candidate => candidate = assessed) +/- This inferential facet checks an explicit contract under exact process-identity assumptions. -/ +def processContractFacet (assessed : Process) (contract : Claim Process) : Facet Process := + .inferential (processScope assessed) contract +/- The scope's compatible interpretations are exactly this assessed process, not an unrelated substitute. -/ +theorem processScopeModels (assessed candidate : Process) : + Models (processScope assessed) candidate ↔ candidate = assessed := + modelsSingleton (fun process => process = assessed) candidate +/- A concrete contract proof supplies the facet's consequence for its scoped object. -/ +theorem processContractDischarged (assessed : Process) (contract : Claim Process) (proof : contract assessed) : + FacetDischarged (processContractFacet assessed contract) := by + refine ⟨⟨assessed,(processScopeModels _ _).2 rfl⟩, ?_⟩ + intro candidate hc + have same := (processScopeModels _ _).1 hc + subst candidate + exact proof +/- Scoped capability grounds include exact claim, object-specific assumptions, canonical articulation and actual assessment. -/ +def ProcessGrounds (assessed : Process) (contract : Claim Process) : Prop := + Grounds contract canonicalArticulation (fun facet => facet = processContractFacet assessed contract) + [processContractFacet assessed contract] +theorem processGrounds (assessed : Process) (contract : Claim Process) (proof : contract assessed) : + ProcessGrounds assessed contract := by + have discharged := processContractDischarged assessed contract proof + refine ⟨by simp, ?_, ?_⟩ + · intro facet hf; subst facet; exact List.mem_singleton.mpr rfl + · intro facet hf; have hf' := List.mem_singleton.mp hf; subst facet + exact ⟨rfl,canonicalArticulated _ discharged,canonicalFacetArticulated _,discharged⟩ +/- Universal output correctness here comes from the concrete program definition, not from an assumed capability label. -/ +theorem outputCorrectByEvaluation : OutputContract outputOnlyProcess := fun _ => rfl +/- This same process actually returns no explanation certificate. -/ +theorem outputOnlyNoExplanation : ¬ ExplanationContract outputOnlyProcess := by + rintro ⟨program,h,_⟩; cases h +/- The full application contract requires outputs and an explanation of that same process. -/ +def FullProcessContract (assessed : Process) : Prop := OutputContract assessed ∧ ExplanationContract assessed +/- Output-only grounds have the assessed process itself as a counterworld to the stronger contract. -/ +def OutputContractEvidence : Prop := + ProcessGrounds outputOnlyProcess OutputContract ∧ + Models (processScope outputOnlyProcess) outputOnlyProcess ∧ + ¬ Entails (processScope outputOnlyProcess) FullProcessContract +/- Existing output evidence does not supply the absent explanation for the same object and scope. -/ +theorem outputContractEvidence : OutputContractEvidence := by + refine ⟨processGrounds _ _ outputCorrectByEvaluation, (processScopeModels _ _).2 rfl, ?_⟩ + intro stronger + exact outputOnlyNoExplanation (stronger outputOnlyProcess ((processScopeModels _ _).2 rfl)).2 +/- Both actual application contracts have grounds and explicit object scopes; neither scope is empty. -/ +def ScopedApplicationEvidence : Prop := + ProcessGrounds outputOnlyProcess OutputContract ∧ + ProcessGrounds explainedProcess FullProcessContract ∧ + (∀ candidate, Models (processScope outputOnlyProcess) candidate ↔ candidate = outputOnlyProcess) ∧ + (∀ candidate, Models (processScope explainedProcess) candidate ↔ candidate = explainedProcess) ∧ + Satisfiable (processScope outputOnlyProcess) ∧ Satisfiable (processScope explainedProcess) +/- Concrete evaluation and a faithful double-input certificate establish the two differently scoped contracts. -/ +theorem scopedApplicationEvidence : ScopedApplicationEvidence := by + refine ⟨processGrounds _ _ outputCorrectByEvaluation, processGrounds _ _ ?_, + processScopeModels _,processScopeModels _,⟨_,(processScopeModels _ _).2 rfl⟩, + ⟨_,(processScopeModels _ _).2 rfl⟩⟩ + exact ⟨fun _ => rfl,⟨.doubleInput,rfl,fun _ => rfl⟩⟩ +/- Universal output correctness does not entail the explanation-requiring contract for the same process. -/ +/-- organon-map CoreReader.Evidence.outputNotExplanation +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem outputNotExplanation : OutputContract outputOnlyProcess ∧ + ¬ ExplanationContract outputOnlyProcess ∧ OutputContractEvidence := + ⟨outputCorrectByEvaluation, outputOnlyNoExplanation, outputContractEvidence⟩ +/- Applications may use distinct contracts, and a faithful certificate can satisfy the stronger one. -/ +/-- organon-map CoreReader.Evidence.applicationContractsDiffer +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem applicationContractsDiffer : + (OutputContract outputOnlyProcess ∧ ¬ (OutputContract outputOnlyProcess ∧ ExplanationContract outputOnlyProcess)) ∧ + (OutputContract explainedProcess ∧ ExplanationContract explainedProcess) ∧ + ScopedApplicationEvidence := + ⟨⟨outputCorrectByEvaluation, fun h => outputOnlyNoExplanation h.2⟩, + ⟨(fun _ => rfl), ⟨.doubleInput, rfl, fun _ => rfl⟩⟩, scopedApplicationEvidence⟩ +/- The assessor supplies a mathematical certificate; the process's own explanation response is unnecessary. -/ +structure ExternalCertificate (p : Process) where + assessorId : Nat + assessedId : Nat + distinctParticipants : assessorId ≠ assessedId + outputCorrect : ∀ n, p.output n = n + n +/- The external assessor 42 evaluates the specified process 7; the full output proof is constructed by evaluation. -/ +def externalOutputCertificate : ExternalCertificate outputOnlyProcess := + ⟨42,7,by decide,fun _ => rfl⟩ +/- An external certificate establishes the output contract without producing an internal explanation. -/ +/-- organon-map CoreReader.Evidence.externalAssessment +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem externalAssessment : + (∃ certificate : ExternalCertificate outputOnlyProcess, + certificate.assessorId = 42 ∧ certificate.assessedId = 7 ∧ + certificate.assessorId ≠ certificate.assessedId ∧ OutputContract outputOnlyProcess) ∧ + ProcessGrounds outputOnlyProcess OutputContract ∧ + ¬ ExplanationContract outputOnlyProcess := + ⟨⟨externalOutputCertificate,rfl,rfl,externalOutputCertificate.distinctParticipants, + externalOutputCertificate.outputCorrect⟩, + processGrounds outputOnlyProcess OutputContract externalOutputCertificate.outputCorrect, + outputOnlyNoExplanation⟩ +/- This argument records concepts and actual premises for a semantic inference, separately from executable tests. -/ +def arithmeticArticulation : Articulation Nat := canonicalArticulation arithmeticFacet +/- A reasoned inferential assessment needs no observation method, while applicable empirical assessment retains observations. -/ +/-- organon-map CoreReader.Evidence.nonExecutableAssessment +organon.relationships.terms#p1 sha256 0d22f818e4466a5ab4272607ac0ab26997270cf05c64ce9ac547e866068907d1 +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem nonExecutableAssessment : + Grounds (fun n : Nat => n + 1 = 3) canonicalArticulation (fun f => f = arithmeticFacet) [arithmeticFacet] ∧ + usesObservation arithmeticFacet = false ∧ + FacetDischarged switchEmpirical ∧ usesObservation switchEmpirical = true := by + refine ⟨⟨by simp, (by intro f hf; cases hf; simp), ?_⟩, rfl, switchEmpiricalDischarged, rfl⟩ + intro f hf; simp only [List.mem_singleton] at hf; cases hf + exact ⟨rfl, canonicalArticulated _ noUniversalChain.1, canonicalFacetArticulated _, noUniversalChain.1⟩ + +end CoreReader.Evidence +``` + + + + **L1** Import CoreReader.Logic, making its checked declarations available to this module; this line states no new philosophical result. + + + **L2** Import CoreReader.Agency, making its checked declarations available to this module; this line states no new philosophical result. + + + **L4** Open namespace CoreReader.Evidence so subsequent declarations receive this module-qualified name. + + + **L5** Make names from CoreReader.Logic available without qualification; this changes name resolution, not assumptions. + + + **L6** Make names from CoreReader.Agency available without qualification; this changes name resolution, not assumptions. + + + **L8** Document the intended scope of Record. The corresponding declaration concerns: A record packages a supplied Boolean test and its supplied observed result; provenance and measurement reliability are not fields. This comment is explanatory, not a proof premise. + + + **L9** Declare the data interface Record. A record packages a supplied Boolean test and its supplied observed result; provenance and measurement reliability are not fields. + + + **L10** Store a specified Boolean test that reads the actual represented world. + + + **L11** Store the observed Boolean outcome to which that test will be compared. + + + **L12** Document the intended scope of Compatible. The corresponding declaration concerns: A world is compatible when every listed test yields its recorded result. The empty record list admits every world. This comment is explanatory, not a proof premise. + + + **L13** Define Compatible. A world is compatible when every listed test yields its recorded result. The empty record list admits every world. + + + **L14** Require every listed record’s actual test at w to equal that record’s observed outcome. + + + **L15** Document the intended scope of Supports. The corresponding declaration concerns: Support means that the claim holds in every compatible modeled world. It is semantic entailment from records, not a statistical confidence measure. This comment is explanatory, not a proof premise. + + + **L16** Define Supports. Support means that the claim holds in every compatible modeled world. It is semantic entailment from records, not a statistical confidence measure. + + + **L17** Require the very claim to hold in every world compatible with all records; absent compatible worlds this implication alone can be vacuous. + + + **L18** Document the intended scope of Articulation. The corresponding declaration concerns: Packages concept strings, an assumption theory, a list of reason claims, and a scope/limits claim. This comment is explanatory, not a proof premise. + + + **L19** Declare the data interface Articulation. Packages concept strings, an assumption theory, a list of reason claims, and a scope/limits claim. + + + **L20** Store identifiable concept names; strings alone do not establish semantic adequacy. + + + **L21** Store the actual theory stated as the articulation’s assumptions. + + + **L22** Store reason contents as propositions about the same world type. + + + **L23** Store the actual application-limit predicate for those reasons. + + + **L24** Document the intended scope of Articulated. The corresponding declaration concerns: Checks only that concept and reason lists are nonempty; it does not establish truth, relevance, or a relation to the target claim. This comment is explanatory, not a proof premise. + + + **L25** Define Articulated. Checks only that concept and reason lists are nonempty; it does not establish truth, relevance, or a relation to the target claim. + + + **L26** Require nonempty concept and reason lists only; this procedural condition is weaker than matching, discharged Grounds. + + + **L27** Document the intended scope of ValuePosition. The corresponding declaration concerns: Represents an adopted option, selected option, option-indexed outcomes/reasons, objectives, constraints, starting theory, scope and criticism response; this is a disclosed application adapter. This comment is explanatory, not a proof premise. + + + **L28** Declare the data interface ValuePosition. Represents an adopted option, selected option, option-indexed outcomes/reasons, objectives, constraints, starting theory, scope and criticism response; this is a disclosed application adapter. + + + **L29** Supply the type of options among which this value position adopts one. + + + **L30** Supply the outcome type used to interpret the effects of each option. + + + **L31** Specify which option is adopted, separately from which option a world actually selects. + + + **L32** Read the actually selected option from each world. + + + **L33** Interpret the actual outcome of each option at each world, rather than storing an arbitrary support label. + + + **L34** State the adopted objective as a predicate on outcomes; its value authority is not proved by this field. + + + **L35** State the world- and option-specific constraints checked alongside the objective. + + + **L36** Store the starting theory; JointAdoption will require it to share a real model with adoption and reasons. + + + **L37** Store reasons parameterized by both world and option, so switching the adopted option changes the assessed reasons. + + + **L38** Specify the scope within which this value-assessment procedure claims its conclusions. + + + **L39** Identify which worlds present relevant criticism; this is an explicit application predicate. + + + **L40** Store an optional textual response at each world; its presence does not prove that the criticism is answered adequately. + + + **L41** Document the intended scope of ValuePosition.commitment. The corresponding declaration concerns: The commitment claim says the world selects this position's adopted option; it is no longer a freely relabeled separate claim field. This comment is explanatory, not a proof premise. + + + **L42** Define ValuePosition.commitment. The commitment claim says the world selects this position's adopted option; it is no longer a freely relabeled separate claim field. + + + **L43** Derive the commitment claim by equating actual selection with this very adopted option. + + + **L44** Document the intended scope of ValuePosition.consequence. The corresponding declaration concerns: Checks this adopted option's modeled outcome against its objective and constraints. This comment is explanatory, not a proof premise. + + + **L45** Define ValuePosition.consequence. Checks this adopted option's modeled outcome against its objective and constraints. + + + **L46** Derive the assessed consequence from this adopted option’s actual outcome satisfying the objective and its actual constraints. + + + **L47** Document the intended scope of ValuePosition.activeReasons. The corresponding declaration concerns: Specializes every option-indexed reason to the adopted option for articulation. This comment is explanatory, not a proof premise. + + + **L48** Define ValuePosition.activeReasons. Specializes every option-indexed reason to the adopted option for articulation. + + + **L49** Specialize each option-indexed reason to the adopted option to produce its actual articulated world predicate. + + + **L50** Document the intended scope of JointAdoption. The corresponding declaration concerns: Requires one world jointly modeling the starting theory, scope, actual adoption and all adopted-option reasons. This comment is explanatory, not a proof premise. + + + **L51** Define JointAdoption. Requires one world jointly modeling the starting theory, scope, actual adoption and all adopted-option reasons. + + + **L52** Require one common world for starting assumptions, application limits and actual adoption. + + + **L53** At that same witness, require every listed reason for that adopted option to hold together. + + + **L54** Document the intended scope of ValueProcedure. The corresponding declaration concerns: Requires nonempty reasons, a joint adoption witness, joint reasons supporting the option's consequence within starting assumptions/scope, and nonempty criticism responses. It does not prove ultimate value correctness. This comment is explanatory, not a proof premise. + + + **L55** Define ValueProcedure. Requires nonempty reasons, a joint adoption witness, joint reasons supporting the option's consequence within starting assumptions/scope, and nonempty criticism responses. It does not prove ultimate value correctness. + + + **L56** Begin ValueProcedure with nonempty reasons and the complete joint adoption witness. + + + **L57** For every world satisfying the actual starting theory and limits, impose the following conditional consequence requirement. + + + **L58** Use the conjunction of all reasons for the adopted option to imply its actual consequence; no individual-reason sufficiency requirement is imposed. + + + **L59** Within limits, every relevant criticism must receive a specified nonempty response; this checks recorded response, not persuasiveness. + + + **L60** Document the intended scope of Facet. The corresponding declaration concerns: Defines three distinct facet kinds with different discharge conditions. This comment is explanatory, not a proof premise. + + + **L61** Declare the alternatives Facet. Defines three distinct facet kinds with different discharge conditions. + + + **L62** An empirical facet stores actual test records together with its scope, conclusion and stated uncertainty predicate. + + + **L63** An inferential facet stores its actual premise theory and the conclusion to be entailed from it. + + + **L64** A value facet stores the entire option/outcome position, including its starting theory, reasons, limits and criticism response. + + + **L65** Document the intended scope of Facet.claim. The corresponding declaration concerns: Extracts the target claim of a facet, using the commitment rather than consequence for a value facet. This comment is explanatory, not a proof premise. + + + **L66** Define Facet.claim. Extracts the target claim of a facet, using the commitment rather than consequence for a value facet. + + + **L67** Read the empirical facet’s own conclusion p as its claim; records, scope and uncertainty remain assessment inputs. + + + **L68** Read the inferential facet’s own conclusion p as its claim, separately from its premise theory. + + + **L69** The value facet’s claim is actual selection equaling its own adopted option, derived through v.commitment. + + + **L70** Document the intended scope of FacetDischarged. The corresponding declaration concerns: Dispatches to a different check for each facet kind; these checks have different truth guarantees. This comment is explanatory, not a proof premise. + + + **L71** Define FacetDischarged. Dispatches to a different check for each facet kind; these checks have different truth guarantees. + + + **L72** Enter the empirical discharge case with this facet’s actual records, scope, conclusion p and uncertainty predicate. + + + **L73** For an empirical facet, require a world compatible with its records and inside its scope, excluding an empty empirical domain. + + + **L74** Require the records to support the scoped conclusion and the explicitly stated uncertainty predicate. + + + **L75** Inferential discharge requires a nonempty model of the actual assumptions and semantic entailment of p from those same assumptions. + + + **L76** Value discharge is exactly the declared ValueProcedure for that same position, not a proof of ultimate value adequacy. + + + **L77** Document the intended scope of FacetArticulated. The corresponding declaration concerns: Requires articulation fields to match the facet's own assumptions, reasons and limits; concept strings are not constrained here. This comment is explanatory, not a proof premise. + + + **L78** Define FacetArticulated. Requires articulation fields to match the facet's own assumptions, reasons and limits; concept strings are not constrained here. + + + **L79** In the empirical articulation case, read the actual records and scope whose assumptions/reasons/limits must match. + + + **L80** This empirical adapter equates articulated assumptions and reasons with actual record compatibility, and articulated limits with the empirical scope. + + + **L81** In the inferential case, use this facet’s actual assumption theory as the articulation’s reference. + + + **L82** This inferential adapter retains the exact premise theory, articulates its model condition as the reason, and uses unrestricted additional limits. + + + **L83** Require value articulation to use exactly this position’s starting theory, adopted-option active reasons and limits. + + + **L84** Document the intended scope of canonicalArticulation. The corresponding declaration concerns: Constructs field-aligned articulations by pattern matching; the fixed concept strings are descriptive labels. This comment is explanatory, not a proof premise. + + + **L85** Define canonicalArticulation. Constructs field-aligned articulations by pattern matching; the fixed concept strings are descriptive labels. + + + **L86** Construct the empirical canonical articulation from the actual record list and scope of the selected facet. + + + **L87** Construct empirical articulation naming test outcomes and conditions, using the actual compatibility claim as its premise/reason and the original scope as its limit. + + + **L88** Construct inferential canonical articulation from this facet’s actual premise theory. + + + **L89** Construct inferential articulation from the same theory and its actual model predicate, with no extra limit. + + + **L90** Construct the value articulation using the same complete position v. + + + **L91** Construct value articulation from the actual starting theory, adopted-option reasons and original limits. + + + **L92** Document the intended scope of canonicalFacetArticulated. The corresponding declaration concerns: Proves all canonical articulations have the required field alignment; no discharge hypothesis is needed for equality by construction. This comment is explanatory, not a proof premise. + + + **L93** State the checked result canonicalFacetArticulated. Proves all canonical articulations have the required field alignment; no discharge hypothesis is needed for equality by construction. + + + **L94** Assert that canonical articulation is semantically connected to this very facet; the proof checks each facet constructor. + + + **L95** Split the three facet constructors; each canonical articulation has exactly the assumptions, reasons and limits required by its matching branch, so all three equalities are reflexive. + + + **L96** Document the intended scope of canonicalArticulated. The corresponding declaration concerns: Given a discharged facet, proves its canonical concept/reason lists are nonempty. The value case uses the discharge premise's reason nonemptiness. This comment is explanatory, not a proof premise. + + + **L97** State the checked result canonicalArticulated. Given a discharged facet, proves its canonical concept/reason lists are nonempty. The value case uses the discharge premise's reason nonemptiness. + + + **L98** Given this facet’s discharge, require its canonical concepts and reasons to be nonempty. + + + **L99** Check canonical articulation separately for empirical, inferential and value facets. + + + **L100** In this empirical or inferential branch, the canonical concept and reason lists are explicitly nonempty; simplification verifies both articulation requirements. + + + **L101** In this empirical or inferential branch, the canonical concept and reason lists are explicitly nonempty; simplification verifies both articulation requirements. + + + **L102** For the value branch, the premise h is ValueProcedure v; its nonempty reasons must establish nonempty canonical active reasons. + + + **L103** For a value facet, supply nonempty canonical concepts and leave the nonempty active-reason obligation. + + + **L104** Use the discharged value procedure’s nonempty reasons; specializing them to the adopted option preserves nonemptiness. + + + **L105** Document the intended scope of Grounds. The corresponding declaration concerns: Grounds packages a nonempty facet list, coverage of a supplied applicability predicate, common claim identity, articulation presence/alignment, and every listed facet's discharge. It is not uniformly a truth certificate for the claim. This comment is explanatory, not a proof premise. + + + **L106** Begin provenance metadata for CoreReader.Evidence.Grounds; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L107** Register source unit organon.grounds#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L108** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L109** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L110** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L111** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L112** Define Grounds. Grounds packages a nonempty facet list, coverage of a supplied applicability predicate, common claim identity, articulation presence/alignment, and every listed facet's discharge. It is not uniformly a truth certificate for the claim. + + + **L113** Take actualApplicable independently of the finite list, so coverage is an explicit obligation rather than inferred from list membership. + + + **L114** Require a nonempty facet list and inclusion of every facet satisfying actualApplicable. + + + **L115** For every listed facet, require the exact claim and a nonempty articulation belonging to that facet. + + + **L116** Also require semantic matching to its actual premises/reasons/limits and discharge by its declared adapter. + + + **L117** Document the intended scope of AchievementAccountability. The corresponding declaration concerns: Defines achievement accountability as exactly the same Grounds predicate, with no additional execution or achievement proof. This comment is explanatory, not a proof premise. + + + **L118** Begin provenance metadata for CoreReader.Evidence.AchievementAccountability; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L119** Register source unit organon.charter.self-transcendence.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L120** Register source unit organon.charter.self-transcendence.limits#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L121** Register source unit organon.grounds#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L122** Register source unit organon.grounds.capabilities#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L123** Register source unit organon.grounds.capabilities#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L124** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L125** Define AchievementAccountability. Defines achievement accountability as exactly the same Grounds predicate, with no additional execution or achievement proof. + + + **L126** Achievement accountability accepts the same actual-applicability predicate and facet list as Grounds. + + + **L127** Define accountability directly by Grounds for the very achievement claim; no extra universal observation requirement is added. + + + **L128** Document the intended scope of transitionAchievement. The corresponding declaration concerns: Defines achievement as understanding/construction expansion between the same modeled transition's before and after states. This comment is explanatory, not a proof premise. + + + **L129** Define transitionAchievement. Defines achievement as understanding/construction expansion between the same modeled transition's before and after states. + + + **L130** The achievement claim is actual expansion between the selected transition’s own before and after states. + + + **L131** Document the intended scope of transitionPerformanceRecord. The corresponding declaration concerns: Tests whether that after-state contains successor actually returning one at the transition input, within the two-transition model. This comment is explanatory, not a proof premise. + + + **L132** Define transitionPerformanceRecord. Tests whether that after-state contains successor actually returning one at the transition input, within the two-transition model. + + + **L133** The performance test inspects operations actually constructed in this transition’s after-state. + + + **L134** It records true only when successor is present and actually sends the shared transition input to 1. + + + **L135** Document the intended scope of transitionReportRecord. The corresponding declaration concerns: Records only the report's announced operation/input/output, not its actual achievement. This comment is explanatory, not a proof premise. + + + **L136** Define transitionReportRecord. Records only the report's announced operation/input/output, not its actual achievement. + + + **L137** Begin a record whose test reads the actual transition’s announcement. + + + **L138** Bind report to the announcement generated for this same transition. + + + **L139** Test its stated successor, input 0 and expected output 1, recording a positive announcement independently of whether the operation exists. + + + **L140** Document the intended scope of transitionPerformanceCompatible. The corresponding declaration concerns: Exhausts inflate/extend to show the actual performance record identifies extension. This comment is explanatory, not a proof premise. + + + **L141** State the checked result transitionPerformanceCompatible. Exhausts inflate/extend to show the actual performance record identifies extension. + + + **L142** Claim that matching the actual positive performance record is equivalent to selecting extend. + + + **L143** Fix an arbitrary actual transition, either inflate or extend, for the record-compatibility equivalence. + + + **L144** Prove both directions: performance compatibility implies extend, and extend supplies compatibility. + + + **L145** Assume this transition matches the actual positive performance record. + + + **L146** Apply compatibility to the actual singleton performance record to obtain its observed test result for this transition. + + + **L147** Split the actual transition into inflate and extend, whose after-states have different operation content. + + + **L148** The inflate state lacks successor, so its performance test cannot equal the recorded true outcome. + + + **L149** The extend case has the required transition identity by reflexivity. + + + **L150** For the reverse implication, substitute the assumption that the transition is extend. + + + **L151** Membership in the singleton record list identifies the arbitrary record with this exact transition record; substitute it before checking its test. + + + **L152** Evaluate the actual extend performance record; its successor-at-zero test equals the recorded true outcome. + + + **L153** Document the intended scope of transitionSupported. The corresponding declaration concerns: Uses performance identification, the concrete new operation and report claim to establish transition expansion in every compatible case. This comment is explanatory, not a proof premise. + + + **L154** State the checked result transitionSupported. Uses performance identification, the concrete new operation and report claim to establish transition expansion in every compatible case. The following tactic block proves this explicit type. + + + **L155** Take an arbitrary transition and its compatibility with the actual performance record; prove expansion for that same transition. + + + **L156** Use transitionPerformanceCompatible to identify every performance-compatible transition as extend. + + + **L157** Substitute extend for the transition, so the remaining achievement claim concerns its real extended after-state. + + + **L158** Check the same system-generated extend report against its actual before/after states: successor is newly constructed and sends input 0 to output 1. + + + **L159** Check the same system-generated extend report against its actual before/after states: successor is newly constructed and sends input 0 to output 1. + + + **L160** Check the same system-generated extend report against its actual before/after states: successor is newly constructed and sends input 0 to output 1. + + + **L161** Apply announcementClaimImpliesExpansion to the verified report content to obtain the same transition’s Expanded claim. + + + **L162** Document the intended scope of transitionFacet. The corresponding declaration concerns: Packages the performance record, input-zero scope and exact expansion claim as an empirical facet. This comment is explanatory, not a proof premise. + + + **L163** Define transitionFacet. Packages the performance record, input-zero scope and exact expansion claim as an empirical facet. + + + **L164** Build an empirical facet from the performance record with the exact input-0 transition scope. + + + **L165** Its conclusion is the same transition’s achievement; its uncertainty predicate is explicitly True. + + + **L166** Document the intended scope of transitionFacetDischarged. The corresponding declaration concerns: Supplies extension as a nonempty witness, actual support and trivial uncertainty. This comment is explanatory, not a proof premise. + + + **L167** State the checked result transitionFacetDischarged. Supplies extension as a nonempty witness, actual support and trivial uncertainty. The following tactic block proves this explicit type. + + + **L168** Provide extend as the nonempty empirical witness with compatible performance evidence and the shared input-0 scope; leave scoped support and uncertainty checks. + + + **L169** The already proved transition support supplies the achievement at any compatible transition, hence within the chosen scope. + + + **L170** The explicitly unrestricted uncertainty predicate is True, so this adapter component is immediate; no quantitative uncertainty bound is inferred. + + + **L171** Document the intended scope of transitionAccountable. The corresponding declaration concerns: Builds achievement Grounds with matching claim, scope, canonical articulation and discharged facet. This comment is explanatory, not a proof premise. + + + **L172** State the checked result transitionAccountable. Builds achievement Grounds with matching claim, scope, canonical articulation and discharged facet. + + + **L173** State accountability for the actual transition-achievement predicate with canonical articulation. + + + **L174** Declare transitionFacet the only applicable facet and use precisely that singleton evidence package. + + + **L175** Split accountability into nonempty facets, coverage of actual applicability, and matching articulated discharge for each included facet. + + + **L176** The applicability assumption identifies the facet with the one prescribed facet, which belongs to the singleton list. + + + **L177** Singleton membership identifies the current facet with the prescribed one; substitute it to check its exact claim and grounds. + + + **L178** Assemble identical claim, nonempty canonical articulation, its semantic connection to this facet, and transitionFacetDischarged. + + + **L179** Assemble identical claim, nonempty canonical articulation, its semantic connection to this facet, and transitionFacetDischarged. + + + **L180** Document the intended scope of transitionReportCompatible. The corresponding declaration concerns: Shows both transition cases produce the same announced operation/input/output record. This comment is explanatory, not a proof premise. + + + **L181** State the checked result transitionReportCompatible. Shows both transition cases produce the same announced operation/input/output record. + + + **L182** State that this transition’s positive report record is compatible with the transition itself, including inflate. + + + **L183** Membership in the singleton record list identifies the arbitrary record with this exact transition record; substitute it before checking its test. + + + **L184** The report test only checks the actual positive announcement contents, which evaluate identically for either transition. + + + **L185** Document the intended scope of transitionReportDoesNotSupport. The corresponding declaration concerns: Uses the inflated transition as a report-compatible non-achievement countermodel. This comment is explanatory, not a proof premise. + + + **L186** State the checked result transitionReportDoesNotSupport. Uses the inflated transition as a report-compatible non-achievement countermodel. + + + **L187** Require inflate to match the report while failing the same achievement predicate. + + + **L188** Conclude that the positive report records therefore do not support the achievement over all compatible transitions. + + + **L189** Unfold the inflate transition: both understood and constructed operation sets are unchanged, so no new-operation witness for Expanded exists. + + + **L190** Unfold the inflate transition: both understood and constructed operation sets are unchanged, so no new-operation witness for Expanded exists. + + + **L191** Combine positive-report compatibility with the false expansion claim at inflate; any claimed support applied there gives a contradiction. + + + **L192** Document the intended scope of ConcreteAchievementExample. The corresponding declaration concerns: Combines same-object achievement accountability and supported extension with an unsupported inflation report, preserving before/after/input identities. This comment is explanatory, not a proof premise. + + + **L193** Define ConcreteAchievementExample. Combines same-object achievement accountability and supported extension with an unsupported inflation report, preserving before/after/input identities. + + + **L194** The concrete example includes actual accountability for the transition achievement. + + + **L195** Its actual-applicability predicate and list identify the same single transition facet. + + + **L196** Require extend to satisfy the actual performance observation. + + + **L197** Require semantic support for the achievement and its truth at extend. + + + **L198** Also retain the report-compatible inflate world in which this achievement is false. + + + **L199** State the resulting failure of support from reports alone. + + + **L200** For every transition, bind the report’s before state to the actual transition-before state. + + + **L201** Bind its after state to that same transition’s actual after state. + + + **L202** Bind the report input to the actual transition input and explicitly fix that condition to 0. + + + **L203** Document the intended scope of concreteAchievementExample. The corresponding declaration concerns: Assembles the concrete performance support, reporting countermodel and exact state/input links. This comment is explanatory, not a proof premise. + + + **L204** State the checked result concreteAchievementExample. Assembles the concrete performance support, reporting countermodel and exact state/input links. The following tactic block proves this explicit type. + + + **L205** Assemble the actual achievement’s accountability, extend performance compatibility and semantic support in the concrete example. + + + **L206** Apply that same support to the extend witness to establish actual expansion there. + + + **L207** Include the report-compatible inflate counterexample and leave the same-before/after/input relationships. + + + **L208** For either transition, all report-to-state and input-0 links hold by the definitions themselves. + + + **L209** Document the intended scope of achievementNeedsSupport. The corresponding declaration concerns: Applies supplied compatible-world support to the arbitrary actual claim and separately includes the checked concrete transition example. This comment is explanatory, not a proof premise. + + + **L210** Begin provenance metadata for CoreReader.Evidence.achievementNeedsSupport; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L211** Register source unit organon.charter.self-transcendence.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L212** Register source unit organon.charter.self-transcendence.limits#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L213** Register source unit organon.grounds#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L214** Register source unit organon.grounds.capabilities#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L215** Register source unit organon.grounds.capabilities#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L216** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L217** State the checked result achievementNeedsSupport. Applies supplied compatible-world support to the arbitrary actual claim and separately includes the checked concrete transition example. + + + **L218** Assume the chosen actual world matches all records and those records already support the achievement. + + + **L219** Conclude truth of the achievement at that actual world, together with the separately constructed concrete achievement example. + + + **L220** Apply the assumed support to the actual evidence-compatible world, and pair that local truth with the separately proved concrete achievement example. + + + **L221** Document the intended scope of supportWeakening. The corresponding declaration concerns: Preserves support when a supported claim implies a weaker claim at every world; it does not weaken the record set. This comment is explanatory, not a proof premise. + + + **L222** Begin provenance metadata for CoreReader.Evidence.supportWeakening; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L223** Register source unit organon.grounds#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L224** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L225** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L226** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L227** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L228** State the checked result supportWeakening. Preserves support when a supported claim implies a weaker claim at every world; it does not weaken the record set. + + + **L229** Assume support for p and a world-by-world implication from p to q; conclude support for q using the same records. + + + **L230** At each compatible world w, first derive p using the unchanged records, then apply the supplied implication weaker to obtain q. + + + **L231** Document the intended scope of evidenceWeakeningCanLoseSupport. The corresponding declaration concerns: Provides a true Boolean observation supporting equality to true and shows deleting that record loses this support. This comment is explanatory, not a proof premise. + + + **L232** State the checked result evidenceWeakeningCanLoseSupport. Provides a true Boolean observation supporting equality to true and shows deleting that record loses this support. + + + **L233** The single identity observation supports that the Boolean world is true. + + + **L234** Deleting that observation leaves empty records, which do not support the unchanged claim. + + + **L235** Split the supported one-record claim from the failure of the same claim after deleting that record. + + + **L236** Read the informative identity test from compatibility; it directly states that the Boolean world is true. + + + **L237** With no records, false is compatible; evaluating purported support there refutes the unchanged true-world claim. + + + **L238** Document the intended scope of scopeRestriction. The corresponding declaration concerns: Restricts a universally supported property from a wider input domain to an included narrower domain, for arbitrary world and input types. This comment is explanatory, not a proof premise. + + + **L239** Begin provenance metadata for CoreReader.Evidence.scopeRestriction; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L240** Register source unit organon.grounds#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L241** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L242** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L243** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L244** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L245** State the checked result scopeRestriction. Restricts a universally supported property from a wider input domain to an included narrower domain, for arbitrary world and input types. + + + **L246** Take broad and narrow application domains and assume every narrow-domain input is in the broad domain. + + + **L247** Assume the same records support p at every input in the broad domain. + + + **L248** Conclude support at every input in the narrower domain; neither the evidence nor predicate p changes. + + + **L249** For a compatible world and narrow-domain input x, included converts narrow membership to broad membership; apply the original broad support there. + + + **L250** Document the intended scope of Duties. The corresponding declaration concerns: Requires every facet satisfying the supplied applicability predicate to be discharged. This comment is explanatory, not a proof premise. + + + **L251** Define Duties. Requires every facet satisfying the supplied applicability predicate to be discharged. + + + **L252** Require every actually applicable facet to pass its own discharge condition. + + + **L253** Define LabeledDuties. Defines labeled duties by ignoring all labels and keeping only the applicability-based duties. + + + **L254** Define labeled duties by exactly the original applicability duties; the labels supply no waiver. + + + **L255** Document the intended scope of assessmentUnion. The corresponding declaration concerns: Proves that discharging the union of two applicability predicates is equivalent to discharging each separately. This comment is explanatory, not a proof premise. + + + **L256** Begin provenance metadata for CoreReader.Evidence.assessmentUnion; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L257** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L258** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L259** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L260** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L261** State the checked result assessmentUnion. Proves that discharging the union of two applicability predicates is equivalent to discharging each separately. + + + **L262** Equate duties for the union of two applicability predicates with fulfillment of both sets of duties. + + + **L263** Prove both directions between duty on the union applicability predicate and simultaneous duties on its two components. + + + **L264** Restrict the union duty to each applicable-facet predicate using the matching disjunction injection. + + + **L265** Unpack both duty sets, split actual applicability into its left/right case, and discharge that very facet using the corresponding duty. + + + **L266** Document the intended scope of labelsCannotWaive. The corresponding declaration concerns: Proves changing labels cannot change duties because labels were ignored by definition; no external classification mechanism is analyzed. This comment is explanatory, not a proof premise. + + + **L267** Begin provenance metadata for CoreReader.Evidence.labelsCannotWaive; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L268** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L269** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L270** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L271** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L272** State the checked result labelsCannotWaive. Proves changing labels cannot change duties because labels were ignored by definition; no external classification mechanism is analyzed. + + + **L273** Changing only the label lists leaves the same duty proposition; the equivalence is reflexive. + + + **L274** Document the intended scope of switchRecord. The corresponding declaration concerns: Records the identity Boolean test with observed value true. This comment is explanatory, not a proof premise. + + + **L275** Define switchRecord. Records the identity Boolean test with observed value true. + + + **L276** State the checked result switchCompatible. Proves compatibility with the single switch record is exactly equality of the world with true. The following tactic block proves this explicit type. + + + **L277** Prove that compatibility with the singleton switch record is equivalent to the actual Boolean world being true. + + + **L278** Apply record compatibility to the sole named test to recover its actual observed equality. + + + **L279** Conversely, singleton membership identifies any listed record with this test, whose equality is the supplied observation premise. + + + **L280** State the checked result switchSupported. Supports equality to true by extracting the previously proved compatibility equivalence. The supplied proof term uses the displayed constructed witnesses or earlier lemmas, rather than adding an axiom. + + + **L281** Use switchCompatible’s forward implication to extract world=true from the same world’s actual record compatibility. + + + **L282** Document the intended scope of optionBenefit. The corresponding declaration concerns: Assigns benefit 4 to selected=true and 0 otherwise. This comment is explanatory, not a proof premise. + + + **L283** Define optionBenefit. Assigns benefit 4 to selected=true and 0 otherwise. + + + **L284** Define optionCost. Assigns cost 3 to selected=true and 0 otherwise. + + + **L285** Document the intended scope of optionReport. The corresponding declaration concerns: States option-specific cost and benefit facts rather than an unconnected reason flag. This comment is explanatory, not a proof premise. + + + **L286** Define optionReport. States option-specific cost and benefit facts rather than an unconnected reason flag. + + + **L287** The option report asserts actual cost at most 3 and the option-specific benefit of 4 for on or 0 for off. + + + **L288** Document the intended scope of switchPosition. The corresponding declaration concerns: Adopts true with actual option cost/benefit outcomes, cost-below-benefit objective, budget constraint and a scoped criticism response. This comment is explanatory, not a proof premise. + + + **L289** Define switchPosition. Adopts true with actual option cost/benefit outcomes, cost-below-benefit objective, budget constraint and a scoped criticism response. + + + **L290** Use Boolean options for on/off. + + + **L291** Represent each outcome as actual benefit and cost in a natural-number pair. + + + **L292** Adopt the on option explicitly; adoption itself is not derived from arithmetic. + + + **L293** Read the actual selected option directly from the Boolean world. + + + **L294** Compute benefit and cost from this same actual option. + + + **L295** Adopt the objective that actual benefit strictly exceeds actual cost. + + + **L296** Check the actual option cost against the fixed budget 3. + + + **L297** Assume the actual Boolean selection is on; do not insert the assessed benefit conclusion into the starting theory. + + + **L298** Use the option-indexed actual cost/benefit report as the sole reason. + + + **L299** Use an unrestricted world scope in this example; starting assumptions and reason content still constrain the procedure. + + + **L300** Mark the off-selected world as a relevant criticism case. + + + **L301** Provide distinct nonempty messages for the two worlds, including budget reconsideration in the criticism case. + + + **L302** State the checked result switchValueProcedure. Provides a consistent adoption witness and derives the adopted option's objective/constraint from its actual cost-benefit reason; both Boolean responses are checked. The following tactic block proves this explicit type. + + + **L303** Separate nonempty reasons, a joint adoption witness, consequence support by all reasons, and response to criticism for switchPosition. + + + **L304** Choose world true, satisfying the starting selection, unrestricted limit and adopted option, and leave its actual reason to check. + + + **L305** Take any reason in switchPosition’s list; the next step identifies its actual optionReport content at the adopted on witness. + + + **L306** Singleton membership identifies the arbitrary reason with optionReport specialized to this position’s adopted option; substitute that actual reason. + + + **L307** Singleton membership identifies the arbitrary reason with optionReport specialized to this position’s adopted option; substitute that actual reason. + + + **L308** Check that the adopted on option meets its recorded cost bound and its stated benefit value. + + + **L309** For an arbitrary world in the stated starting/limit conditions, assume the entire active-reason conjunction. + + + **L310** Extract the actual optionReport reason from that conjunction, rather than introducing an independent support label. + + + **L311** Unfold which option is adopted: this evidence concerns the on option. + + + **L312** Use the reported benefit equality to prove the on option’s benefit exceeds 3. + + + **L313** Combine cost ≤ 3 with benefit > 3 to prove cost < benefit, and retain the same cost bound as the constraint. + + + **L314** Check both Boolean worlds to provide the recorded nonempty criticism response where required. + + + **L315** Document the intended scope of oppositePosition. The corresponding declaration concerns: Changes the adopted option to false and updates its starting selection while retaining the same outcome model and objective. This comment is explanatory, not a proof premise. + + + **L316** Define oppositePosition. Changes the adopted option to false and updates its starting selection while retaining the same outcome model and objective. + + + **L317** Change both adopted option and starting selection to off while retaining the same actual outcome/reason interpretation. + + + **L318** Document the intended scope of oppositePositionRejected. The corresponding declaration concerns: Shows false can be jointly adopted but fails the unchanged cost-below-benefit objective, so its value procedure is rejected. This comment is explanatory, not a proof premise. + + + **L319** State the checked result oppositePositionRejected. Shows false can be jointly adopted but fails the unchanged cost-below-benefit objective, so its value procedure is rejected. The following tactic block proves this explicit type. + + + **L320** Construct an actual joint adoption witness for the opposite off position at world false; the rejection will therefore not rely on an empty domain. + + + **L321** Construct an actual joint adoption witness for the opposite off position at world false; the rejection will therefore not rely on an empty domain. + + + **L322** For the opposite position’s false-world witness, take any listed reason before checking that off option’s actual report. + + + **L323** Singleton membership identifies the arbitrary reason with optionReport specialized to this position’s adopted option; substitute that actual reason. + + + **L324** Singleton membership identifies the arbitrary reason with optionReport specialized to this position’s adopted option; substitute that actual reason. + + + **L325** The off option’s own report is true: its zero cost is within the bound and its zero benefit matches the stated report. + + + **L326** Retain the nonempty joint witness and separately refute fulfillment of the opposite value procedure. + + + **L327** Assume the opposite off position satisfies its entire ValueProcedure, to derive a contradiction with its zero-benefit outcome. + + + **L328** Assemble all of the opposite position’s reasons at its actual false-world witness before applying any consequence requirement. + + + **L329** Take any actual reason of the opposite position to assemble all reasons at its inhabited false-world counterexample. + + + **L330** Singleton membership identifies the arbitrary reason with optionReport specialized to this position’s adopted option; substitute that actual reason. + + + **L331** Singleton membership identifies the arbitrary reason with optionReport specialized to this position’s adopted option; substitute that actual reason. + + + **L332** The off option’s own report is true: its zero cost is within the bound and its zero benefit matches the stated report. + + + **L333** Apply the assumed opposite procedure’s joint-reason consequence clause to that same starting/limit witness and all its actual reasons. + + + **L334** Its purported objective would require the off option’s zero cost to be strictly less than its zero benefit, contradicting irreflexivity. + + + **L335** Document the intended scope of contradictoryStartingPosition. The corresponding declaration concerns: Replaces the starting theory with a false singleton, eliminating every joint adoption witness. This comment is explanatory, not a proof premise. + + + **L336** Define contradictoryStartingPosition. Replaces the starting theory with a false singleton, eliminating every joint adoption witness. + + + **L337** Replace the starting theory with the impossible singleton claim False. + + + **L338** Define impossibleAdoptionPosition. Always selects false while retaining adoption of true, making joint adoption impossible. + + + **L339** Keep the adopted on option but make every actual selection off, making joint adoption impossible. + + + **L340** Document the intended scope of inadmissibleValuePositionsRejected. The corresponding declaration concerns: Rejects both inconsistent starting theory and impossible adoption via the required witness. This comment is explanatory, not a proof premise. + + + **L341** State the checked result inadmissibleValuePositionsRejected. Rejects both inconsistent starting theory and impossible adoption via the required witness. + + + **L342** Reject the procedures for contradictory starting assumptions and impossible actual adoption separately. + + + **L343** Separate rejection of the contradictory starting theory from rejection of the impossible selected/adopted combination. + + + **L344** Extract a joint adoption witness from the alleged procedure for the contradictory starting position. + + + **L345** The singleton starting theory requires False at that witness, directly contradicting its model proof. + + + **L346** Extract the adoption equality from the alleged joint witness for the impossible selected/adopted combination. + + + **L347** The required adoption equality equates distinct Boolean options, so this witness cannot exist. + + + **L348** Document the intended scope of unsupportedPosition. The corresponding declaration concerns: Copies the switch value position but deletes its reasons, guaranteeing procedural failure. This comment is explanatory, not a proof premise. + + + **L349** Define unsupportedPosition. Copies the switch value position but deletes its reasons, guaranteeing procedural failure. + + + **L350** Define switchEmpirical. Builds an empirical facet concluding the Boolean world is true from the switch record, with unrestricted scope and trivially true uncertainty. + + + **L351** Use the actual switch observation, unrestricted scope and same selected-on claim; uncertainty is explicitly True. + + + **L352** State the checked result switchEmpiricalDischarged. Discharges that empirical facet with a true-world witness, semantic support, and trivial uncertainty. The following tactic block proves this explicit type. + + + **L353** Use true as a nonempty world compatible with the switch record and unrestricted empirical scope. + + + **L354** The same switch record’s semantic support proves the scoped switch claim at each compatible world. + + + **L355** Discharge the explicitly trivial uncertainty predicate, without adding an empirical confidence claim. + + + **L356** Document the intended scope of mixedMissingResponsibility. The corresponding declaration concerns: Shows a discharged empirical facet does not discharge a union of applicable facets when an included value facet has no reasons. This comment is explanatory, not a proof premise. + + + **L357** Begin provenance metadata for CoreReader.Evidence.mixedMissingResponsibility; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L358** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L359** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L360** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L361** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L362** State the checked result mixedMissingResponsibility. Shows a discharged empirical facet does not discharge a union of applicable facets when an included value facet has no reasons. + + + **L363** Retain successful discharge of the actual empirical switch facet. + + + **L364** Deny all mixed duties even with empty labels, because the actual value facet also applies and lacks recorded reasons. + + + **L365** Keep the valid empirical switch facet and separately refute completion of all mixed duties. + + + **L366** Assume every actual mixed facet is discharged, including the value facet whose recorded reason list is empty. + + + **L367** Select the value facet from the actual applicability union and extract its required nonempty reason-list condition. + + + **L368** Its reason list is definitionally empty, contradicting only that recorded procedural requirement. + + + **L369** Document the intended scope of uninformativeArgument. The corresponding declaration concerns: Constructs a nonempty articulation with no assumptions and a tautological reason; it carries no information about the switch conclusion. This comment is explanatory, not a proof premise. + + + **L370** Define uninformativeArgument. Constructs a nonempty articulation with no assumptions and a tautological reason; it carries no information about the switch conclusion. + + + **L371** Articulate a switch concept with empty assumptions and a True reason; these nonempty words do not constrain the switch world. + + + **L372** Begin provenance metadata for CoreReader.Evidence.articulationNotSupport; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L373** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L374** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L375** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L376** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L377** State the checked result articulationNotSupport. Proves this articulation passes the nonemptiness check while its assumptions do not entail that the world is true. + + + **L378** The uninformative articulation’s actual assumptions do not entail that the world is true. + + + **L379** Pair nonempty but uninformative concepts/reasons with the empty theory’s established failure to entail the switch claim. + + + **L380** Pair nonempty but uninformative concepts/reasons with the empty theory’s established failure to entail the switch claim. + + + **L381** Document the intended scope of unrelatedArticulationRejected. The corresponding declaration concerns: Shows that a nonempty unrelated articulation and a discharged empirical facet need not align, and rejects this concrete pairing. This comment is explanatory, not a proof premise. + + + **L382** State the checked result unrelatedArticulationRejected. Shows that a nonempty unrelated articulation and a discharged empirical facet need not align, and rejects this concrete pairing. + + + **L383** Keep the unrelated articulation procedurally present and the switch facet actually discharged. + + + **L384** Still reject semantic matching between that unrelated articulation and this empirical facet. + + + **L385** Retain articulation and valid switch evidence, then separately test whether this unrelated articulation actually matches the facet. + + + **L386** Assume the uninformative articulation semantically matches switchEmpirical, despite its empty premise theory. + + + **L387** Evaluate the alleged equality of articulation assumptions and empirical compatibility assumptions on the compatibility claim itself. + + + **L388** The empirical singleton contains that compatibility claim, while the unrelated empty theory cannot; the alleged equality yields False. + + + **L389** Close this component of unrelatedArticulationRejected using the displayed local evidence or previously proved lemma; the component belongs to the following fixed result: Shows that a nonempty unrelated articulation and a discharged empirical facet need not align, and rejects this concrete pairing. + + + **L390** Document the intended scope of temperatureRecord. The corresponding declaration concerns: Records only the first coordinate of a Boolean pair, observed as true; the second coordinate is unmeasured. This comment is explanatory, not a proof premise. + + + **L391** Define temperatureRecord. Records only the first coordinate of a Boolean pair, observed as true; the second coordinate is unmeasured. + + + **L392** State the checked result temperatureCompatible. Shows duplicating that record remains compatible with either second-coordinate value when the first is true. + + + **L393** For any output coordinate b, repeated temperature records remain compatible with (true,b). + + + **L394** For either output coordinate b, singleton-style membership in the repeated list selects the same temperature test; its observed first coordinate is true and leaves b unconstrained. + + + **L395** For either output coordinate b, singleton-style membership in the repeated list selects the same temperature test; its observed first coordinate is true and leaves b unconstrained. + + + **L396** For either output coordinate b, singleton-style membership in the repeated list selects the same temperature test; its observed first coordinate is true and leaves b unconstrained. + + + **L397** For either output coordinate b, singleton-style membership in the repeated list selects the same temperature test; its observed first coordinate is true and leaves b unconstrained. + + + **L398** Document the intended scope of BudgetWorld. The corresponding declaration concerns: Uses a Boolean action coordinate and natural-number budget as the world type. This comment is explanatory, not a proof premise. + + + **L399** Introduce the type abbreviation BudgetWorld. Uses a Boolean action coordinate and natural-number budget as the world type. + + + **L400** Document the intended scope of announcement. The corresponding declaration concerns: Defines a fixed declaration string; its content is not linked to budget. This comment is explanatory, not a proof premise. + + + **L401** Define announcement. Defines a fixed declaration string; its content is not linked to budget. + + + **L402** Define announcementPosition. Uses an action announcement as the sole option-indexed reason while requiring actual benefit/cost and available budget. + + + **L403** Use Boolean options for on/off. + + + **L404** Represent each outcome as actual benefit and cost in a natural-number pair. + + + **L405** Adopt the on option explicitly; adoption itself is not derived from arithmetic. + + + **L406** Read actual selection from the first coordinate while leaving budget independently variable. + + + **L407** Compute benefit and cost from this same actual option. + + + **L408** Adopt the objective that actual benefit strictly exceeds actual cost. + + + **L409** Compare the adopted option’s actual cost with this world’s independently supplied budget. + + + **L410** Fix selection to on without any affordability or budget assumption. + + + **L411** Use the actual option-specific announcement text as the reason; it says nothing about available budget. + + + **L412** Use an unrestricted world scope in this example; starting assumptions and reason content still constrain the procedure. + + + **L413** Treat budget below 3 as relevant criticism of this cost-3 action. + + + **L414** Record a nonempty message about reconsidering the action when cost exceeds budget. + + + **L415** Document the intended scope of announcementHasJointAdoption. The corresponding declaration concerns: Constructs an action-true budget-zero world where the announcement reason holds; failure later is substantive, not absent adoption. This comment is explanatory, not a proof premise. + + + **L416** State the checked result announcementHasJointAdoption. Constructs an action-true budget-zero world where the announcement reason holds; failure later is substantive, not absent adoption. The following tactic block proves this explicit type. + + + **L417** Choose selected-on with budget 0 as a joint adoption witness; the starting theory fixes selection but does not assume affordability. + + + **L418** Take an arbitrary announcement reason at the selected-on, zero-budget joint witness. + + + **L419** Use membership to identify the actual reason as the option-indexed announcement text, then specialize it to the adopted on option. + + + **L420** Use membership to identify the actual reason as the option-indexed announcement text, then specialize it to the adopted on option. + + + **L421** Use membership to identify the actual reason as the option-indexed announcement text, then specialize it to the adopted on option. + + + **L422** The actual announcement equals the on option’s activation text; this proves the announcement reason, not the budget constraint. + + + **L423** Document the intended scope of announcementNotBudgetReason. The corresponding declaration concerns: At budget zero, the adopted action and true nonempty announcement reasons fail the real budget consequence, refuting the procedure. This comment is explanatory, not a proof premise. + + + **L424** State the checked result announcementNotBudgetReason. At budget zero, the adopted action and true nonempty announcement reasons fail the real budget consequence, refuting the procedure. + + + **L425** Require nonempty announcement reasons and actual adoption at selected-on with budget 0. + + + **L426** At that same zero-budget world, all actual announcement reasons hold. + + + **L427** Nevertheless reject the actual consequence and the whole value procedure. + + + **L428** Assemble nonempty announcement reasons and the true announcement; refute the zero-budget consequence and leave failure of the whole procedure. + + + **L429** For the claimed conjunction of reasons at budget 0, take any member of the actual announcement reason list. + + + **L430** Use membership to identify the actual reason as the option-indexed announcement text, then specialize it to the adopted on option. + + + **L431** Use membership to identify the actual reason as the option-indexed announcement text, then specialize it to the adopted on option. + + + **L432** The actual announcement equals the on option’s activation text; this proves the announcement reason, not the budget constraint. + + + **L433** Assume the announcement position satisfies ValueProcedure, to test its consequence clause at budget 0. + + + **L434** Collect every announcement reason at the same selected-on, zero-budget world. + + + **L435** To supply all reasons to that clause, take any announcement reason at the same zero-budget world. + + + **L436** Use membership to identify the actual reason as the option-indexed announcement text, then specialize it to the adopted on option. + + + **L437** Use membership to identify the actual reason as the option-indexed announcement text, then specialize it to the adopted on option. + + + **L438** The actual announcement equals the on option’s activation text; this proves the announcement reason, not the budget constraint. + + + **L439** Apply a hypothetical procedure to that inhabited zero-budget starting/limit case and its actual announcement reason. + + + **L440** The resulting cost constraint would require cost 3 within budget 0, which is impossible. + + + **L441** Document the intended scope of actionRecord. The corresponding declaration concerns: Records only the action Boolean, leaving budget completely unconstrained. This comment is explanatory, not a proof premise. + + + **L442** Define actionRecord. Records only the action Boolean, leaving budget completely unconstrained. + + + **L443** State the checked result actionCompatible. Shows two copies of the action record accept every budget when action=true. The following tactic block proves this explicit type. + + + **L444** Every action record in the repeated list tests only the actual selected-on coordinate, so any supplied budget remains compatible. + + + **L445** Document the intended scope of measurementRepeatNotSupport. The corresponding declaration concerns: Combines explicit countermodels showing that repeated measurement of one coordinate does not support an unmeasured coordinate or a budget consequence, and does not fix the announcement value procedure. This comment is explanatory, not a proof premise. + + + **L446** Begin provenance metadata for CoreReader.Evidence.measurementRepeatNotSupport; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L447** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L448** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L449** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L450** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L451** State the checked result measurementRepeatNotSupport. Combines explicit countermodels showing that repeated measurement of one coordinate does not support an unmeasured coordinate or a budget consequence, and does not fix the announcement value procedure. + + + **L452** The actual temperature test returns true even when the independent output coordinate is false. + + + **L453** Retain this false-output world under repeated temperature observations. + + + **L454** Also retain a true-output world under those same repeated observations. + + + **L455** A single temperature record does not support the other output being true. + + + **L456** Repeating that temperature record still does not support the other output being true. + + + **L457** Repeated observed activation is compatible with selected-on and budget 0. + + + **L458** The same repeated records are also compatible with budget 3. + + + **L459** A single activation record does not support the option’s actual objective-and-budget consequence. + + + **L460** Repeating activation records does not repair that lack of consequence support. + + + **L461** The announcement-based value procedure also fails for that actual option and constraint. + + + **L462** Record the observation’s actual true value and both temperature-compatible output alternatives; leave the unsupported output claims to refute. + + + **L463** Keep both budget-0 and budget-3 action-compatible worlds and the established announcement-procedure failure; leave affordability support claims to refute. + + + **L464** Assume a single temperature observation supports the independently represented second output being true. + + + **L465** Apply purported one-record output support to (true,false), whose temperature observation is true but whose other output claim is false. + + + **L466** Apply purported one-record output support to (true,false), whose temperature observation is true but whose other output claim is false. + + + **L467** The same (true,false) counterworld remains compatible with repeated temperature records, defeating repeated-data output support. + + + **L468** Assume a single action observation supports the adopted option’s benefit-and-budget consequence. + + + **L469** A single observed activation is compatible with budget 0; purported consequence support there would force the impossible cost constraint. + + + **L470** A single observed activation is compatible with budget 0; purported consequence support there would force the impossible cost constraint. + + + **L471** Repeating activation records retains the same zero-budget counterworld, so it still does not support the actual affordability consequence. + + + **L472** Document the intended scope of selfAssertionNotReason. The corresponding declaration concerns: Combines empty-reason and nonempty-but-budget-irrelevant self-assertion failures, with a joint adoption witness for the latter. This comment is explanatory, not a proof premise. + + + **L473** Begin provenance metadata for CoreReader.Evidence.selfAssertionNotReason; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L474** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L475** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L476** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L477** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L478** State the checked result selfAssertionNotReason. Combines empty-reason and nonempty-but-budget-irrelevant self-assertion failures, with a joint adoption witness for the latter. + + + **L479** The missing-reason position can be actually adopted yet fail its recorded procedure. + + + **L480** The stronger announcement example has nonempty reasons and actual adoption at budget 0. + + + **L481** Its actual consequence and its procedure still fail because the same adopted option exceeds budget. + + + **L482** Retain an actual joint adoption witness, excluding an empty-starting-domain explanation of this failure. + + + **L483** Prove unsupportedPosition.commitment true by reduction; a supposed ValueProcedure contradicts its empty reason list through its nonemptiness requirement. + + + **L484** Reuse the nonempty actual announcement reasons and adoption equality from announcementNotBudgetReason. + + + **L485** Also reuse failure of the same zero-budget consequence and of the entire announcement procedure. + + + **L486** Retain announcementHasJointAdoption so this failure is not explained by an empty or inconsistent starting domain. + + + **L487** Document the intended scope of valueWithoutSelfProof. The corresponding declaration concerns: Exhibits a coherent reasoned position not derivable from empty assumptions, and rejects opposite-option, inconsistent-start and impossible-adoption variants. This comment is explanatory, not a proof premise. + + + **L488** Begin provenance metadata for CoreReader.Evidence.valueWithoutSelfProof; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L489** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L490** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L491** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L492** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L493** State the checked result valueWithoutSelfProof. Exhibits a coherent reasoned position not derivable from empty assumptions, and rejects opposite-option, inconsistent-start and impossible-adoption variants. + + + **L494** Require the switch position’s actual starting theory to have a model. + + + **L495** Deny derivation of its adopted commitment from the empty Boolean theory. + + + **L496** The opposite position has a joint witness but fails consequence assessment. + + + **L497** Also reject contradictory starting and impossible adoption variants, distinguishing non-self-derived from inconsistent starts. + + + **L498** Combine the actual switch procedure, world true as its starting model, and non-entailment of the adopted claim from emptyTheory. + + + **L499** Add rejection of the inhabited opposite option and the separate contradictory-start and impossible-adoption variants. + + + **L500** Document the intended scope of BenefitCostWorld. The corresponding declaration concerns: Stores a selected Boolean option together with variable benefit and cost values. This comment is explanatory, not a proof premise. + + + **L501** Introduce the type abbreviation BenefitCostWorld. Stores a selected Boolean option together with variable benefit and cost values. + + + **L502** Define measuredOutcome. For true, returns the world's benefit/cost pair; false has outcome zero/zero. + + + **L503** The on option reads the world’s actual benefit/cost pair; the off option yields (0,0). + + + **L504** Define benefitReason. Requires the same option's measured benefit to equal four. + + + **L505** The benefit reason requires the actual option’s measured benefit to equal 4. + + + **L506** Define costReason. Requires that option's measured cost to be at most three. + + + **L507** The cost reason requires the same option’s measured cost to be at most 3. + + + **L508** Document the intended scope of jointReasonPosition. The corresponding declaration concerns: Uses two separate option-specific benefit and cost reasons jointly for the adopted option's objective and budget. This comment is explanatory, not a proof premise. + + + **L509** Define jointReasonPosition. Uses two separate option-specific benefit and cost reasons jointly for the adopted option's objective and budget. + + + **L510** Use Boolean options for on/off. + + + **L511** Represent each outcome as actual benefit and cost in a natural-number pair. + + + **L512** Adopt the on option explicitly; adoption itself is not derived from arithmetic. + + + **L513** Read selection from the world’s first coordinate, separately from measured benefit and cost. + + + **L514** Use measuredOutcome so the assessed option’s actual benefit and cost come from this world. + + + **L515** Adopt the objective that actual benefit strictly exceeds actual cost. + + + **L516** Require this option’s measured cost to be at most 3. + + + **L517** Assume the selected option is on, without assuming benefit or cost conclusions. + + + **L518** List benefitReason and costReason together; the procedure will use their conjunction. + + + **L519** Use an unrestricted world scope in this example; starting assumptions and reason content still constrain the procedure. + + + **L520** Identify an actual measured cost above 3 as relevant criticism. + + + **L521** Record the nonempty response to reassess this option when its actual cost exceeds budget. + + + **L522** Document the intended scope of jointReasonProcedure. The corresponding declaration concerns: Builds a joint witness at benefit four/cost three and combines both reasons to prove cost below benefit and within budget. This comment is explanatory, not a proof premise. + + + **L523** State the checked result jointReasonProcedure. Builds a joint witness at benefit four/cost three and combines both reasons to prove cost below benefit and within budget. The following tactic block proves this explicit type. + + + **L524** Separate the joint-reason position’s nonempty reasons, joint witness, conjunction-based consequence and criticism response. + + + **L525** Use selected-on with benefit 4 and cost 3 as the common starting/limit/adoption witness. + + + **L526** Take any of the two reasons at the actual (true,(4,3)) witness, then split membership to check each distinct reason. + + + **L527** Expose the actual two-element reason list: benefitReason and costReason. + + + **L528** Split reason membership into the benefit reason or the remaining singleton cost reason. + + + **L529** Substitute the benefit reason and check that the witness’s measured benefit is exactly 4. + + + **L530** Identify the remaining reason with costReason and substitute it. + + + **L531** Identify the remaining reason with costReason and substitute it. + + + **L532** Check the witness’s cost bound 3 ≤ 3 by reflexivity of the natural-number order. + + + **L533** For an arbitrary admitted world, assume all active reasons together rather than requiring either reason alone to suffice. + + + **L534** Extract the actual benefitReason from the reason conjunction at this world and adopted option. + + + **L535** Extract costReason from the same conjunction at the same world and option. + + + **L536** Unfold benefitReason: the adopted on option’s measured benefit equals 4. + + + **L537** Unfold costReason: that same option’s measured cost is at most 3. + + + **L538** Retain the actual cost constraint and leave only the strict benefit-over-cost objective. + + + **L539** Rewrite the measured benefit to 4 and check that it exceeds 3. + + + **L540** Compose cost ≤ 3 with 3 < benefit to establish cost < benefit using both reasons. + + + **L541** For a world within limits where criticism is relevant, construct the required response about this option’s excessive cost. + + + **L542** Provide the explicit nonempty response about reassessing the option when its cost exceeds the budget; this records a response, not its persuasive adequacy. + + + **L543** Document the intended scope of JointReasonsExample. The corresponding declaration concerns: States that the joint procedure passes while either reason alone can hold at a world failing the consequence. This comment is explanatory, not a proof premise. + + + **L544** Define JointReasonsExample. States that the joint procedure passes while either reason alone can hold at a world failing the consequence. + + + **L545** Require the two-reason position to satisfy its complete ValueProcedure. + + + **L546** Fix a benefit-only counterworld (true,(4,5)) satisfying the same starting assumptions and limits. + + + **L547** At that world, actual adoption and the benefit reason both hold. + + + **L548** Deny the assessed consequence there, because its actual cost is too high. + + + **L549** Fix a cost-only counterworld (true,(0,3)) under the same starting assumptions and limits. + + + **L550** At this world, actual adoption and the cost reason hold. + + + **L551** Deny its assessed consequence because zero benefit does not exceed cost 3. + + + **L552** State the checked result jointReasonsExample. Uses benefit four/cost five and benefit zero/cost three as counterexamples to individual-reason sufficiency. The following tactic block proves this explicit type. + + + **L553** Begin the combined example with the already checked two-reason procedure. + + + **L554** Supply the benefit-only counterworld with benefit 4 and cost 5, satisfying the same starting, limit and adoption conditions. + + + **L555** Supply the cost-only counterworld with benefit 0 and cost 3 under the same conditions. + + + **L556** The benefit-only world violates the cost constraint 5 ≤ 3; natural-number arithmetic closes the contradiction. + + + **L557** The cost-only world cannot satisfy the strict objective 3 < 0; arithmetic closes this counterexample. + + + **L558** Document the intended scope of heterogeneousReasons. The corresponding declaration concerns: Combines empirical, inferential and value examples with a genuine two-reason combination that neither reason alone establishes. This comment is explanatory, not a proof premise. + + + **L559** Begin provenance metadata for CoreReader.Evidence.heterogeneousReasons; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L560** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L561** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L562** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L563** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L564** State the checked result heterogeneousReasons. Combines empirical, inferential and value examples with a genuine two-reason combination that neither reason alone establishes. + + + **L565** Include the actually discharged empirical switch facet. + + + **L566** Include an inferential facet whose satisfiable true-world premise entails the same true-world claim. + + + **L567** Include the actual switch value procedure and the two-joint-reasons example in this registered theorem. + + + **L568** Combine the checked empirical facet, an inhabited inferential singleton, the value procedure and the joint-reason counterexamples. + + + **L569** For the inferential facet, its singleton premise directly yields the same true-world claim at any model. + + + **L571** Document the intended scope of zeroRecord. The corresponding declaration concerns: Records only a function's Boolean output at natural-number input zero. This comment is explanatory, not a proof premise. + + + **L572** Define zeroRecord. Records only a function's Boolean output at natural-number input zero. + + + **L573** Define localGenerator. Produces a function returning true exactly at its natural-number seed. + + + **L574** Document the intended scope of allTrue. The corresponding declaration concerns: Requires a Boolean-valued function to return true at every natural number. This comment is explanatory, not a proof premise. + + + **L575** Define allTrue. Requires a Boolean-valued function to return true at every natural number. + + + **L576** State the checked result zeroCompatible. Proves one zero-input record constrains exactly the function's value at zero. The following tactic block proves this explicit type. + + + **L577** Prove both directions between matching zeroRecord and the actual function returning true at input 0. + + + **L578** Apply record compatibility to the sole named test to recover its actual observed equality. + + + **L579** Conversely, singleton membership identifies any listed record with this test, whose equality is the supplied observation premise. + + + **L580** Document the intended scope of GeneratingProcess. The corresponding declaration concerns: Stores producer identity, the actual earlier predicate and the seed used by its revision algorithm. This comment is explanatory, not a proof premise. + + + **L581** Declare the data interface GeneratingProcess. Stores producer identity, the actual earlier predicate and the seed used by its revision algorithm. + + + **L582** Store the actual generating process owner identifier. + + + **L583** Store the prior Boolean-valued function before this process generates its revision. + + + **L584** Store the seed input used by this process’s actual local generator. + + + **L585** Document the intended scope of GeneratingProcess.outputRevision. The corresponding declaration concerns: Preserves prior successes and adds the seed-selected input through the actual local generator. This comment is explanatory, not a proof premise. + + + **L586** Define GeneratingProcess.outputRevision. Preserves prior successes and adds the seed-selected input through the actual local generator. + + + **L587** The revised function preserves each true prior output or adds truth at the actual generated seed input. + + + **L588** Document the intended scope of ProducedRevision. The corresponding declaration concerns: Stores producer plus exact before and after predicate objects. This comment is explanatory, not a proof premise. + + + **L589** Declare the data interface ProducedRevision. Stores producer plus exact before and after predicate objects. + + + **L590** Identify which owner produced this concrete revision object. + + + **L591** Store the actual before-function of the revision. + + + **L592** Store the actual after-function of the revision. + + + **L593** Document the intended scope of GeneratingProcess.produce. The corresponding declaration concerns: Constructs this process's own revision with its owner and actual prior/output functions. This comment is explanatory, not a proof premise. + + + **L594** Define GeneratingProcess.produce. Constructs this process's own revision with its owner and actual prior/output functions. + + + **L595** Construct the revision directly from this process’s owner, prior function and computed output revision. + + + **L596** Define sampleGeneratingProcess. Uses owner seventeen, an always-false prior predicate and seed zero. + + + **L597** Document the intended scope of OwnedRevisionExample. The corresponding declaration concerns: Binds self-origin and exact before/after functions to a real zero-input change whose global claim lacks support. This comment is explanatory, not a proof premise. + + + **L598** Define OwnedRevisionExample. Binds self-origin and exact before/after functions to a real zero-input change whose global claim lacks support. + + + **L599** Bind the revision’s producer identifier to the actual generating process owner. + + + **L600** Bind its before-function to this process’s actual prior function. + + + **L601** Bind its after-function to this process’s actual outputRevision. + + + **L602** Require actual change at input 0 from false before to true after. + + + **L603** Retain an actual false output at input 1 after that revision. + + + **L604** The actual produced after-function matches the input-0 observation. + + + **L605** That record still does not support the all-input truth claim. + + + **L606** Document the intended scope of ownedRevisionExample. The corresponding declaration concerns: Computes ownership/object links and uses the produced function's failure at one to refute universal support. This comment is explanatory, not a proof premise. + + + **L607** State the checked result ownedRevisionExample. Computes ownership/object links and uses the produced function's failure at one to refute universal support. The following tactic block proves this explicit type. + + + **L608** Check producer identity, prior/output revision relationships and actual sample values by computation; retain zero-record compatibility and leave universal support to refute. + + + **L609** Assume zeroRecord supports allTrue, to refute it using this owner’s actual produced revision. + + + **L610** Apply purported support to this owner’s actual produced after-function at input 1, where its revision still returns false. + + + **L611** Eliminate the resulting false=true equality; the actual revision is an evidence-compatible counterexample. + + + **L612** Document the intended scope of selfOriginDoesNotSupport. The corresponding declaration concerns: Retains the local observation countermodel and adds an actual owned before/after revision with the same unsupported global claim. This comment is explanatory, not a proof premise. + + + **L613** Begin provenance metadata for CoreReader.Evidence.selfOriginDoesNotSupport; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L614** Register source unit organon.charter.reflexivity.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L615** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L616** State the checked result selfOriginDoesNotSupport. Retains the local observation countermodel and adds an actual owned before/after revision with the same unsupported global claim. + + + **L617** Compute localGenerator 0 as true at 0 and false at 1. + + + **L618** Require this generated function to match the same input-0 record. + + + **L619** State failure of all-input support and include the concrete owner/prior/revision relationship example. + + + **L620** Compute the generated function’s values at 0 and 1, give its zero-record compatibility, and include the owned revision relationship example. + + + **L621** Assume the local zero observation entails true output at every input of every compatible function. + + + **L622** Instantiate alleged universal support with localGenerator 0 and then input 1; compatibility at 0 did not constrain this failing input. + + + **L623** Eliminate the resulting false=true equality; the actual revision is an evidence-compatible counterexample. + + + **L624** Document the intended scope of localNotUniversal. The corresponding declaration concerns: Exhibits both a universally true function and a zero-only true function compatible with the same observation, with an explicit outside input; therefore the observation does not support universal truth. This comment is explanatory, not a proof premise. + + + **L625** Begin provenance metadata for CoreReader.Evidence.localNotUniversal; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L626** Register source unit organon.grounds.scope#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L627** Register source unit organon.grounds.scope#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L628** Register source unit organon.grounds.scope#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L629** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L630** State the checked result localNotUniversal. Exhibits both a universally true function and a zero-only true function compatible with the same observation, with an explicit outside input; therefore the observation does not support universal truth. + + + **L631** Require at least one natural-number input outside the observed singleton scope. + + + **L632** The constant-true function matches the zero observation. + + + **L633** The local generator also matches that same observation. + + + **L634** The first function is universally true while the second is not. + + + **L635** Therefore the shared observation does not support universal truth. + + + **L636** Provide an input outside the observed scope and show both the constant-true function and local generator satisfy the same zero observation. + + + **L637** The constant function is universally true; retain the known support counterexample and leave the local generator’s universal claim to refute. + + + **L638** Evaluate any proposed all-input truth of the local generator at 1, where its actual result is false. + + + **L639** Document the intended scope of hiddenDifference. The corresponding declaration concerns: Shows the two functions agree on the domain restricted to zero and disagree at one; local agreement does not establish global equality. This comment is explanatory, not a proof premise. + + + **L640** Begin provenance metadata for CoreReader.Evidence.hiddenDifference; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L641** Register source unit organon.grounds.scope#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L642** Register source unit organon.grounds.scope#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L643** Register source unit organon.grounds.scope#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L644** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L645** State the checked result hiddenDifference. Shows the two functions agree on the domain restricted to zero and disagree at one; local agreement does not establish global equality. + + + **L646** State equality of both functions only for inputs satisfying n=0. + + + **L647** State their concrete output inequality at input 1. + + + **L648** Separate agreement on the input-0 scope from the concrete output difference at input 1. + + + **L649** Substitute n=0 from the scope premise; both functions then compute to true. + + + **L650** Document the intended scope of singleObservation. The corresponding declaration concerns: A single zero-input observation is nonvacuously compatible and supports its local result but does not support the all-input claim. This comment is explanatory, not a proof premise. + + + **L651** Begin provenance metadata for CoreReader.Evidence.singleObservation; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L652** Register source unit organon.grounds.scope#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L653** Register source unit organon.grounds.scope#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L654** Register source unit organon.grounds.scope#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L655** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L656** State the checked result singleObservation. A single zero-input observation is nonvacuously compatible and supports its local result but does not support the all-input claim. + + + **L657** Require an actual function compatible with the single observation, preventing empty evidence semantics. + + + **L658** That single record supports its actual input-0 claim. + + + **L659** It does not support the stronger all-input claim. + + + **L660** Compute the record count as one and provide localGenerator 0 as an actual compatible witness. + + + **L661** Extract the supported input-0 fact directly from compatibility and reuse the established failure of allTrue support. + + + **L662** Document the intended scope of arithmeticFacet. The corresponding declaration concerns: Defines an inferential facet with assumption n=2 and conclusion n+1=3. This comment is explanatory, not a proof premise. + + + **L663** Define arithmeticFacet. Defines an inferential facet with assumption n=2 and conclusion n+1=3. + + + **L664** Define usesObservation. Returns true only for empirical facet tags; this is a classification test, not an analysis of computational executability. + + + **L665** Classify an empirical facet as using observation because it carries actual test records. + + + **L666** Classify inferential and value facets as not using observation in this represented method classifier. + + + **L667** Document the intended scope of noUniversalChain. The corresponding declaration concerns: Discharges the arithmetic implication with a model n=2 while its observation tag is false. This is an example of nonempirical discharge, not a universal account of knowledge. This comment is explanatory, not a proof premise. + + + **L668** Begin provenance metadata for CoreReader.Evidence.noUniversalChain; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L669** Register source unit organon.grounds.scope#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L670** Register source unit organon.grounds.scope#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L671** Register source unit organon.grounds.scope#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L672** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L673** State the checked result noUniversalChain. Discharges the arithmetic implication with a model n=2 while its observation tag is false. This is an example of nonempirical discharge, not a universal account of knowledge. The following tactic block proves this explicit type. + + + **L674** Provide n=2 as the inferential theory’s nonempty witness and note that its facet constructor uses no observation. + + + **L675** Take any natural-number world n satisfying the arithmetic facet’s actual premise theory. + + + **L676** Extract n=2 from the actual singleton premise, rather than assuming the desired successor conclusion. + + + **L677** Expose the arithmetic conclusion n+1=3 as the remaining goal. + + + **L678** Rewrite n to 2 using the premise; the required arithmetic equality reduces by computation. + + + **L679** Document the intended scope of Trial. The corresponding declaration concerns: Stores setting, actual outcome and recorded outcome as independent natural-number fields, with no measurement mechanism. This comment is explanatory, not a proof premise. + + + **L680** Declare the data interface Trial. Stores setting, actual outcome and recorded outcome as independent natural-number fields, with no measurement mechanism. + + + **L681** Store the trial’s setting separately from its outcomes. + + + **L682** Store the trial’s actual outcome, whether accurately recorded or not. + + + **L683** Store the separately recorded outcome to allow accuracy comparisons. + + + **L684** Document the intended scope of Verified. The corresponding declaration concerns: Verification means exact equality of the two supplied outcome fields. This comment is explanatory, not a proof premise. + + + **L685** Define Verified. Verification means exact equality of the two supplied outcome fields. + + + **L686** Define Reproduced. Reproduction means only equality of two setting fields; it does not require matching outcomes or histories. + + + **L687** Define Bounded. The bound property is actualOutcome≤2, a fixed threshold rather than a general stability theory. + + + **L688** Document the intended scope of variableOutcomesStableBound. The corresponding declaration concerns: Exhibits matching settings with different actual outcomes that both satisfy the fixed upper bound. This comment is explanatory, not a proof premise. + + + **L689** Begin provenance metadata for CoreReader.Evidence.variableOutcomesStableBound; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L690** Register source unit organon.grounds.scope#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L691** Register source unit organon.grounds.scope#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L692** Register source unit organon.grounds.scope#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L693** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L694** State the checked result variableOutcomesStableBound. Exhibits matching settings with different actual outcomes that both satisfy the fixed upper bound. + + + **L695** Fix the first trial at setting 0 with actual and recorded outcome 1. + + + **L696** Fix the second trial at the same setting with actual and recorded outcome 2. + + + **L697** Require the two explicitly fixed trials to share settings, differ in actual outcomes and both satisfy actualOutcome ≤ 2. + + + **L698** Evaluate the two same-setting trials: actual outcomes 1 and 2 differ, but each satisfies actualOutcome ≤ 2. + + + **L699** Document the intended scope of verificationReproductionStability. The corresponding declaration concerns: Uses explicit numeric trials to separate recorded/actual agreement, equal settings, and the fixed outcome bound. This comment is explanatory, not a proof premise. + + + **L700** Begin provenance metadata for CoreReader.Evidence.verificationReproductionStability; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L701** Register source unit organon.grounds.scope#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L702** Register source unit organon.grounds.scope#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L703** Register source unit organon.grounds.scope#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L704** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L705** State the checked result verificationReproductionStability. Uses explicit numeric trials to separate recorded/actual agreement, equal settings, and the fixed outcome bound. + + + **L706** Require two accurately recorded trials whose settings nevertheless differ. + + + **L707** Require repeated settings alongside an inaccurate second record and an actual result exceeding the bound. + + + **L708** Require preserved bounds even though one recorded outcome is inaccurate. + + + **L709** Compute each concrete trial predicate separately, exhibiting changed settings, inaccurate recording and failure or preservation of the bound without conflating them. + + + **L710** Document the intended scope of Program. The corresponding declaration concerns: Defines a tiny program language with doubling and natural-number constants only. This comment is explanatory, not a proof premise. + + + **L711** Declare the alternatives Program. Defines a tiny program language with doubling and natural-number constants only. + + + **L712** Provide syntax for the explanation program that doubles its actual input. + + + **L713** Provide syntax for a constant-output explanation program carrying its returned natural number. + + + **L714** Define Program.eval. Defines the executable meaning of the two program constructors. + + + **L715** Evaluate the doubleInput explanation program at n by actual addition n+n. + + + **L716** Evaluate a constant program by returning its stored value, independently of the input. + + + **L717** Document the intended scope of Process. The corresponding declaration concerns: A process consists of an arbitrary natural-number function and an optional tiny-language explanation program. This comment is explanatory, not a proof premise. + + + **L718** Declare the data interface Process. A process consists of an arbitrary natural-number function and an optional tiny-language explanation program. + + + **L719** Store the same process’s actual output function over natural-number inputs. + + + **L720** Store the process’s optional supplied explanation program, separately from its output function. + + + **L721** Document the intended scope of OutputContract. The corresponding declaration concerns: Requires the output function to double every natural-number input. This comment is explanatory, not a proof premise. + + + **L722** Define OutputContract. Requires the output function to double every natural-number input. + + + **L723** Document the intended scope of ExplanationContract. The corresponding declaration concerns: Requires an attached program whose evaluated outputs equal the process output on every input; this is extensional agreement, not causal or human explanatory adequacy. This comment is explanatory, not a proof premise. + + + **L724** Define ExplanationContract. Requires an attached program whose evaluated outputs equal the process output on every input; this is extensional agreement, not causal or human explanatory adequacy. + + + **L725** Require an actually supplied program whose evaluation equals this process’s output at every natural input. + + + **L726** Document the intended scope of outputOnlyProcess. The corresponding declaration concerns: Constructs the correct doubling function without any attached explanation program. This comment is explanatory, not a proof premise. + + + **L727** Define outputOnlyProcess. Constructs the correct doubling function without any attached explanation program. + + + **L728** Define explainedProcess. Constructs the same output function with the doubling program attached. + + + **L729** Document the intended scope of processScope. The corresponding declaration concerns: Restricts modeled candidates to the exact assessed process, without restricting the contract's input quantifier. This comment is explanatory, not a proof premise. + + + **L730** Define processScope. Restricts modeled candidates to the exact assessed process, without restricting the contract's input quantifier. + + + **L731** Restrict theory models by the actual equality candidate=assessed, not by assuming the desired contract. + + + **L732** Document the intended scope of processContractFacet. The corresponding declaration concerns: Builds an inferential contract facet under the exact assessed-process identity assumption. This comment is explanatory, not a proof premise. + + + **L733** Define processContractFacet. Builds an inferential contract facet under the exact assessed-process identity assumption. + + + **L734** Build an inferential facet with that exact object-identity scope and the supplied contract conclusion. + + + **L735** Document the intended scope of processScopeModels. The corresponding declaration concerns: Proves that modeling the identity scope is exactly equality to the assessed process. This comment is explanatory, not a proof premise. + + + **L736** State the checked result processScopeModels. Proves that modeling the identity scope is exactly equality to the assessed process. + + + **L737** State that modeling this scope is exactly equality to the assessed process. + + + **L738** Instantiate modelsSingleton with equality to the actual assessed Process, proving exactly which candidates satisfy processScope. + + + **L739** Document the intended scope of processContractDischarged. The corresponding declaration concerns: Uses a supplied proof of the actual process contract and scope equality to discharge the corresponding inferential facet. This comment is explanatory, not a proof premise. + + + **L740** State the checked result processContractDischarged. Uses a supplied proof of the actual process contract and scope equality to discharge the corresponding inferential facet. + + + **L741** Conclude discharge for that same object’s contract facet using the explicit contract-proof premise. + + + **L742** Use the assessed process itself as a model of its identity scope; leave semantic entailment of its contract. + + + **L743** Take a candidate and proof hc that it lies in the actual assessed process’s identity scope. + + + **L744** From the scope model hc, recover that the candidate is exactly the assessed process. + + + **L745** Substitute that process identity so the contract goal is about the actual assessed object. + + + **L746** Use the explicit premise proof of this object’s contract; the generic helper does not create contract correctness without that premise. + + + **L747** Document the intended scope of ProcessGrounds. The corresponding declaration concerns: Requires canonical Grounds for this exact process/contract facet and its singleton applicability. This comment is explanatory, not a proof premise. + + + **L748** Define ProcessGrounds. Requires canonical Grounds for this exact process/contract facet and its singleton applicability. + + + **L749** Require Grounds for the supplied contract using canonical articulation and the exact assessed-process facet as applicable. + + + **L750** The listed evidence package contains precisely that same process-contract facet. + + + **L751** State the checked result processGrounds. Constructs matching contract Grounds from an actual proof for that same assessed process. + + + **L752** Conclude these same-object ProcessGrounds from the explicit proof of the contract at the assessed process. + + + **L753** Apply the contract-discharge helper to the explicit proof for this same assessed process. + + + **L754** Separate nonempty facets, exact applicability coverage and each facet’s claim/articulation/discharge obligations. + + + **L755** The applicability assumption identifies the facet with the one prescribed facet, which belongs to the singleton list. + + + **L756** Singleton membership identifies the current facet with the prescribed one; substitute it to check its exact claim and grounds. + + + **L757** Assemble the same contract claim, nonempty canonical articulation, semantic connection to the object scope and the established discharge. + + + **L758** Document the intended scope of outputCorrectByEvaluation. The corresponding declaration concerns: Proves all-input doubling directly from the concrete output function, not an assumed success flag. This comment is explanatory, not a proof premise. + + + **L759** State the checked result outputCorrectByEvaluation. Proves all-input doubling directly from the concrete output function, not an assumed success flag. The supplied proof term uses the displayed constructed witnesses or earlier lemmas, rather than adding an axiom. + + + **L760** Document the intended scope of outputOnlyNoExplanation. The corresponding declaration concerns: Rejects an attached explanation witness because the same process stores none. This comment is explanatory, not a proof premise. + + + **L761** State the checked result outputOnlyNoExplanation. Rejects an attached explanation witness because the same process stores none. The following tactic block proves this explicit type. + + + **L762** Any explanation contract would supply a program whose some value equals the process’s actual none response; distinct option constructors make that impossible. + + + **L763** Document the intended scope of FullProcessContract. The corresponding declaration concerns: Conjoins output correctness with an attached output-faithful explanation for the same process. This comment is explanatory, not a proof premise. + + + **L764** Define FullProcessContract. Conjoins output correctness with an attached output-faithful explanation for the same process. + + + **L765** Document the intended scope of OutputContractEvidence. The corresponding declaration concerns: Combines grounded output and a nonempty exact-process scope whose model refutes the stronger full contract. This comment is explanatory, not a proof premise. + + + **L766** Define OutputContractEvidence. Combines grounded output and a nonempty exact-process scope whose model refutes the stronger full contract. + + + **L767** Require grounded output correctness for the actual output-only process. + + + **L768** Keep that process itself as an inhabitant of the exact assessment scope. + + + **L769** Deny that this same scope entails the stronger output-plus-explanation contract. + + + **L770** Document the intended scope of outputContractEvidence. The corresponding declaration concerns: Builds output Grounds by evaluation and uses the missing explanation at the same process to refute full-contract entailment. This comment is explanatory, not a proof premise. + + + **L771** State the checked result outputContractEvidence. Builds output Grounds by evaluation and uses the missing explanation at the same process to refute full-contract entailment. The following tactic block proves this explicit type. + + + **L772** Supply the actual output contract’s grounds and the process’s own scope witness, then refute the stronger contract under that very scope. + + + **L773** Assume that this exact process scope entails the stronger output-plus-explanation contract. + + + **L774** Instantiate alleged full-contract entailment at outputOnlyProcess itself; its explanation component contradicts the proven absent explanation. + + + **L775** Document the intended scope of ScopedApplicationEvidence. The corresponding declaration concerns: Requires both different application contracts to have Grounds and nonempty exact-process scopes. This comment is explanatory, not a proof premise. + + + **L776** Define ScopedApplicationEvidence. Requires both different application contracts to have Grounds and nonempty exact-process scopes. + + + **L777** Include grounded output correctness for outputOnlyProcess. + + + **L778** Include grounded output and explanation together for explainedProcess. + + + **L779** Make the first scope’s exact identity with outputOnlyProcess explicit for every candidate. + + + **L780** Likewise make the second scope’s exact identity with explainedProcess explicit. + + + **L781** Require both actual process-identity theories to be satisfiable. + + + **L782** Document the intended scope of scopedApplicationEvidence. The corresponding declaration concerns: Supplies actual all-input output proofs and the doubling explanation program for the stronger contract. This comment is explanatory, not a proof premise. + + + **L783** State the checked result scopedApplicationEvidence. Supplies actual all-input output proofs and the doubling explanation program for the stronger contract. The following tactic block proves this explicit type. + + + **L784** Construct output-only grounds by evaluation and reserve the explained process’s stronger contract proof. + + + **L785** Provide exact process-identity scope equivalences and each process itself as a nonempty scope witness. + + + **L786** Provide exact process-identity scope equivalences and each process itself as a nonempty scope witness. + + + **L787** For explainedProcess, prove every doubled output by reflexivity and supply doubleInput as an actual provided, extensionally faithful explanation program. + + + **L788** Document the intended scope of outputNotExplanation. The corresponding declaration concerns: Proves output correctness with no attached explanation and includes the corresponding same-object Grounds/countermodel evidence. This comment is explanatory, not a proof premise. + + + **L789** Begin provenance metadata for CoreReader.Evidence.outputNotExplanation; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L790** Register source unit organon.grounds.capabilities#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L791** Register source unit organon.grounds.capabilities#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L792** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L793** State the checked result outputNotExplanation. Proves output correctness with no attached explanation and includes the corresponding same-object Grounds/countermodel evidence. + + + **L794** Retain absence of this process’s explanation contract together with its scoped output evidence. + + + **L795** Combine actual output correctness, the same process’s absence of an explanation, and its matched scoped output evidence. + + + **L796** Document the intended scope of applicationContractsDiffer. The corresponding declaration concerns: Shows output-only evidence fails the stronger contract, while the explained process satisfies both; both applications carry their own Grounds. This comment is explanatory, not a proof premise. + + + **L797** Begin provenance metadata for CoreReader.Evidence.applicationContractsDiffer; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L798** Register source unit organon.grounds.capabilities#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L799** Register source unit organon.grounds.capabilities#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L800** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L801** State the checked result applicationContractsDiffer. Shows output-only evidence fails the stronger contract, while the explained process satisfies both; both applications carry their own Grounds. + + + **L802** The output-only process meets output correctness but fails the combined output-and-explanation contract. + + + **L803** The explained process meets both actual contracts. + + + **L804** Include the explicit scoped grounds and nonempty witnesses for both application contracts. + + + **L805** For outputOnlyProcess, supply actual output correctness and refute any joint contract by projecting its impossible explanation component. + + + **L806** For explainedProcess, compute all doubled outputs, supply faithful doubleInput syntax, and include both contracts’ matched scoped grounds. + + + **L807** Document the intended scope of ExternalCertificate. The corresponding declaration concerns: Binds output-correctness proof to the exact process and distinct assessor/assessed identifiers; it is a mathematical role model, not authenticated real provenance. This comment is explanatory, not a proof premise. + + + **L808** Declare the data interface ExternalCertificate. Binds output-correctness proof to the exact process and distinct assessor/assessed identifiers; it is a mathematical role model, not authenticated real provenance. + + + **L809** Store the external assessor’s identifier. + + + **L810** Store the assessed participant’s identifier; the certificate type already fixes the assessed Process. + + + **L811** Require distinct participant identifiers as an explicit certificate field. + + + **L812** Require a proof of this very process’s doubled output for every input; a generic certificate assumes this field, while the concrete certificate constructs it. + + + **L813** Document the intended scope of externalOutputCertificate. The corresponding declaration concerns: Constructs assessor forty-two's proof for assessed object seven by actual output evaluation. This comment is explanatory, not a proof premise. + + + **L814** Define externalOutputCertificate. Constructs assessor forty-two's proof for assessed object seven by actual output evaluation. + + + **L815** Construct participants 42 and 7, compute their inequality, and prove every doubled output by reflexivity of the actual program. + + + **L816** Document the intended scope of externalAssessment. The corresponding declaration concerns: Uses a distinct-participant certificate to supply matching output Grounds while the assessed process still returns no explanation. This comment is explanatory, not a proof premise. + + + **L817** Begin provenance metadata for CoreReader.Evidence.externalAssessment; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L818** Register source unit organon.grounds.capabilities#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L819** Register source unit organon.grounds.capabilities#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L820** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L821** State the checked result externalAssessment. Uses a distinct-participant certificate to supply matching output Grounds while the assessed process still returns no explanation. + + + **L822** Require an actual external certificate indexed by outputOnlyProcess. + + + **L823** Identify its assessor as 42 and assessed participant as 7. + + + **L824** Require their distinction and actual output correctness of the same process. + + + **L825** Also retain matched ProcessGrounds for that same output contract. + + + **L826** Still deny an internal explanation contract for that actual process. + + + **L827** Use the actual externalOutputCertificate with fixed participants 42 and 7 and its proved participant distinction. + + + **L828** Take universal output correctness from that concrete certificate, whose proof was constructed from the actual program. + + + **L829** Build matching ProcessGrounds for the very outputOnlyProcess using that same concrete output proof. + + + **L830** Retain outputOnlyNoExplanation, so the external certificate does not assert an internal explanation exists. + + + **L831** Document the intended scope of arithmeticArticulation. The corresponding declaration concerns: Names the canonical articulation of the arithmetic inferential facet. This comment is explanatory, not a proof premise. + + + **L832** Define arithmeticArticulation. Names the canonical articulation of the arithmetic inferential facet. + + + **L833** Document the intended scope of nonExecutableAssessment. The corresponding declaration concerns: Constructs Grounds for the arithmetic conditional facet and distinguishes its nonempirical tag from a discharged empirical switch facet. The tag does not establish noncomputability. This comment is explanatory, not a proof premise. + + + **L834** Begin provenance metadata for CoreReader.Evidence.nonExecutableAssessment; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L835** Register source unit organon.relationships.terms#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L836** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L837** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L838** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L839** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L840** State the checked result nonExecutableAssessment. Constructs Grounds for the arithmetic conditional facet and distinguishes its nonempirical tag from a discharged empirical switch facet. The tag does not establish noncomputability. + + + **L841** Require matched canonical Grounds for n+1=3 using precisely arithmeticFacet. + + + **L842** Specify that this inferential facet uses no observation. + + + **L843** At the same time, include an actually discharged empirical facet that does use observation. + + + **L844** Build the arithmetic claim’s nonempty, applicability-covered Grounds, retain its no-observation classification, and include the valid observed switch facet. + + + **L845** Singleton membership fixes the assessed facet to arithmeticFacet, so its specific assumptions and conclusion must be checked. + + + **L846** Use the same arithmetic facet’s proven discharge with canonical nonempty articulation and its exact semantic connection. + + + **L848** Close namespace CoreReader.Evidence; this adds no proof or premise. + + +### `leanified/CoreReader/Integration.lean` + + +```lean +import CoreReader.Agency +import CoreReader.Choice + +namespace CoreReader.Integration +open CoreReader.Logic CoreReader.Evidence CoreReader.Agency CoreReader.Choice + +/- Canonical articulation preserves the actual assessment contents of each facet. -/ +theorem canonicalGrounds {W : Type} (claim : Claim W) (facets : List (Facet W)) + (hne : facets ≠ []) (checked : ∀ f ∈ facets, f.claim = claim ∧ FacetDischarged f) : + Grounds claim canonicalArticulation (fun f => f ∈ facets) facets := by + exact ⟨hne, fun _ h => h, fun f hf => + ⟨(checked f hf).1, canonicalArticulated f (checked f hf).2, + canonicalFacetArticulated f, (checked f hf).2⟩⟩ + +theorem canonicalGroundsForSingleton {W : Type} (f : Facet W) (checked : FacetDischarged f) : + Grounds f.claim canonicalArticulation (fun g => g = f) [f] := by + refine ⟨by simp, (by intro g hg; cases hg; simp), ?_⟩ + intro g hg + simp only [List.mem_singleton] at hg + subst g + exact ⟨rfl, canonicalArticulated f checked, canonicalFacetArticulated f, checked⟩ + +/- A mode selects whether a system applies or waives the modeled governance rule. -/ +inductive Mode | apply | waive + deriving DecidableEq, Repr + +/- The four hypotheses vary algorithm and governance independently for the same assessed system. -/ +abbrev World := Candidate × Mode + +def actual : World := (.identity, .apply) + +/- A method's form and its possible executable realizations belong to one object. -/ +structure Method where + form : Form + realize : World → Implementation + +/- System fields identify the owner, its method, its current principle form, policy and work. -/ +structure System where + owner : Nat + method : Method + principleForm : Form + governance : World → Mode + requirements : Requirements + +def policyFor : Mode → Policy + | .apply => openPolicy + | .waive => neutralPolicy + +def workFor (owner : Nat) : Mode → List WorkRecord + | .apply => completeOwnWork owner + | .waive => [] + +def System.policy (s : System) (w : World) : Policy := policyFor (s.governance w) +def System.rules (s : System) (_w : World) : List Principle := ownRules s.owner +def System.work (s : System) (w : World) : List WorkRecord := workFor s.owner (s.governance w) + +def actualSystem : System where + owner := 0 + method := ⟨⟨.method, 0⟩, fun w => implementation w.1⟩ + principleForm := ⟨.principle, 0⟩ + governance := Prod.snd + requirements := identityRequirements + +def systemCapability (s : System) : Claim World := + fun w => ∀ n, s.requirements.inputs n → (s.method.realize w).run n = s.requirements.expected n + +def systemBudget (s : System) : Claim World := + fun w => (s.method.realize w).cost ≤ s.requirements.budget + +def systemObservation (s : System) : Record World := + ⟨fun w => decide ((s.method.realize w).run 0 = s.requirements.expected 0), true⟩ + +def systemHeld (s : System) : Theory World := + union (singleton (systemCapability s)) (singleton (systemBudget s)) + +inductive Question | correctOutput | affordable + deriving DecidableEq, Repr + +def systemContext (s : System) : Context World Question := + ⟨singleton (Compatible [systemObservation s]), + (fun q => match q with | .correctOutput => systemCapability s | .affordable => systemBudget s), + fun w => (s.method.realize w).domain 0 ∧ w.2 = .apply⟩ + +abbrev capability := systemCapability actualSystem +abbrev observation := systemObservation actualSystem +abbrev held := systemHeld actualSystem +abbrev context := systemContext actualSystem + +/- The output observation identifies the algorithm, without identifying its independently varied governance mode. -/ +theorem observationIdentifies (w : World) : Compatible [observation] w ↔ w.1 = .identity := by + rcases w with ⟨candidate, mode⟩ + cases candidate <;> simp [Compatible, observation, systemObservation, actualSystem, + implementation, identityRequirements, identityImpl, successorImpl] + +theorem capabilityActual : capability actual := fun _ _ => rfl + +theorem observedCapability : Supports [observation] capability := by + intro w hw + have hid := (observationIdentifies w).1 hw + rcases w with ⟨candidate, mode⟩ + change candidate = .identity at hid + subst candidate + exact fun _ _ => rfl + +def capabilityFacet : Facet World := .empirical [observation] (fun _ => True) capability (fun _ => True) + +theorem capabilityFacetChecked : FacetDischarged capabilityFacet := by + exact ⟨⟨actual, (observationIdentifies actual).2 rfl, trivial⟩, + (fun w hw _ => observedCapability w hw), fun _ _ => trivial⟩ + +theorem capabilityGrounds : Grounds capability canonicalArticulation + (fun f => f = capabilityFacet) [capabilityFacet] := + canonicalGroundsForSingleton capabilityFacet capabilityFacetChecked + +theorem actualAdmissible : Admissible held context actual := by + refine ⟨(modelsUnion _ _ _).2 ⟨(modelsSingleton _ _).2 capabilityActual, + (modelsSingleton _ _).2 (by change 1 ≤ 1; decide)⟩, + (modelsSingleton _ _).2 ((observationIdentifies actual).2 rfl), trivial, rfl⟩ + +theorem jointConsistent : Consistent held context := + consequenceConsistency held context ⟨actual, actualAdmissible⟩ + +/- The current method/principle forms, judgments, rules and own work are read from this very system and world. -/ +def Charter (s : System) (w : World) : Prop := + Generative (s.policy w) ∧ Consistent (systemHeld s) (systemContext s) ∧ + Reflexive s.owner (s.rules w) (s.work w) ∧ + (s.policy w).current s.method.form ∧ (s.policy w).current s.principleForm + +theorem charterChecked : Charter actualSystem actual := + ⟨⟨Or.inl rfl, fun _ _ => trivial⟩, jointConsistent, completeOwnWork_reflexive 0, rfl, rfl⟩ + +/- Revision adds a supported input-specific assertion about the same system's realized method. -/ +def revisedHeld : Theory World := union held + (singleton (fun w => (actualSystem.method.realize w).run 0 = actualSystem.requirements.expected 0)) + +def initialSnapshot : Snapshot World Question := ⟨held, context, 0⟩ +def revisedSnapshot : Snapshot World Question := ⟨revisedHeld, context, 1⟩ + +/-- organon-map CoreReader.Integration.revisionKeepsConsistency +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem revisionKeepsConsistency : + Charter actualSystem actual ∧ Consistent revisedHeld context ∧ + TruthfulReport initialSnapshot revisedSnapshot true ∧ + ¬ TruthfulReport initialSnapshot revisedSnapshot false := by + refine ⟨charterChecked, consequenceConsistency revisedHeld context ⟨actual, + (modelsUnion _ _ _).2 ⟨actualAdmissible.1, (modelsSingleton _ _).2 rfl⟩, + actualAdmissible.2⟩, (fun _ => rfl), ?_⟩ + intro h + have bad := h (Or.inr (by decide)) + cases bad + +/- A claim about this system's method is assessed as its owner's system claim. -/ +def OwnCapabilityDuty (s : System) (w : World) (facets : List (Facet World)) : Prop := + Performed (s.work w) (.system s.owner) .assessment ∧ + Grounds (systemCapability s) canonicalArticulation (fun f => f ∈ facets) facets + +/-- organon-map CoreReader.Integration.ownCapabilityGrounded +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem ownCapabilityGrounded : + OwnCapabilityDuty actualSystem actual [capabilityFacet] ∧ capability actual := by + refine ⟨⟨?_, ?_⟩, capabilityActual⟩ + · exact ownAssessmentPerformed 0 (.system 0) (by simp [ownSubjects]) + · exact canonicalGrounds capability [capabilityFacet] (by simp) + (by intro f hf; simp only [List.mem_singleton] at hf; cases hf; exact ⟨rfl, capabilityFacetChecked⟩) + +/- This cost observation is true of both algorithms but does not discriminate their output behavior. -/ +def costAllowanceRecord : Record World := + ⟨fun w => decide ((actualSystem.method.realize w).cost ≤ 2), true⟩ + +def unsupportedCapabilityFacet : Facet World := + .empirical [costAllowanceRecord] (fun _ => True) capability (fun _ => True) + +theorem costCompatibleWithFailure : Compatible [costAllowanceRecord] (.successor, .apply) := by + intro r hr + simp only [List.mem_singleton] at hr + subst r + rfl + +theorem costDoesNotSupportOutput : ¬ Supports [costAllowanceRecord] capability := by + intro h + have bad := h (.successor, .apply) costCompatibleWithFailure 0 trivial + cases bad + +theorem unsupportedGrounds : ¬ Grounds capability canonicalArticulation + (fun f => f = unsupportedCapabilityFacet) [unsupportedCapabilityFacet] := by + intro h + have discharged := (h.2.2 unsupportedCapabilityFacet (by simp)).2.2.2 + exact costDoesNotSupportOutput (fun w hw => discharged.2.1 w hw trivial) + +/- Five separately adopted requirements govern distinct operations; the mode does not give them priority over one another. -/ +inductive Commitment | generation | consistency | reflexivity | grounds | choice + deriving DecidableEq, Repr + +/- A Grounds policy governs arbitrary claims, articulations and applicable facets, rather than only one capability claim. -/ +def groundsPermission (mode : Mode) (claim : Claim World) (a : Facet World → Articulation World) + (applicable : Facet World → Prop) (facets : List (Facet World)) : Prop := + match mode with + | .apply => Grounds claim a applicable facets + | .waive => True + +def GroundsProvision (mode : Mode) : Prop := + ∀ claim a applicable facets, groundsPermission mode claim a applicable facets → + Grounds claim a applicable facets + +theorem groundsProvisionMeaning (mode : Mode) : GroundsProvision mode ↔ mode = .apply := by + cases mode with + | apply => exact ⟨fun _ => rfl, fun _ _ _ _ _ h => h⟩ + | waive => + constructor + · intro h + exact False.elim (unsupportedGrounds (h capability canonicalArticulation + (fun f => f = unsupportedCapabilityFacet) [unsupportedCapabilityFacet] trivial)) + · intro h; cases h + +/- The consistency policy checks a whole same-context theory, not isolated judgments. -/ +def consistencyPermission (mode : Mode) (t : Theory World) (c : Context World Question) : Prop := + match mode with | .apply => Consistent t c | .waive => True + +def conflictingHeld : Theory World := union (singleton capability) (singleton (fun w => ¬ capability w)) + +theorem conflictConsequences : + Consequence conflictingHeld context .correctOutput true ∧ + Consequence conflictingHeld context .correctOutput false := by + exact ⟨fun w hw => hw.1 capability (Or.inl rfl), + fun w hw => hw.1 (fun w => ¬ capability w) (Or.inr rfl)⟩ + +theorem conflictingHeldInconsistent : ¬ Consistent conflictingHeld context := + conflictRequiresChange conflictingHeld context .correctOutput conflictConsequences.1 conflictConsequences.2 + +/- The selection policy applies the actual output/budget and relevant-reason conditions to every implementation. -/ +def choicePermission (mode : Mode) (req : Requirements) (i : Implementation) (reasons : List Reason) : Prop := + match mode with | .apply => JustifiedChoice req i reasons | .waive => True + +/- The following consequences are computed from distinct rule applications; they are not interchangeable support flags. -/ +def proposedOperation : Mode → Operation + | .apply => .successor + | .waive => .copy + +def selfSamples : Mode → List Nat + | .apply => [0, 1] + | .waive => [1] + +noncomputable def conflictDecision (mode : Mode) : Bool := + @decide (consistencyPermission mode conflictingHeld context) (Classical.propDecidable _) + +noncomputable def groundsDecision (mode : Mode) (facet : Facet World) : Bool := + @decide (groundsPermission mode facet.claim canonicalArticulation (fun f => f = facet) [facet]) + (Classical.propDecidable _) + +noncomputable def choiceDecision (mode : Mode) (i : Implementation) (reasons : List Reason) : Bool := + @decide (choicePermission mode identityRequirements i reasons) (Classical.propDecidable _) + +theorem decisionsApply : conflictDecision .apply = false ∧ + groundsDecision .apply unsupportedCapabilityFacet = false ∧ + groundsDecision .apply capabilityFacet = true ∧ + choiceDecision .apply cheapSuccessor [.method .simplicity] = false ∧ + choiceDecision .apply identityImpl objectiveReason = true := by + classical + simp only [conflictDecision, groundsDecision, choiceDecision, consistencyPermission, + groundsPermission, choicePermission] + exact ⟨decide_eq_false conflictingHeldInconsistent, + decide_eq_false unsupportedGrounds, decide_eq_true capabilityGrounds, + decide_eq_false eligibleInternalReasonNotSufficient.2, decide_eq_true identityJustified⟩ + +theorem decisionsWaive : conflictDecision .waive = true ∧ + groundsDecision .waive unsupportedCapabilityFacet = true ∧ + choiceDecision .waive cheapSuccessor [.method .simplicity] = true := by + exact ⟨@decide_eq_true (consistencyPermission .waive conflictingHeld context) + (Classical.propDecidable _) trivial, + @decide_eq_true (groundsPermission .waive unsupportedCapabilityFacet.claim canonicalArticulation + (fun f => f = unsupportedCapabilityFacet) [unsupportedCapabilityFacet]) (Classical.propDecidable _) trivial, + @decide_eq_true (choicePermission .waive identityRequirements cheapSuccessor [.method .simplicity]) + (Classical.propDecidable _) trivial⟩ + +/- Each application supplies its own outcome type, adopted objective, constraints and actual option-indexed reasons. -/ +noncomputable def commitmentPositionFor (c : Commitment) (chosenMode : Mode) : ValuePosition World := + match c with + | .generation => { + Position := Mode, Outcome := Operation, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => proposedOperation mode, + objective := fun op => op.run 0 ≠ Operation.copy.run 0, + constraints := fun _ mode => Generative (policyFor mode), + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ mode => (proposedOperation mode).run 0 = 1 ∧ Operation.copy.run 0 = 0], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => ¬ Expanded baseState inflatedState, + response := fun _ => some "Pursuing expansion does not guarantee it; assess the actual before and after capabilities separately" } + | .consistency => { + Position := Mode, Outcome := Bool, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => conflictDecision mode, + objective := fun accepted => accepted = false, + constraints := fun _ mode => consistencyPermission mode held context, + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ _ => Consequence conflictingHeld context .correctOutput true ∧ + Consequence conflictingHeld context .correctOutput false], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => ¬ Entails (emptyTheory : Theory Bool) (fun w => w = true), + response := fun _ => some "Consistency alone does not establish sufficient support; assess the claim with its grounds as well" } + | .reflexivity => { + Position := Mode, Outcome := List Nat, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => selfSamples mode, + objective := fun samples => ∃ n ∈ samples, ownArithmeticPrinciple n = false, + constraints := fun _ mode => Reflexive 0 (ownRules 0) (workFor 0 mode), + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ _ => ownArithmeticPrinciple 0 = false ∧ ownArithmeticPrinciple 1 = true], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => selfTest [1] = true ∧ ownArithmeticPrinciple 0 = false, + response := fun _ => some "A passing self-test does not certify the principle; retain the relevant counterexample and its scope" } + | .grounds => { + Position := Mode, Outcome := Bool, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => groundsDecision mode unsupportedCapabilityFacet, + objective := fun accepted => accepted = false, + constraints := fun _ mode => groundsPermission mode capability canonicalArticulation + (fun f => f = capabilityFacet) [capabilityFacet], + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ _ => Compatible [costAllowanceRecord] (.successor, .apply) ∧ + ¬ capability (.successor, .apply)], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => OutputContract outputOnlyProcess ∧ ¬ ExplanationContract outputOnlyProcess, + response := fun _ => some "Grounds allows an external output assessment without requiring this process to provide an internal explanation" } + | .choice => { + Position := Mode, Outcome := Bool, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => choiceDecision mode cheapSuccessor [.method .simplicity], + objective := fun accepted => accepted = false, + constraints := fun _ mode => choicePermission mode identityRequirements identityImpl objectiveReason, + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ _ => cheapSuccessor.run 0 = 1 ∧ identityRequirements.expected 0 = 0 ∧ + cheapSuccessor.cost ≤ identityRequirements.budget], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => identityImpl.conventional = true ∧ identityImpl.established = true, + response := fun _ => some "An existing conventional method remains eligible when actual output and budget reasons justify it" } + +noncomputable def commitmentPosition (c : Commitment) : ValuePosition World := commitmentPositionFor c .apply + +/- The fact used as a reason has content before evaluating the adopted rule's consequence. -/ +theorem positionReasons (c : Commitment) : + ∀ r ∈ (commitmentPosition c).reasons, r actual (commitmentPosition c).adopted := by + cases c <;> intro r hr <;> dsimp [commitmentPosition, commitmentPositionFor] at hr ⊢ <;> + rcases List.mem_singleton.mp hr with rfl + · exact ⟨rfl, rfl⟩ + · exact conflictConsequences + · exact ⟨rfl, rfl⟩ + · refine ⟨costCompatibleWithFailure, ?_⟩ + intro h + have bad := h 0 trivial + cases bad + · exact ⟨rfl, rfl, by decide⟩ + +/- Each adopted rule has its stated consequence in this explicitly defined application; this is not ultimate value justification. -/ +theorem positionConsequence (c : Commitment) (w : World) : (commitmentPosition c).consequence w := by + cases c <;> dsimp [commitmentPosition, commitmentPositionFor, ValuePosition.consequence] + · exact ⟨by decide, ⟨Or.inl rfl, fun _ _ => trivial⟩⟩ + · exact ⟨decisionsApply.1, jointConsistent⟩ + · exact ⟨⟨0, by simp [selfSamples], rfl⟩, completeOwnWork_reflexive 0⟩ + · exact ⟨decisionsApply.2.1, capabilityGrounds⟩ + · exact ⟨decisionsApply.2.2.2.1, identityJustified⟩ + +theorem positionProcedure (c : Commitment) : ValueProcedure (commitmentPosition c) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · cases c <;> simp [commitmentPosition, commitmentPositionFor] + · refine ⟨actual, ?_, ?_, ?_, positionReasons c⟩ + · cases c <;> exact (modelsSingleton _ _).2 rfl + · cases c <;> rfl + · cases c <;> rfl + · intro w _ _ _ + exact positionConsequence c w + · intro w _ _ + cases c <;> exact ⟨_, rfl, by decide⟩ + +/- Criticism is instantiated within the adopted position's actual limit rather than made vacuous. -/ +theorem criticismWithinScope (c : Commitment) : + (commitmentPosition c).limits actual ∧ (commitmentPosition c).relevantCriticism actual := by + constructor + · cases c <;> rfl + · cases c + · simp [commitmentPosition, commitmentPositionFor, Expanded, baseState, inflatedState] + · exact consistentIncomplete.2.1 + · exact ⟨rfl, rfl⟩ + · exact ⟨outputNotExplanation.1, outputNotExplanation.2.1⟩ + · exact ⟨rfl, rfl⟩ + +/- Waiving the rule changes the actual computed outcome or an explicit adopted constraint; old reasons cannot certify it unchanged. -/ +theorem oppositeConsequenceFails (c : Commitment) (w : World) : + ¬ (commitmentPositionFor c .waive).consequence w := by + cases c <;> intro h + · exact permissionNotValuation.2.2 h.2 + · have bad : conflictDecision .waive = false := h.1 + rw [decisionsWaive.1] at bad + cases bad + · obtain ⟨n, hn, hf⟩ := h.1 + change n ∈ [1] at hn + have he : n = 1 := List.mem_singleton.mp hn + subst n + cases hf + · have bad : groundsDecision .waive unsupportedCapabilityFacet = false := h.1 + rw [decisionsWaive.2.1] at bad + cases bad + · have bad : choiceDecision .waive cheapSuccessor [.method .simplicity] = false := h.1 + rw [decisionsWaive.2.2] at bad + cases bad + +theorem oppositeProcedureRejected (c : Commitment) : ¬ ValueProcedure (commitmentPositionFor c .waive) := by + intro h + obtain ⟨w, hs, hl, _, hr⟩ := h.2.1 + exact oppositeConsequenceFails c w (h.2.2.1 w hs hl hr) + +/- Each statement names adoption of a particular rule; its defined policy gives that option its meaning. -/ +noncomputable def commitmentClaim (c : Commitment) : Claim World := (commitmentPosition c).commitment + +noncomputable def commitmentFacet (c : Commitment) : Facet World := .value (commitmentPosition c) + +/-- organon-map CoreReader.Integration.reasonsBelongToCommitments +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem reasonsBelongToCommitments (c : Commitment) : + Grounds (commitmentClaim c) canonicalArticulation + (fun f => f = commitmentFacet c) [commitmentFacet c] ∧ + JointAdoption (commitmentPosition c) ∧ + (commitmentPosition c).relevantCriticism actual ∧ + ¬ ValueProcedure (commitmentPositionFor c .waive) := by + exact ⟨canonicalGroundsForSingleton (commitmentFacet c) (positionProcedure c), + (positionProcedure c).2.1, (criticismWithinScope c).2, oppositeProcedureRejected c⟩ + +/- This claim concerns the Grounds rule for arbitrary claim/facet packages, not a single capability duty. -/ +theorem groundsCommitmentIsProvision : commitmentClaim .grounds = (fun w => GroundsProvision w.2) := by + funext w + apply propext + exact (groundsProvisionMeaning w.2).symm + +/-- organon-map CoreReader.Integration.groundsSelfAssessment +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem groundsSelfAssessment : + Grounds (fun w => GroundsProvision w.2) canonicalArticulation + (fun f => f = commitmentFacet .grounds) [commitmentFacet .grounds] ∧ + (commitmentPosition .grounds).limits actual ∧ + (commitmentPosition .grounds).relevantCriticism actual ∧ + ¬ ValueProcedure (commitmentPositionFor .grounds .waive) := by + rw [← groundsCommitmentIsProvision] + exact ⟨(reasonsBelongToCommitments .grounds).1, + (criticismWithinScope .grounds).1, (criticismWithinScope .grounds).2, + oppositeProcedureRejected .grounds⟩ + +/- This existing principle form implements the same system's choice rule on two actual proposals. +Input 0 names the identity proposal; input 1 names the cheap successor proposal. -/ +structure PhilosophyMethod where + form : Form + mode : Mode + +def currentPhilosophy (s : System) (w : World) : PhilosophyMethod := + ⟨s.principleForm, s.governance w⟩ + +noncomputable def PhilosophyMethod.review (p : PhilosophyMethod) (input : Nat) : Nat := + if input = 0 then + if choiceDecision p.mode identityImpl objectiveReason then 1 else 0 + else if choiceDecision p.mode cheapSuccessor [.method .simplicity] then 1 else 0 + +noncomputable def PhilosophyMethod.implementation (p : PhilosophyMethod) : Implementation where + name := "Current philosophy's proposal review" + conventional := true + established := true + run := p.review + cost := 1 + domain n := n = 0 ∨ n = 1 + explanation := p.review + trace n := [n, p.review n] + +def proposalRequirements : Requirements where + inputs n := n = 0 ∨ n = 1 + expected n := if n = 0 then 1 else 0 + budget := 1 + values _ := True + +theorem currentReviewCorrect : ∀ n, proposalRequirements.inputs n → + (currentPhilosophy actualSystem actual).review n = proposalRequirements.expected n := by + intro n hn + rcases hn with rfl | rfl <;> + simp [PhilosophyMethod.review, currentPhilosophy, actualSystem, actual, + proposalRequirements, decisionsApply.2.2.2.1, decisionsApply.2.2.2.2] + +/- Status alone fails for this actual principle method; its demonstrated proposal decisions give a relevant reason. -/ +/-- organon-map CoreReader.Integration.existingPhilosophyNotPrivileged +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem existingPhilosophyNotPrivileged : + (currentPhilosophy actualSystem actual).form = actualSystem.principleForm ∧ + (currentPhilosophy actualSystem actual).mode = actualSystem.governance actual ∧ + ¬ JustifiedChoice proposalRequirements + (currentPhilosophy actualSystem actual).implementation [.status .standing] ∧ + JustifiedChoice proposalRequirements + (currentPhilosophy actualSystem actual).implementation [.method .output] ∧ + (currentPhilosophy actualSystem actual).review 0 = 1 ∧ + (currentPhilosophy actualSystem actual).review 1 = 0 := by + refine ⟨rfl, rfl, statusOnlyFails _ _ _, ?_, currentReviewCorrect 0 (Or.inl rfl), + currentReviewCorrect 1 (Or.inr rfl)⟩ + exact ⟨⟨currentReviewCorrect, by change 1 ≤ 1; decide⟩, + .method .output, by simp, trivial, currentReviewCorrect⟩ + +/- Applications choose their contract and requirements; the resulting claim is about this system's actual method. -/ +def applicationClaim (s : System) (req : Requirements) + (contract : Requirements → Implementation → Prop) : Claim World := + fun w => contract req (s.method.realize w) + +def ApplicationDuties (s : System) (w : World) (req : Requirements) + (contract : Requirements → Implementation → Prop) + (articulations : Facet World → Articulation World) + (applicable : Facet World → Prop) (facets : List (Facet World)) : Prop := + Reflexive s.owner (s.rules w) (s.work w) ∧ + Grounds (applicationClaim s req contract) articulations applicable facets + +/- These are consequences of an explicitly adopted duty, not a proof that arbitrary applications fulfill it. -/ +/-- organon-map CoreReader.Integration.applicationRetainsDuties +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem applicationRetainsDuties (s : System) (w : World) (req : Requirements) + (contract : Requirements → Implementation → Prop) + (articulations : Facet World → Articulation World) + (applicable : Facet World → Prop) (facets : List (Facet World)) + (h : ApplicationDuties s w req contract articulations applicable facets) : + Reflexive s.owner (s.rules w) (s.work w) ∧ + (∀ f, applicable f → f ∈ facets) ∧ + (∀ f ∈ facets, f.claim = applicationClaim s req contract ∧ + Articulated (articulations f) ∧ FacetArticulated (articulations f) f ∧ FacetDischarged f) := + ⟨h.1, h.2.2.1, h.2.2.2⟩ + +def outputContract (req : Requirements) (i : Implementation) : Prop := + ∀ n, req.inputs n → i.run n = req.expected n + +def successorRequirements : Requirements := + { identityRequirements with expected := fun n => n + 1 } + +/- Holding the system and observation fixed while changing the actual objective changes the capability claim. -/ +def changedObjectiveFacet : Facet World := + .empirical [observation] (fun _ => True) + (applicationClaim actualSystem successorRequirements outputContract) (fun _ => True) + +/-- organon-map CoreReader.Integration.applicationVariation +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem applicationVariation : + ApplicationDuties actualSystem actual identityRequirements outputContract + canonicalArticulation (fun f => f = capabilityFacet) [capabilityFacet] ∧ + ¬ applicationClaim actualSystem successorRequirements outputContract actual ∧ + ¬ Grounds (applicationClaim actualSystem successorRequirements outputContract) + canonicalArticulation (fun f => f = changedObjectiveFacet) [changedObjectiveFacet] := by + refine ⟨⟨completeOwnWork_reflexive 0, capabilityGrounds⟩, ?_, ?_⟩ + · intro h + have bad := h 0 trivial + cases bad + · intro h + have discharged := (h.2.2 changedObjectiveFacet (by simp)).2.2.2 + have bad := discharged.2.1 actual ((observationIdentifies actual).2 rfl) trivial 0 trivial + cases bad + +/- The very system satisfies the charter while its true cost evidence fails to establish its output capability. -/ +/-- organon-map CoreReader.Integration.charterNotGrounds +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem charterNotGrounds : + Charter actualSystem actual ∧ + Compatible [costAllowanceRecord] actual ∧ + ¬ Grounds capability canonicalArticulation + (fun f => f = unsupportedCapabilityFacet) [unsupportedCapabilityFacet] := by + exact ⟨charterChecked, (by intro r hr; cases List.mem_singleton.mp hr; rfl), unsupportedGrounds⟩ + +/- A single inhabited system/context carries the charter, its own actual claim and support, +contentful principle work, and separately reasoned governance commitments. -/ +/-- organon-map CoreReader.Integration.jointWitness +organon.preamble#p1 sha256 2ff45595af647eddc9fc095b3f3854f284bf3740ae7af1bacdb98773ffa44097 +organon.preamble#p2 sha256 2ff45595af647eddc9fc095b3f3854f284bf3740ae7af1bacdb98773ffa44097 +organon.charter.overview#p2 sha256 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c +organon.charter.overview#p3 sha256 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem jointWitness : + ∃ s : System, ∃ w : World, + Admissible (systemHeld s) (systemContext s) w ∧ Charter s w ∧ + OwnCapabilityDuty s w [capabilityFacet] ∧ systemCapability s w ∧ + JustifiedChoice s.requirements (s.method.realize w) objectiveReason ∧ + (∀ c : Commitment, Grounds (commitmentClaim c) canonicalArticulation + (fun f => f = commitmentFacet c) [commitmentFacet c]) ∧ + s = actualSystem ∧ w = actual := by + exact ⟨actualSystem, actual, actualAdmissible, charterChecked, + ownCapabilityGrounded.1, capabilityActual, identityJustified, + fun c => (reasonsBelongToCommitments c).1, rfl, rfl⟩ + +end CoreReader.Integration +``` + + + + **L1** Imports CoreReader.Agency and its dependencies into this module. + + + **L2** Imports CoreReader.Choice and its dependencies into this module. + + + **L4** Opens namespace CoreReader.Integration; file boundaries do not change declaration identity. + + + **L5** Makes the listed namespaces available for unqualified references. + + + **L7** Documents the following definition or result: Builds Grounds from a nonempty list of discharged facets all targeting one claim, using canonical articulations and list membership itself as applicability. + + + **L8** Builds Grounds from a nonempty list of discharged facets all targeting one claim, using canonical articulations and list membership itself as applicability. + + + **L9** Assumes a nonempty facet list, with each facet targeting claim and already discharged. + + + **L10** Builds Grounds using each facet's own constructed articulation and list membership as the applicability predicate. + + + **L11** Supplies nonemptiness and tautological membership coverage, then checks each listed facet. + + + **L12** For each facet, uses checked to establish the same claim and derive a nonempty articulation from its discharge. + + + **L13** Adds that articulation's exact content correspondence and the supplied discharge proof. + + + **L15** Builds Grounds for one discharged facet with applicability exactly equality to that facet. + + + **L16** For a single discharged facet, makes exactly that facet applicable to its own claim. + + + **L17** Proves the singleton is nonempty and every facet equal to f occurs in it; leaves per-facet content checks. + + + **L18** Takes any facet g known to belong to the singleton list [f]. + + + **L19** Singleton membership turns hg into the equality g=f. + + + **L20** Replaces g by the same discharged facet f. + + + **L21** Uses identical claim, constructed articulability, exact facet-content match and checked discharge to finish its Grounds fields. + + + **L23** Documents the following definition or result: Separates applying the modeled standards from waiving them; the two modes drive actual policy decisions. + + + **L24** Separates applying the modeled standards from waiving them; the two modes drive actual policy decisions. + + + **L25** Generates decidable equality and display instances for the preceding datatype. + + + **L27** Documents the following definition or result: A world pairs one of two candidate implementations with one of two governance modes; it is a closed four-world model. + + + **L28** A world pairs one of two candidate implementations with one of two governance modes; it is a closed four-world model. + + + **L30** Chooses identity implementation under applying governance as the concrete actual world. + + + **L32** Documents the following definition or result: Binds a revisable form identity to a world-dependent implementation. + + + **L33** Binds a method form kind/version to its world-dependent implementation; this structure alone does not prove the form is revisable. + + + **L34** Stores the form kind and version of this method. + + + **L35** Assigns an actual implementation to every candidate/governance world for this same method. + + + **L37** Documents the following definition or result: Binds owner, method, principle form, governance selection and application requirements. + + + **L38** Binds owner, method, principle form, governance selection and application requirements. + + + **L39** Identifies the owner whose principles and work are used for this system. + + + **L40** Stores the system's method form together with its world-dependent implementation. + + + **L41** Stores the current form of the system's own principle. + + + **L42** Selects whether this system applies or waives governance in each world. + + + **L43** Fixes the actual input, output, budget and value requirements used to assess this system's implementation. + + + **L45** Applying governance selects the open policy; waiving selects the policy without expansion valuation. + + + **L46** Applying governance selects openPolicy, which values expansion and permits revision. + + + **L47** Waiving governance selects neutralPolicy, which lacks the required expansion valuation. + + + **L49** Applying governance supplies content-checked own-work records; waiving supplies none. + + + **L50** Applying governance gives this owner the complete contentful work log. + + + **L51** Waiving governance gives the same owner an empty work log. + + + **L53** Uses this same system's governance choice to select its policy. + + + **L54** Uses the registered generation/assessment rules for this system's owner. + + + **L55** Uses this owner's governance mode to select the actual work-record list. + + + **L57** Constructs owner zero with version-zero method/principle forms, candidate-dependent implementation, world-selected governance and identity requirements. + + + **L58** Assigns owner zero to the shared actual system. + + + **L59** Uses a version-zero method form whose realization is selected by the world's candidate component. + + + **L60** Sets this system's current principle form to principle version zero. + + + **L61** Reads governance from the world's second component, independently of the implementation candidate. + + + **L62** Assesses the same method against identityRequirements. + + + **L64** For this system's requested inputs, requires its realized method to match its own expected output. + + + **L65** Claims that this system's realized method meets its specified output on every required input. + + + **L67** Checks the same realized implementation's cost against the system's budget. + + + **L68** Claims that the same realized method's cost fits this system's own budget. + + + **L70** Records whether the system's actual implementation meets its expected output at input zero. + + + **L71** Records true for the test that this same method's output at zero equals its required output there. + + + **L73** Holds this same system's capability and budget claims together. + + + **L74** The system simultaneously holds its actual output-capability claim and its budget claim. + + + **L76** Defines the output-correctness and affordability questions used by the context. + + + **L77** Generates decidable equality and display instances for the preceding datatype. + + + **L79** Uses the same system's observation as assumption and its capability/budget as meanings; scope requires domain membership at zero and applying governance. + + + **L80** The context assumes compatibility with this system's actual zero-input observation. + + + **L81** Interprets correctOutput as this system's capability and affordable as its budget compliance. + + + **L82** Restricts admissible scope to implementations whose domain includes zero and worlds with governance applied. + + + **L84** Abbreviates the actual system's parameterized output capability claim. + + + **L85** Abbreviates the actual system's input-zero observation record. + + + **L86** Abbreviates the actual system's simultaneously held capability/budget theory. + + + **L87** Abbreviates the actual system's question/assumption/scope context. + + + **L89** Documents the following definition or result: Computes that the zero observation identifies the identity candidate while leaving governance mode unconstrained. + + + **L90** Computes that the zero observation identifies the identity candidate while leaving governance mode unconstrained. + + + **L91** Separates the candidate algorithm from the independently varied governance mode. + + + **L92** Checks each of the two actual candidates against the observation's true zero-output test. + + + **L93** Identity returns required zero while successor returns one, so only identity matches, regardless of governance. + + + **L95** Proves the actual identity implementation meets every requested identity output by reduction. + + + **L97** Uses candidate identification and known identity behavior to obtain universal requested-input capability within the closed model. + + + **L98** Takes an arbitrary world compatible with the same observation. + + + **L99** Uses observationIdentifies to infer that this world's algorithm candidate is identity. + + + **L100** Separates the world's algorithm and governance components for substitution. + + + **L101** Restates the inferred identity equality directly on the candidate variable. + + + **L102** Replaces the candidate algorithm with identity while retaining its governance mode. + + + **L103** Identity's run equals the required output at every input by definition, proving capability in this world. + + + **L105** Packages the actual observation and capability claim in an empirical facet with unrestricted scope and trivial uncertainty. + + + **L107** Supplies an actual compatible witness, the closed-model support proof and trivial uncertainty. + + + **L108** Supplies actual as a compatible world in the facet's unrestricted scope, avoiding an empty-world discharge. + + + **L109** Uses observedCapability for support in every compatible world; the stated uncertainty condition is trivial. + + + **L111** Builds canonical Grounds for this exact capability facet. + + + **L112** Makes only the actual output capability facet applicable, with its own singleton evidence package. + + + **L113** Applies the singleton Grounds constructor to the already discharged capability facet. + + + **L115** Proves actual identity/apply jointly satisfies capability, budget, observation assumptions and governance/domain scope. + + + **L116** Builds an admissible actual-world witness, first proving both jointly held claims; capability uses capabilityActual. + + + **L117** The held budget claim computes to actual cost 1 within budget 1. + + + **L118** Adds compatibility with the zero observation, domain membership at zero, and actual's apply mode. + + + **L120** Derives consistency from the explicitly established actual admissible world. + + + **L121** Applies semantic consequence consistency using actual and its admissibility proof as the required nonempty witness. + + + **L123** Documents the following definition or result: Conjoins this system's generation policy, contextual consistency, full content-valid reflexivity and current method/principle form membership. + + + **L124** Conjoins this system's generation policy, contextual consistency, full content-valid reflexivity and current method/principle form membership. + + + **L125** The Charter requires this system's actual policy to be Generative and its jointly held judgments contextually consistent. + + + **L126** It also requires full owned-rule reflexivity for this system's actual work log. + + + **L127** Both the method form and principle form must be current under that same policy. + + + **L129** Combines evaluated open-policy facts, actual consistency and the content-validated own-work model. + + + **L130** Combines openPolicy's valuation/revisability, jointConsistent, the complete owned log and both version-zero current forms. + + + **L132** Documents the following definition or result: Adds the system's zero-input output fact to its existing held theory. + + + **L133** Adds the system's zero-input output fact to its existing held theory. + + + **L134** Adds the specific assertion that this same method meets its required output at input zero. + + + **L136** Stores the actual held theory/context with revision identity zero. + + + **L137** Stores the extended held theory with the same context and revision identity one. + + + **L139** Opens provenance metadata binding CoreReader.Integration.revisionKeepsConsistency to the following source references; this metadata is not a proof premise. + + + **L140** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L141** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L142** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L143** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L144** Keeps the same charter and an admissible model after the added fact, then accepts true and rejects false revision reporting. + + + **L145** The actual system retains its Charter, and adding that supported assertion leaves revisedHeld consistent. + + + **L146** Reporting the identified revision as true satisfies the one-way change-report condition. + + + **L147** Reporting that same revision as false violates the condition. + + + **L148** Keeps charterChecked and proves revised consistency with actual as a concrete admissible witness. + + + **L149** Actual satisfies old held claims plus the newly added zero-input output assertion. + + + **L150** Retains actual's existing context/scope proof and verifies a true report; only rejection of a false report remains. + + + **L151** Assumes the changed snapshots could satisfy TruthfulReport with report=false. + + + **L152** The revision identifiers 0 and 1 differ, so that assumed obligation forces false=true. + + + **L153** Eliminates that impossible Boolean equality, rejecting the concealed revision. + + + **L155** Documents the following definition or result: Requires this system's assessment record and matching Grounds for its own capability claim. + + + **L156** Requires this system's assessment record and matching Grounds for its own capability claim. + + + **L157** OwnCapabilityDuty first requires an actual assessment record targeting this system's owner-identical system subject. + + + **L158** It also requires same-claim Grounds for this system's output capability over all listed applicable facets. + + + **L160** Opens provenance metadata binding CoreReader.Integration.ownCapabilityGrounded to the following source references; this metadata is not a proof premise. + + + **L161** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L162** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L163** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L164** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L165** Combines the actual content-validated self-assessment record with observation-supported capability Grounds and capability truth. + + + **L166** States that the actual system's own capability duty is fulfilled and its claimed capability actually holds. + + + **L167** Supplies capabilityActual immediately, leaving the system-assessment record and corresponding Grounds. + + + **L168** Uses the complete log's assessment of system zero as the owned-system work witness. + + + **L169** Builds Grounds from the nonempty singleton capability-facet list. + + + **L170** The singleton's only facet has exactly the target claim and the already proved discharge. + + + **L172** Documents the following definition or result: Records cost at most two for the same system implementation; both candidates pass. + + + **L173** Records cost at most two for the same system implementation; both candidates pass. + + + **L174** Records that implementation cost is at most two; both algorithm candidates satisfy this weaker cost observation. + + + **L176** Attempts to support the same output capability from only the permissive cost observation. + + + **L177** Attempts to support output capability using only cost evidence, with no restrictive scope or uncertainty condition. + + + **L179** Computes that successor/apply satisfies the cost observation despite failing identity output. + + + **L180** Takes a record belonging to the singleton cost-observation list. + + + **L181** Singleton membership identifies that record as costAllowanceRecord. + + + **L182** Substitutes the actual cost record for r. + + + **L183** Successor costs two, so the recorded at-most-two observation evaluates true. + + + **L185** Applies alleged support to the compatible successor counterworld and input zero to derive contradiction. + + + **L186** Assumes the cost observation supports output capability in every compatible world. + + + **L187** Applies that assumption to the compatible successor world and input zero, obtaining the false equation 1=0. + + + **L188** Eliminates the impossible output equality, refuting cost-only support. + + + **L190** Extracts the bad facet's support obligation from alleged Grounds and contradicts the cost countermodel. + + + **L191** Tests the singleton package that makes this cost-only capability facet applicable. + + + **L192** Assumes that inadequate singleton package nonetheless satisfies Grounds. + + + **L193** Extracts FacetDischarged for its actual cost-only capability facet from the Grounds premise. + + + **L194** Its support clause would yield cost-only Supports, contradicting costDoesNotSupportOutput. + + + **L196** Documents the following definition or result: Indexes five individual governance commitments, each with separately interpreted reasons and outcomes. + + + **L197** Indexes five individual governance commitments, each with separately interpreted reasons and outcomes. + + + **L198** Generates decidable equality and display instances for the preceding datatype. + + + **L200** Documents the following definition or result: Applying mode permits a claim bundle only when Grounds holds; waiving mode permits every bundle. + + + **L201** Applying mode permits a claim bundle only when Grounds holds; waiving mode permits every bundle. + + + **L202** Accepts an arbitrary applicability predicate and supplied facet package for the same claim/articulations. + + + **L203** Chooses the permission rule according to the governance mode. + + + **L204** Apply mode permits a package only when it actually satisfies Grounds. + + + **L205** Waive mode permits every package without checking Grounds. + + + **L207** States the general requirement that every permitted claim bundle has Grounds, across all claims, articulations, applicable facets and lists. + + + **L208** For every actual claim, articulation family and facet package, provision applies to any package the mode permits. + + + **L209** Every permitted package must satisfy its own corresponding Grounds duties. + + + **L211** Proves applying mode enforces the general provision, while the concrete unsupported cost bundle refutes waiving mode. + + + **L212** Checks the general provision separately for apply and waive modes. + + + **L213** In apply mode permission already is Grounds, so the general provision passes by returning the supplied proof. + + + **L214** For waive mode, the proof must show that unrestricted permission violates the general provision. + + + **L215** Proves both directions of the impossible waive-mode equivalence. + + + **L216** Assumes the general provision holds even though this mode waives checks. + + + **L217** Applies that universal assumption to the actual unsupported capability package, which would contradict unsupportedGrounds. + + + **L218** Supplies its exact singleton applicability and package; waive permission is true, forcing the invalid Grounds result. + + + **L219** The reverse implication starts from waive=apply, an impossible constructor equality. + + + **L221** Documents the following definition or result: Applying mode requires consistency for a proposed theory/context; waiving mode permits it unconditionally. + + + **L222** Applying mode requires consistency for a proposed theory/context; waiving mode permits it unconditionally. + + + **L223** Apply requires whole-theory consistency in context; waive imposes no such constraint. + + + **L225** Combines the actual capability claim with its negation in one theory. + + + **L227** Extracts both signed capability consequences from the simultaneously held contradictory claims. + + + **L228** The conflicting held theory entails positive output correctness under the fixed context. + + + **L229** The same theory and context also entail its negative judgment. + + + **L230** An admissible world's model of conflictingHeld must satisfy its explicitly included capability claim. + + + **L231** That same model must also satisfy the explicitly included negation of capability. + + + **L233** Uses those same-context opposite consequences to refute consistency. + + + **L234** Uses the two opposite same-context consequences to refute consistency of the conflicting held theory. + + + **L236** Documents the following definition or result: Applying governance uses the separate feasible relevant-choice norm; waiving governance accepts every proposed reason list. + + + **L237** Applying governance uses the separate feasible relevant-choice norm; waiving governance accepts every proposed reason list. + + + **L238** Apply enforces actual feasibility and reason relevance through JustifiedChoice; waive allows any selection package. + + + **L240** Documents the following definition or result: Applying mode proposes successor, while waiving proposes the unchanged copy operation. + + + **L241** Applying mode proposes successor, while waiving proposes the unchanged copy operation. + + + **L242** Applying the generation rule proposes successor, whose output can differ from copy. + + + **L243** Waiving that rule proposes the unchanged copy operation. + + + **L245** Applying mode tests zero and one; waiving mode tests only the passing sample one. + + + **L246** Applying reflexive assessment checks both zero and one, including the arithmetic counterexample. + + + **L247** Waiving it checks only one, the sample where the arithmetic principle passes. + + + **L249** Classically decides the consistency-permission proposition for the concrete conflicting theory; it is noncomputable, not a deployed checker. + + + **L250** Uses classical propositional decision to turn the whole conflicting-theory permission into a Boolean; no executable decision algorithm is supplied. + + + **L252** Classically decides whether the chosen mode permits the given exact singleton facet bundle. + + + **L253** Decides permission for this facet's own claim and its exact singleton assessment package. + + + **L254** Supplies classical decidability for that potentially noncomputable Grounds proposition. + + + **L256** Classically decides permission for the specified implementation/reasons under identity requirements. + + + **L257** Classically decides this implementation's permission under fixed identity requirements and its supplied reasons. + + + **L259** Proves applying mode rejects contradiction, unsupported capability and infeasible cheap successor while accepting actual capability and identity choice. + + + **L260** Applying Grounds rejects the cost-only capability package. + + + **L261** Applying Grounds accepts the properly supported output-observation package. + + + **L262** Applying choice rejects cheapSuccessor despite its relevant simplicity reason, because its output is infeasible. + + + **L263** Applying choice accepts identity with its actual output reason. + + + **L264** Enables the classical decidability instances used in these Boolean permission definitions. + + + **L265** Unfolds the three Boolean decisions and their apply-mode consistency predicate. + + + **L266** Also unfolds Grounds and choice permission, exposing the actual propositions each Boolean decides. + + + **L267** The proved inconsistency forces conflictDecision apply to false. + + + **L268** The failed cost package decides false, while the discharged observation package decides true. + + + **L269** The infeasible cheap method decides false; the feasible justified identity decides true. + + + **L271** Computes that waiving mode accepts the concrete contradiction, unsupported facet and infeasible choice. + + + **L272** Waive mode accepts even the unsupported cost-only capability package. + + + **L273** It also accepts cheapSuccessor with simplicity alone despite the wrong output. + + + **L274** Starts the waiver calculation with consistencyPermission, which is definitionally True in this mode. + + + **L275** Uses that trivial permission proof to obtain the true Boolean conflict decision. + + + **L276** Next decides waiver permission for the exact unsupported capability facet's claim. + + + **L277** Its singleton applicability/package is unchanged; waiver makes permission True and the decision true. + + + **L278** Finally decides waiver permission for the same cheap method and simplicity-only reasons. + + + **L279** That permission is again trivially True, completing all three waiver decisions. + + + **L281** Documents the following definition or result: For each commitment, interprets governance modes as options with its own operational outcome, objective, constraint, actual reasons and scoped criticism response. + + + **L282** For each commitment, interprets governance modes as options with its own operational outcome, objective, constraint, actual reasons and scoped criticism response. + + + **L283** Chooses a different operational value-position adapter for each of the five commitments. + + + **L284** Constructs the value position for the generation commitment. + + + **L285** Its positions are governance modes, outcomes are operations, and adoption is compared with this same system's selected governance. + + + **L286** Maps a mode to the actual proposed successor-or-copy operation. + + + **L287** The adopted generation objective requires output at zero to differ from copy's zero output. + + + **L288** Also requires the mode's actual policy to satisfy the adopted Generative constraints. + + + **L289** Explicitly assumes the same system has selected chosenMode; this is a starting commitment, not a derived universal fact. + + + **L290** Its option-dependent reason compares the proposed operation's 0→1 behavior with copy's 0→0 behavior. + + + **L291** Limits this generation position to worlds whose implementation candidate is identity. + + + **L292** Keeps actual inventory inflation without expansion as a relevant criticism of the generation commitment. + + + **L293** Responds that orientation does not guarantee progress and before/after capabilities need separate assessment; the stored response is nonempty text. + + + **L294** Constructs the distinct value position for the consistency commitment. + + + **L295** Uses modes as positions and a Boolean conflict-admission decision as outcome, tied to the same selected governance. + + + **L296** Its actual outcome is the mode's decision on the whole conflicting theory. + + + **L297** Requires that decision to reject the conflicting theory. + + + **L298** Simultaneously requires the actual held theory and context to pass the same mode's consistency permission. + + + **L299** States adoption of chosenMode by the same system as this position's explicit starting assumption. + + + **L300** The consistency reason begins with the conflicting theory's positive output-correctness consequence. + + + **L301** It also includes the opposite consequence under exactly the same question and context. + + + **L302** Limits this consistency position to identity-candidate worlds. + + + **L303** Uses the empty Bool theory's failure to entail truth at every world as the live incompleteness criticism. + + + **L304** Responds that consistency alone does not establish sufficient support and the claim's grounds still need assessment. + + + **L305** Constructs the value position for reflexive assessment. + + + **L306** Uses modes as positions and an actual sample-input list as outcome, tied to the same selected governance. + + + **L307** The mode chooses the sample set [0,1] or [1]. + + + **L308** Requires some actually selected sample to expose a false result of the same arithmetic principle. + + + **L309** Also requires full owner-zero rule/work reflexivity for that same mode. + + + **L310** Explicitly adopts chosenMode for this same system as the starting commitment. + + + **L311** The reason identifies actual arithmetic failure at zero and success at one. + + + **L312** Restricts this reflexivity position to identity-candidate worlds. + + + **L313** Retains the passing test at one together with the actual failure at zero as criticism. + + + **L314** Responds that passing a self-test does not certify the principle and the counterexample's scope must be retained. + + + **L315** Constructs the value position for the Grounds provision itself. + + + **L316** Uses modes as positions and a Boolean evidence-package decision as outcome, under the same system's governance. + + + **L317** The actual outcome tests the unsupported cost-only capability facet. + + + **L318** Requires rejection of that unsupported evidence package. + + + **L319** Also requires permission for the actual capability claim with its content-derived articulations. + + + **L320** That positive constraint uses exactly the properly discharged singleton capabilityFacet package. + + + **L321** States this same system's adoption of chosenMode as an explicit starting commitment. + + + **L322** The Grounds reason records that the successor/apply world is compatible with the cost observation. + + + **L323** It pairs that compatibility with actual failure of the claimed output capability in that same world. + + + **L324** Restricts this Grounds position to identity-candidate worlds. + + + **L325** The criticism points to the same process having the output contract without an attached explanation contract. + + + **L326** Responds that external output assessment can supply Grounds without requiring this process to explain its internal generation. + + + **L327** Constructs the separate value position for implementation choice. + + + **L328** Uses modes as positions and a Boolean method-admission decision as outcome, under the same governance selection. + + + **L329** The tested choice is the cheap successor justified only by its simplicity reason. + + + **L330** Requires rejection of that wrong-output choice. + + + **L331** Also requires acceptance of identity under the same requirements with its actual output reason. + + + **L332** Explicitly adopts chosenMode for this system; the value starting point is not proved from neutral facts. + + + **L333** The choice reason contrasts cheapSuccessor's output one with the required output zero on the same input. + + + **L334** Also records that the method fits the budget, so cheapness cannot conceal its output failure. + + + **L335** Limits this choice position to identity-candidate worlds. + + + **L336** Keeps identity's actual conventional and established status as a relevant criticism of excluding existing methods. + + + **L337** Responds that a conventional existing method remains eligible when actual output and budget reasons justify it. + + + **L339** Specializes each individually interpreted position to adopting applying governance. + + + **L341** Documents the following definition or result: Checks every listed commitment-specific reason at the same actual world and adopted mode by concrete counterexamples or computation. + + + **L342** Checks every listed commitment-specific reason at the same actual world and adopted mode by concrete counterexamples or computation. + + + **L343** Every actual listed reason for commitment c must hold at actual for its adopted apply option. + + + **L344** Separates the five commitments and unfolds each actual reason list while fixing a listed reason r. + + + **L345** Each list is a singleton, so the membership premise identifies r with that commitment's concrete reason. + + + **L346** Generation's reason computes successor 0=1 and copy 0=0. + + + **L347** Consistency's reason uses the already proved positive and negative consequences of the same conflicting theory. + + + **L348** Reflexivity's reason computes failure at zero and success at one for the same arithmetic principle. + + + **L349** For Grounds, supplies the successor world's cost compatibility and leaves its capability failure to prove. + + + **L350** Assumes that same successor world nevertheless has the required output capability. + + + **L351** At required input zero, that assumption yields successor's output one equal to required zero. + + + **L352** Eliminates the impossible 1=0 equality, proving the capability failure part of the reason. + + + **L353** Choice's reason computes output one, required zero and the cheap method's within-budget cost. + + + **L355** Documents the following definition or result: Proves each adopted mode has its stated objective and constraint using actual decision and compliance theorems, without asserting ultimate normative validity. + + + **L356** Proves each adopted mode has its stated objective and constraint using actual decision and compliance theorems, without asserting ultimate normative validity. + + + **L357** Unfolds each commitment's consequence into its actual objective and mode-dependent constraint. + + + **L358** Generation's apply option differs from copy at zero and its openPolicy satisfies valuation plus revisability. + + + **L359** Consistency's apply option rejects the conflicting theory while the actual held theory remains consistent. + + + **L360** Reflexivity chooses the actual counterexample zero from [0,1] and supplies full contentful owned-work reflexivity. + + + **L361** Grounds rejects the unsupported cost package while the proper capability package has Grounds. + + + **L362** Choice rejects cheapSuccessor and retains the justified feasible identity implementation. + + + **L364** Builds nonempty reason lists, joint adoption, checked option consequences and nonempty responses for every commitment; reason assumptions are not needed by the already proved consequences. + + + **L365** Splits ValueProcedure into nonempty reasons, joint adoption, the scoped consequence rule and criticism response. + + + **L366** Checks that every commitment's actual reason list contains its singleton reason. + + + **L367** Uses the same actual world for JointAdoption and supplies positionReasons c; remaining goals are starting-theory membership, limits and adoption. + + + **L368** In actual, governance is apply, so the singleton starting theory selecting the adopted mode holds. + + + **L369** For each commitment, actual's identity candidate satisfies its declared limit. + + + **L370** For each commitment, actual's selected governance equals the adopted apply option. + + + **L371** Takes an arbitrary world and the procedure's starting, limit and all-reasons premises for its consequence clause. + + + **L372** Uses positionConsequence, which already proves that apply option's objective and constraints for every world; these premises are not needed here. + + + **L373** For the response clause, takes a world with an in-scope relevant criticism. + + + **L374** Every commitment returns its actual stored nonempty response string, satisfying the response-existence requirement. + + + **L376** Documents the following definition or result: Provides an actual in-scope criticism case for each commitment, avoiding vacuous response obligations in these examples. + + + **L377** Provides an actual in-scope criticism case for each commitment, avoiding vacuous response obligations in these examples. + + + **L378** Requires both that actual is inside this commitment's limits and that its specific criticism really applies there. + + + **L379** Separates the actual-limit check from the actual-criticism check. + + + **L380** Every limit asks for identity, which is actual's candidate by definition. + + + **L381** Checks each commitment's distinct criticism rather than assuming criticism vacuously. + + + **L382** Generation's criticism holds because inflating baseline lists creates no newly understood or constructed operation. + + + **L383** Consistency's criticism uses the empty theory's proved failure to entail the selected Bool claim. + + + **L384** Reflexivity's criticism computes a passing sample at one and failure at zero. + + + **L385** Grounds' criticism combines actual output correctness of outputOnlyProcess with its absent explanation contract. + + + **L386** Choice's criticism holds because identity is actually conventional and established. + + + **L388** Documents the following definition or result: Shows the waiving option fails each unchanged commitment-specific objective or constraint. + + + **L389** Shows the waiving option fails each unchanged commitment-specific objective or constraint. + + + **L390** Claims that every commitment's waive option fails its declared objective or constraint in any world. + + + **L391** Separates the commitments and assumes the corresponding waive consequence, seeking a contradiction. + + + **L392** Generation's consequence would require Generative neutralPolicy, contradicting permissionNotValuation's proved failure. + + + **L393** Consistency's assumed objective says waive must reject the conflicting theory. + + + **L394** But decisionsWaive computes acceptance=true, turning that objective into true=false. + + + **L395** Rejects that impossible Boolean equality for the consistency option. + + + **L396** Reflexivity's assumed objective supplies a selected sample n where the arithmetic principle is false. + + + **L397** Waive mode's selected samples are exactly [1]. + + + **L398** Membership in that singleton forces the supposed failing input n to be one. + + + **L399** Replaces n with one in the alleged failure proof. + + + **L400** The principle actually returns true at one, contradicting its alleged false result. + + + **L401** Grounds' assumed objective says waive rejects the specific unsupported capability package. + + + **L402** decisionsWaive instead says that same package is accepted, yielding true=false. + + + **L403** Rejects the impossible equality, so the waived Grounds consequence fails. + + + **L404** Choice's assumed objective says waive rejects cheapSuccessor with simplicity alone. + + + **L405** decisionsWaive proves that exact selection is accepted, again yielding true=false. + + + **L406** Rejects that equality, completing failure of all five waive consequences. + + + **L408** Combines a hypothetical joint-adoption witness with consequence failure to reject the opposite mode's procedure. + + + **L409** Assumes the opposite waive value position nevertheless satisfies ValueProcedure. + + + **L410** Extracts its JointAdoption witness w, starting-theory proof hs, limit proof hl and all-reasons proof hr. + + + **L411** The assumed procedure's consequence clause applied to that same joint witness produces the waive consequence, which oppositeConsequenceFails c w refutes. + + + **L413** Documents the following definition or result: Extracts each position's adoption claim; all use the same governance selector but have separately assessed consequences and reasons. + + + **L414** Extracts each position's adoption claim; all use the same governance selector but have separately assessed consequences and reasons. + + + **L416** Wraps the specific interpreted commitment position as a value facet. + + + **L418** Opens provenance metadata binding CoreReader.Integration.reasonsBelongToCommitments to the following source references; this metadata is not a proof premise. + + + **L419** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L420** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L421** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L422** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L423** Provides per-commitment Grounds, a real joint adoption, actual relevant criticism and rejection of the opposite policy under the same interpreted objective. + + + **L424** Requires Grounds for the actual adoption claim of commitment c, with articulation built from its facet contents. + + + **L425** Makes exactly commitmentFacet c applicable and supplies only that same facet. + + + **L426** Additionally requires a nonempty jointly admissible adoption witness for that position. + + + **L427** Requires this particular commitment's criticism to actually hold at actual. + + + **L428** Also proves the opposite waive position fails the same value-procedure requirements. + + + **L429** Constructs singleton Grounds using that commitment's checked positionProcedure. + + + **L430** Adds its joint witness, actual criticism and the proved rejection of its opposite position. + + + **L432** Documents the following definition or result: Proves the grounds position's adoption claim is extensionally the general Grounds provision for the selected governance mode. + + + **L433** Proves the grounds position's adoption claim is extensionally the general Grounds provision for the selected governance mode. + + + **L434** To equate the two claims, fixes an arbitrary world w and compares their propositions there. + + + **L435** Uses proposition extensionality: equivalence of the two propositions suffices for their equality. + + + **L436** groundsProvisionMeaning says the general provision holds exactly in apply mode, matching this adoption claim in reverse direction. + + + **L438** Opens provenance metadata binding CoreReader.Integration.groundsSelfAssessment to the following source references; this metadata is not a proof premise. + + + **L439** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L440** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L441** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L442** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L443** Applies value Grounds to the general Grounds provision itself, retaining actual scope/criticism and a rejected waiver variant. + + + **L444** Assesses the general GroundsProvision itself, quantified over claim/facet packages, with content-derived articulation. + + + **L445** The applicable value aspect is exactly the grounds commitment's own facet. + + + **L446** Requires actual to satisfy that commitment's declared limit. + + + **L447** Requires its criticism to actually apply at actual as well. + + + **L448** Requires the opposite waived Grounds commitment to fail ValueProcedure. + + + **L449** Rewrites the general provision as the extensionally identical grounds adoption claim. + + + **L450** Reuses the actual Grounds proof for that same grounds commitment. + + + **L451** Supplies the separately checked actual limit and actual relevant criticism. + + + **L452** Supplies the proved failure of the opposite waived Grounds position. + + + **L454** Documents the following definition or result: Stores the current philosophical principle form and its actual governance mode. + + + **L455** Documents the following definition or result: Stores the current philosophical principle form and its actual governance mode. + + + **L456** Stores the current philosophical principle form and its actual governance mode. + + + **L457** Stores the actual principle form this philosophy method implements. + + + **L458** Stores whether this same philosophy method applies or waives its governance checks. + + + **L460** Derives the reviewed philosophy object from this same system's principle form and governance selection. + + + **L461** Builds the philosophy method from this system's own principle form and its governance in w. + + + **L463** Returns approval decisions for the identity proposal at zero and the cheap infeasible proposal otherwise, using this philosophy's actual governance mode. + + + **L464** Input zero identifies the identity-method proposal; every other input follows the cheap-successor proposal branch. + + + **L465** For identity, runs this philosophy method's actual choice policy and returns 1 for accept, 0 for reject. + + + **L466** For other inputs, applies the same policy to cheapSuccessor with simplicity alone, again encoding accept/reject as 1/0. + + + **L468** Exposes that actual philosophical review procedure as an implementation with domain zero/one and matching output/trace proxies. + + + **L469** Names the implementation as the current philosophy's actual proposal-review method. + + + **L470** Marks this proposal-review implementation as conventional. + + + **L471** Also marks the same implementation as established; later proof tests whether that alone justifies priority. + + + **L472** The implementation's actual run is precisely this philosophy method's review function. + + + **L473** Assigns cost one to this review implementation. + + + **L474** Declares only proposal identifiers zero and one within its application domain. + + + **L475** Provides the same review function as the implementation's explanation field. + + + **L476** Records a two-entry trace containing the proposal identifier and its actual review result. + + + **L478** Requires accepting proposal zero and rejecting proposal one within budget one. + + + **L479** The application tests exactly proposal identifiers zero and one. + + + **L480** Requires identity's proposal zero to be accepted as 1 and the other tested proposal to be rejected as 0. + + + **L481** Allows this review method a cost budget of one. + + + **L482** Imposes no additional restriction through the requirements' values predicate in this example. + + + **L484** Computes both requested proposal decisions from applying-governance results. + + + **L485** For each required proposal, the actual system's current philosophy review must equal the application's expected verdict. + + + **L486** Takes a proposal n with proof hn that it is one of the required inputs. + + + **L487** Uses hn to restrict n to the concrete identity or cheap-successor proposal identifier. + + + **L488** Unfolds the same current philosophy method and actual system to expose the real proposal decisions. + + + **L489** Uses decisionsApply to match accepted identity and rejected cheap successor against their required verdicts. + + + **L491** Documents the following definition or result: Binds the implementation to the current principle/governance object, rejects status-only priority and justifies it by its two actual proposal decisions. + + + **L492** Opens provenance metadata binding CoreReader.Integration.existingPhilosophyNotPrivileged to the following source references; this metadata is not a proof premise. + + + **L493** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L494** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L495** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L496** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L497** Binds the implementation to the current principle/governance object, rejects status-only priority and justifies it by its two actual proposal decisions. + + + **L498** Checks this philosophy method's form is exactly the actual system's current principle form. + + + **L499** Checks its governance mode is exactly the same system's mode at actual. + + + **L500** Begins the claim that status alone cannot justify choosing this actual review implementation. + + + **L501** The rejected reason list is exactly [.status .standing] for that same philosophy implementation. + + + **L502** By contrast, asserts this implementation has a justified choice under the actual proposal requirements. + + + **L503** That positive choice uses its actual output reason, not merely its name or established flag. + + + **L504** The same philosophy review actually accepts identity's proposal zero with result one. + + + **L505** It actually rejects cheap successor's proposal one with result zero. + + + **L506** Provides same-form/mode identities, status-only rejection and correct proposal-zero evaluation; leaves positive output-based choice to prove. + + + **L507** Also supplies currentReviewCorrect for required proposal one, proving its actual rejection. + + + **L508** Builds the positive choice's feasibility from both correct proposal outputs and cost 1≤budget 1. + + + **L509** Uses the listed .method .output reason and currentReviewCorrect as its actual relevance witness. + + + **L511** Documents the following definition or result: Applies any supplied application contract and requirements to this system's actual world-dependent method. + + + **L512** Applies any supplied application contract and requirements to this system's actual world-dependent method. + + + **L513** Accepts an arbitrary application contract relating Requirements to the implementation being assessed. + + + **L514** At each world, applies that same contract and requirements to this system's actual method realization. + + + **L516** Conjoins full same-system reflexivity with Grounds for the exact parameterized application claim. + + + **L517** ApplicationDuties keeps the chosen application contract as an explicit parameter. + + + **L518** Also accepts the articulation supplied for each potentially relevant facet. + + + **L519** Keeps the actual applicability predicate separate from the supplied facet list. + + + **L520** Requires full reflexivity of the same system owner's actual rules and work at w. + + + **L521** Requires matching Grounds for the claim produced by this system, these requirements and this contract. + + + **L523** Documents the following definition or result: Projects an explicitly assumed application-compliance interface into reflexivity, applicability coverage and matching discharged facets; it does not invent compliance. + + + **L524** Opens provenance metadata binding CoreReader.Integration.applicationRetainsDuties to the following source references; this metadata is not a proof premise. + + + **L525** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L526** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L527** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L528** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L529** Projects an explicitly assumed application-compliance interface into reflexivity, applicability coverage and matching discharged facets; it does not invent compliance. + + + **L530** The theorem retains the arbitrary application contract rather than fixing a single capability definition. + + + **L531** Retains the actual articulation family for that application's facets. + + + **L532** Retains the application's own applicability predicate and supplied facet list. + + + **L533** Crucially assumes ApplicationDuties already holds for these exact objects; the theorem does not create compliance. + + + **L534** The conclusion retains full same-owner rule/work reflexivity from that assumed duty. + + + **L535** It requires every actually applicable facet to occur in the supplied list, regardless of labels. + + + **L536** For every listed facet, its assessed claim must equal this system's actual parameterized application claim. + + + **L537** That same facet must have an articulable, content-matching articulation and actually satisfy its discharge conditions. + + + **L538** Projects h.1 as reflexivity, h.2.2.1 as applicability coverage, and h.2.2.2 as each listed facet's same-claim, articulation and discharge checks. + + + **L540** Requires the implementation to meet the application's expected output on every requested input. + + + **L541** The output contract checks this implementation's actual run against the chosen expected output on every required input. + + + **L543** Changes the same application requirements from identity to successor output while retaining other fields. + + + **L544** Keeps identityRequirements' inputs and other fields but changes expected output to n+1. + + + **L546** Documents the following definition or result: Reuses the old observation while changing the assessed claim to the successor objective, setting up a same-object scope test. + + + **L547** Reuses the old observation while changing the assessed claim to the successor objective, setting up a same-object scope test. + + + **L548** Reuses the old actual observation for an empirical facet with unrestricted scope. + + + **L549** Changes its assessed claim to this same system meeting successorRequirements; the uncertainty predicate remains trivial. + + + **L551** Opens provenance metadata binding CoreReader.Integration.applicationVariation to the following source references; this metadata is not a proof premise. + + + **L552** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L553** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L554** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L555** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L556** In this example, the original identity contract retains its fulfilled duties; the changed successor contract fails for the same actual method, and the specified retained-observation package cannot ground it. + + + **L557** The original identity-output application fulfills ApplicationDuties for the actual system and world. + + + **L558** That positive instance uses the already supported capabilityFacet and its own constructed articulation. + + + **L559** But the same actual system does not meet the changed successor-output contract. + + + **L560** Nor does the changed claim acquire Grounds from the retained observation package. + + + **L561** This failure concerns exactly changedObjectiveFacet's singleton package, not every possible evidence package. + + + **L562** Builds the original duty from full owned reflexivity and capabilityGrounds, then leaves changed behavior and changed evidence failures. + + + **L563** Assumes the actual identity method meets the new successor contract. + + + **L564** At required input zero, this would force actual output zero to equal expected one. + + + **L565** Eliminates the impossible 0=1 equality, refuting the changed actual capability claim. + + + **L566** Assumes the retained observation singleton nevertheless gives Grounds for that changed claim. + + + **L567** Extracts the actual changedObjectiveFacet's discharge from that assumed Grounds package. + + + **L568** Its support rule applied to the compatible actual world and input zero yields the same false output equality 0=1. + + + **L569** Rejects that equality, proving the specified retained-observation package cannot ground the new claim. + + + **L571** Documents the following definition or result: Exhibits this actual charter-compliant system with compatible cost evidence whose specified capability facet is unsupported; other valid grounds can still exist. + + + **L572** Opens provenance metadata binding CoreReader.Integration.charterNotGrounds to the following source references; this metadata is not a proof premise. + + + **L573** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L574** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L575** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L576** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L577** Exhibits this actual charter-compliant system with compatible cost evidence whose specified capability facet is unsupported; other valid grounds can still exist. + + + **L578** The same actual system satisfies all represented Charter conditions. + + + **L579** Its actual world is compatible with the true at-most-two cost observation. + + + **L580** Nevertheless, that cost evidence does not provide Grounds for its output capability. + + + **L581** The denied Grounds is the particular unsupportedCapabilityFacet singleton, not every possible assessment bundle. + + + **L582** Combines charterChecked, direct compatibility of actual with the cost record, and the already proved unsupportedGrounds counterexample. + + + **L584** Documents the following definition or result: Constructs one shared system/world satisfying actual judgments, full reflexivity, capability evidence, feasible choice and each interpreted commitment's Grounds; it is a bounded model, not universal philosophical correctness. + + + **L585** Documents the following definition or result: Constructs one shared system/world satisfying actual judgments, full reflexivity, capability evidence, feasible choice and each interpreted commitment's Grounds; it is a bounded model, not universal philosophical correctness. + + + **L586** Opens provenance metadata binding CoreReader.Integration.jointWitness to the following source references; this metadata is not a proof premise. + + + **L587** Records source reference organon.preamble#p1 with content digest 2ff45595af647eddc9fc095b3f3854f284bf3740ae7af1bacdb98773ffa44097; matching a digest establishes source identity, not semantic fidelity. + + + **L588** Records source reference organon.preamble#p2 with content digest 2ff45595af647eddc9fc095b3f3854f284bf3740ae7af1bacdb98773ffa44097; matching a digest establishes source identity, not semantic fidelity. + + + **L589** Records source reference organon.charter.overview#p2 with content digest 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c; matching a digest establishes source identity, not semantic fidelity. + + + **L590** Records source reference organon.charter.overview#p3 with content digest 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c; matching a digest establishes source identity, not semantic fidelity. + + + **L591** Records source reference organon.relationships.roles#p1 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L592** Records source reference organon.relationships.roles#p2 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L593** Records source reference organon.relationships.roles#p3 with content digest 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e; matching a digest establishes source identity, not semantic fidelity. + + + **L594** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L595** Constructs one shared system/world satisfying actual judgments, full reflexivity, capability evidence, feasible choice and each interpreted commitment's Grounds; it is a bounded model, not universal philosophical correctness. + + + **L596** Requires an actual system/world pair as the joint witness, so the combined claim is nonempty. + + + **L597** That same pair must be admissible for its jointly held/contextual claims and satisfy its Charter. + + + **L598** It must also have its own capability duty fulfilled by capabilityFacet and possess the claimed capability. + + + **L599** The same realized method must be feasibly chosen under its own requirements using objectiveReason. + + + **L600** For every one of the five commitments, the corresponding actual adoption claim must have Grounds. + + + **L601** Each commitment uses its own exact singleton value facet and corresponding applicability. + + + **L602** Finally identifies the witnesses with actualSystem and actual, preventing unrelated existential substitutions. + + + **L603** Chooses that exact pair and supplies its actual admissibility and checked Charter. + + + **L604** Adds this same system's owned capability duty, actual capability and justified identity choice. + + + **L605** Uses each commitment's existing Grounds proof, then closes the two witness-identity equalities by construction. + + + **L607** Closes the current namespace. + + +### `leanified/CoreReader/Logic.lean` + + +```lean +namespace CoreReader.Logic + +/- A claim denotes the worlds in which its content holds. -/ +abbrev Claim (W : Type) := W → Prop +/- A theory is a collection of simultaneously held claims. -/ +abbrev Theory (W : Type) := Claim W → Prop +/- A model satisfies every member of the whole theory. -/ +def Models {W : Type} (t : Theory W) (w : W) : Prop := ∀ p, t p → p w +/- Semantic entailment quantifies over all models. -/ +def Entails {W : Type} (t : Theory W) (p : Claim W) : Prop := ∀ w, Models t w → p w +/- Satisfiability requires an actual witness. -/ +def Satisfiable {W : Type} (t : Theory W) : Prop := ∃ w, Models t w +/- Assumptions, meanings and scope are distinct components; questions remain explicit. -/ +structure Context (W Q : Type) where + assumptions : Theory W + meaning : Q → Claim W + scope : Claim W +/- Admissible worlds satisfy held claims, assumptions and scope jointly. -/ +def Admissible {W Q : Type} (t : Theory W) (c : Context W Q) (w : W) : Prop := + Models t w ∧ Models c.assumptions w ∧ c.scope w +/- A negative judgment denies the very same question under the same meaning. -/ +def Consequence {W Q : Type} (t : Theory W) (c : Context W Q) (q : Q) (positive : Bool) : Prop := + ∀ w, Admissible t c w → if positive then c.meaning q w else ¬ c.meaning q w +/- The consistency obligation prohibits both consequences at one comparison basis. -/ +def Consistent {W Q : Type} (t : Theory W) (c : Context W Q) : Prop := + ∀ q, ¬ (Consequence t c q true ∧ Consequence t c q false) +/- An inhabited joint interpretation prevents opposite semantic consequences. -/ +/-- organon-map CoreReader.Logic.consequenceConsistency +organon.charter.consistency#p1 sha256 c6960c590c096d33250599cf418e3c6a1dc26bfc7d7800c82b8efde656950f42 +-/ +theorem consequenceConsistency {W Q : Type} (t : Theory W) (c : Context W Q) + (inhabited : ∃ w, Admissible t c w) : Consistent t c := by + intro q h + obtain ⟨w, hw⟩ := inhabited + exact (h.2 w hw) (h.1 w hw) +/- Empty and singleton theories provide concrete semantic contexts. -/ +def emptyTheory {W : Type} : Theory W := fun _ => False +def singleton {W : Type} (p : Claim W) : Theory W := fun q => q = p +def union {W : Type} (a b : Theory W) : Theory W := fun p => a p ∨ b p +theorem modelsSingleton {W : Type} (p : Claim W) (w : W) : Models (singleton p) w ↔ p w := by + constructor + · intro h; exact h p rfl + · intro h q hq; cases hq; exact h +theorem modelsUnion {W : Type} (a b : Theory W) (w : W) : + Models (union a b) w ↔ Models a w ∧ Models b w := by + constructor + · intro h; exact ⟨fun p hp => h p (Or.inl hp), fun p hp => h p (Or.inr hp)⟩ + · rintro ⟨ha,hb⟩ p (hp|hp); exact ha p hp; exact hb p hp +/- The paired world records independent truth values for two questions. -/ +def premiseP : Claim (Bool × Bool) := fun w => w.1 = true +def premiseRule : Claim (Bool × Bool) := fun w => w.1 = true → w.2 = true +def premiseNotQ : Claim (Bool × Bool) := fun w => w.2 ≠ true +def jointTheory : Theory (Bool × Bool) := + union (singleton premiseP) (union (singleton premiseRule) (singleton premiseNotQ)) +/- Each premise has a model, but their joint implication makes the union unsatisfiable. -/ +/-- organon-map CoreReader.Logic.jointConflict +organon.charter.consistency#p1 sha256 c6960c590c096d33250599cf418e3c6a1dc26bfc7d7800c82b8efde656950f42 +-/ +theorem jointConflict : + Satisfiable (singleton premiseP) ∧ Satisfiable (singleton premiseRule) ∧ + Satisfiable (singleton premiseNotQ) ∧ ¬ Satisfiable jointTheory := by + refine ⟨⟨(true,true), (modelsSingleton _ _).2 rfl⟩, + ⟨(false,false), (modelsSingleton _ _).2 (by intro h; cases h)⟩, + ⟨(false,false), (modelsSingleton _ _).2 (by intro h; cases h)⟩, ?_⟩ + rintro ⟨w, hw⟩ + have hp := hw premiseP (Or.inl rfl) + have hr := hw premiseRule (Or.inr (Or.inl rfl)) + have hn := hw premiseNotQ (Or.inr (Or.inr rfl)) + exact hn (hr hp) +/- A retraction replaces the old singleton, rather than retaining both at the same time. -/ +def revisionSlice (time : Nat) : Theory Bool := + singleton (fun w => w = (time == 0)) +/- The initial and revised slices have models; keeping both would create a conflict. -/ +/-- organon-map CoreReader.Logic.revisionCanReverse +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem revisionCanReverse : + Satisfiable (revisionSlice 0) ∧ Satisfiable (revisionSlice 1) ∧ + ¬ Satisfiable (union (revisionSlice 0) (revisionSlice 1)) := by + refine ⟨⟨true, (modelsSingleton _ _).2 rfl⟩, + ⟨false, (modelsSingleton _ _).2 rfl⟩, ?_⟩ + rintro ⟨w, hw⟩ + have hs := (modelsUnion _ _ _).1 hw + have hp := (modelsSingleton _ _).1 hs.1 + have hn := (modelsSingleton _ _).1 hs.2 + have bad : true = false := hp.symm.trans hn + cases bad +/- This basic question asks whether the represented switch is on. -/ +def onQuestion : Unit → Claim Bool := fun _ w => w = true +def assumptionContext (b : Bool) : Context Bool Unit := + ⟨singleton (fun w => w = b), onQuestion, fun _ => True⟩ +def meaningContext (b : Bool) : Context Bool Unit := + ⟨singleton (fun w => w = true), (fun _ w => w = b), fun _ => True⟩ +def scopeContext (b : Bool) : Context Bool Unit := + ⟨emptyTheory, onQuestion, fun w => w = b⟩ +/- Distinct assumptions, meanings and scopes each admit opposite judgments without same-context conflict. -/ +/-- organon-map CoreReader.Logic.contextDifferences +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem contextDifferences : + (Consequence emptyTheory (assumptionContext true) () true ∧ + Consequence emptyTheory (assumptionContext false) () false) ∧ + (Consequence emptyTheory (meaningContext true) () true ∧ + Consequence emptyTheory (meaningContext false) () false) ∧ + (Consequence emptyTheory (scopeContext true) () true ∧ + Consequence emptyTheory (scopeContext false) () false) ∧ + (∀ b, ∃ w, Admissible emptyTheory (assumptionContext b) w) ∧ + (∀ b, ∃ w, Admissible emptyTheory (meaningContext b) w) ∧ + (∀ b, ∃ w, Admissible emptyTheory (scopeContext b) w) := by + have empty : ∀ w : Bool, Models emptyTheory w := by intro w p hp; cases hp + refine ⟨⟨?_, ?_⟩, ⟨?_, ?_⟩, ⟨?_, ?_⟩, ?_, ?_, ?_⟩ + · intro w h; change w = true; exact (modelsSingleton (fun x : Bool => x = true) w).1 h.2.1 + · intro w h hp; have hn := (modelsSingleton _ _).1 h.2.1; cases hp.symm.trans hn + · intro w h; change w = true; exact (modelsSingleton (fun x : Bool => x = true) w).1 h.2.1 + · intro w h hn; have hp := (modelsSingleton _ _).1 h.2.1; cases hp.symm.trans hn + · intro w h; exact h.2.2 + · intro w h hp; cases hp.symm.trans h.2.2 + · intro b; exact ⟨b, empty b, (modelsSingleton _ _).2 rfl, trivial⟩ + · intro b; exact ⟨true, empty true, (modelsSingleton _ _).2 rfl, trivial⟩ + · intro b; exact ⟨b, empty b, empty b, rfl⟩ +/- Snapshots preserve identifiable adopted-form revisions even when semantic content agrees. -/ +structure Snapshot (W Q : Type) where + held : Theory W + context : Context W Q + revisionIdentity : Nat +/- Semantic equivalence compares represented content, not its list ordering. -/ +def SameContent {W Q : Type} (a b : Snapshot W Q) : Prop := + (∀ p, a.held p ↔ b.held p) ∧ + (∀ p, a.context.assumptions p ↔ b.context.assumptions p) ∧ + (∀ q w, a.context.meaning q w ↔ b.context.meaning q w) ∧ + (∀ w, a.context.scope w ↔ b.context.scope w) +/- The reporting norm covers both semantic change and independently identified revisions. -/ +def TruthfulReport {W Q : Type} (a b : Snapshot W Q) (reported : Bool) : Prop := + (¬ SameContent a b ∨ a.revisionIdentity ≠ b.revisionIdentity) → reported = true +/- A real represented change and compliance entail an acknowledged change. -/ +/-- organon-map CoreReader.Logic.semanticChangeMustBeReported +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem semanticChangeMustBeReported {W Q : Type} (a b : Snapshot W Q) (reported : Bool) + (changed : ¬ SameContent a b ∨ a.revisionIdentity ≠ b.revisionIdentity) + (h : TruthfulReport a b reported) : reported = true := h changed +/- Reordering a two-claim presentation preserves the held theory extension. -/ +/-- organon-map CoreReader.Logic.representationOrderIrrelevant +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem representationOrderIrrelevant {W : Type} (p q : Claim W) : + ∀ r, union (singleton p) (singleton q) r ↔ union (singleton q) (singleton p) r := by + intro r; exact or_comm +def contextSnapshot (c : Context Bool Unit) (revision : Nat := 0) : Snapshot Bool Unit := + ⟨emptyTheory, c, revision⟩ +/- Hiding each kind of contextual change violates the reporting interface; reporting alone supplies no truth guarantee. -/ +/-- organon-map CoreReader.Logic.hiddenContextChangeRejected +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem hiddenContextChangeRejected : + ¬ TruthfulReport (contextSnapshot (assumptionContext true)) (contextSnapshot (assumptionContext false)) false ∧ + ¬ TruthfulReport (contextSnapshot (meaningContext true)) (contextSnapshot (meaningContext false)) false ∧ + ¬ TruthfulReport (contextSnapshot (scopeContext true)) (contextSnapshot (scopeContext false)) false ∧ + ¬ TruthfulReport (contextSnapshot (scopeContext true) 0) (contextSnapshot (scopeContext true) 1) false ∧ + (TruthfulReport (contextSnapshot (assumptionContext true)) (contextSnapshot (assumptionContext false)) true ∧ + ¬ Models (assumptionContext false).assumptions true) := by + have neq : (fun w : Bool => w = true) ≠ (fun w : Bool => w = false) := by + intro h; have k := congrFun h true; have z : true = false := k.mp rfl; cases z + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + have bad := h (Or.inl (by intro s; exact neq ((s.2.1 _).mp rfl))) + cases bad + · intro h + have bad := h (Or.inl (by intro s; have z := (s.2.2.1 () true).mp rfl; cases z)) + cases bad + · intro h + have bad := h (Or.inl (by intro s; have z := (s.2.2.2 true).mp rfl; cases z)) + cases bad + · intro h; have bad := h (Or.inr (by decide)); cases bad + · refine ⟨fun _ => rfl, ?_⟩ + intro h; have z := (modelsSingleton _ _).1 h; cases z +/- Two nonidentical resource objectives can share a feasible allocation. -/ +/-- organon-map CoreReader.Logic.tensionWithoutContradiction +organon.charter.consistency.limits#p1 sha256 4fa1c29bf95ad6ef04c6d27671a832c0af8ba31b9c0d8018a8d09c4f33c38e75 +-/ +theorem tensionWithoutContradiction : + (∃ budget : Nat, 4 ≤ budget ∧ budget ≤ 6) ∧ + ¬ ((fun n : Nat => 4 ≤ n) = (fun n : Nat => n ≤ 6)) := by + refine ⟨⟨5, by decide, by decide⟩, ?_⟩ + intro h; have k := congrFun h 0; have bad : 4 ≤ 0 := k.mpr (by decide); cases bad +/- Conflicting conclusions cannot be retained under the same consistency obligation. -/ +/-- organon-map CoreReader.Logic.conflictRequiresChange +organon.charter.consistency.limits#p1 sha256 4fa1c29bf95ad6ef04c6d27671a832c0af8ba31b9c0d8018a8d09c4f33c38e75 +-/ +theorem conflictRequiresChange {W Q : Type} (t : Theory W) (c : Context W Q) (q : Q) + (positive : Consequence t c q true) (negative : Consequence t c q false) : + ¬ Consistent t c := fun h => h q ⟨positive,negative⟩ +/- A satisfiable theory can have a false assumption at a specified actual world. -/ +/-- organon-map CoreReader.Logic.consistentFalse +organon.charter.consistency.limits#p1 sha256 4fa1c29bf95ad6ef04c6d27671a832c0af8ba31b9c0d8018a8d09c4f33c38e75 +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem consistentFalse : Satisfiable (singleton (fun w : Bool => w = true)) ∧ + ¬ Models (singleton (fun w : Bool => w = true)) false := by + refine ⟨⟨true, (modelsSingleton _ _).2 rfl⟩, ?_⟩ + intro h; have bad := (modelsSingleton _ _).1 h; cases bad +/- The explicitly asked on/off question is undecided by the empty but inhabited theory. -/ +/-- organon-map CoreReader.Logic.consistentIncomplete +organon.charter.consistency.limits#p1 sha256 4fa1c29bf95ad6ef04c6d27671a832c0af8ba31b9c0d8018a8d09c4f33c38e75 +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem consistentIncomplete : Satisfiable (emptyTheory : Theory Bool) ∧ + ¬ Entails emptyTheory (fun w : Bool => w = true) ∧ + ¬ Entails emptyTheory (fun w : Bool => w ≠ true) := by + have empty : ∀ w : Bool, Models emptyTheory w := by intro w p hp; cases hp + refine ⟨⟨true, empty true⟩, ?_, ?_⟩ + · intro h; have bad := h false (empty false); cases bad + · intro h; exact h true (empty true) rfl +/- A claim can share a model with a theory without following in every model. -/ +/-- organon-map CoreReader.Logic.compatibilityNotEntailment +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem compatibilityNotEntailment : + Satisfiable (union emptyTheory (singleton (fun w : Bool => w = true))) ∧ + ¬ Entails emptyTheory (fun w : Bool => w = true) := by + refine ⟨⟨true, (modelsUnion _ _ _).2 ⟨?_, (modelsSingleton _ _).2 rfl⟩⟩, + consistentIncomplete.2.1⟩ + intro p hp; cases hp + +end CoreReader.Logic +``` + + + + **L1** Open namespace CoreReader.Logic so subsequent declarations receive this module-qualified name. + + + **L3** Document the intended scope of Claim. The corresponding declaration concerns: A claim is a proposition-valued function on a supplied world type W; the world type is not restricted to a real-world interpretation. This comment is explanatory, not a proof premise. + + + **L4** Introduce the type abbreviation Claim. A claim is a proposition-valued function on a supplied world type W; the world type is not restricted to a real-world interpretation. + + + **L5** Document the intended scope of Theory. The corresponding declaration concerns: A theory is a predicate selecting claims, rather than a finite syntax or executable theory representation. This comment is explanatory, not a proof premise. + + + **L6** Introduce the type abbreviation Theory. A theory is a predicate selecting claims, rather than a finite syntax or executable theory representation. + + + **L7** Document the intended scope of Models. The corresponding declaration concerns: A world models a theory exactly when every selected claim holds at that world. This comment is explanatory, not a proof premise. + + + **L8** Define Models. A world models a theory exactly when every selected claim holds at that world. + + + **L9** Document the intended scope of Entails. The corresponding declaration concerns: Semantic entailment universally quantifies over worlds satisfying the theory. With no model it is vacuous. This comment is explanatory, not a proof premise. + + + **L10** Define Entails. Semantic entailment universally quantifies over worlds satisfying the theory. With no model it is vacuous. + + + **L11** Document the intended scope of Satisfiable. The corresponding declaration concerns: Satisfiability requires an actual witness world together with a proof that it models the theory. This comment is explanatory, not a proof premise. + + + **L12** Define Satisfiable. Satisfiability requires an actual witness world together with a proof that it models the theory. + + + **L13** Document the intended scope of Context. The corresponding declaration concerns: Packages contextual assumptions, question meanings, and a scope predicate; the interface does not validate these choices. This comment is explanatory, not a proof premise. + + + **L14** Declare the data interface Context. Packages contextual assumptions, question meanings, and a scope predicate; the interface does not validate these choices. + + + **L15** Store the actual contextual assumption theory, separately from the held theory. + + + **L16** Interpret each question as a proposition about each world. + + + **L17** Store the predicate selecting the admitted application scope. + + + **L18** Document the intended scope of Admissible. The corresponding declaration concerns: A world is admissible when the held theory, contextual assumptions, and scope all hold simultaneously. This comment is explanatory, not a proof premise. + + + **L19** Define Admissible. A world is admissible when the held theory, contextual assumptions, and scope all hold simultaneously. + + + **L20** Require this same world to model both theories and satisfy the contextual scope simultaneously. + + + **L21** Document the intended scope of Consequence. The corresponding declaration concerns: A signed consequence must hold in every admissible world: positive selects the question meaning and negative selects its negation. This comment is explanatory, not a proof premise. + + + **L22** Define Consequence. A signed consequence must hold in every admissible world: positive selects the question meaning and negative selects its negation. + + + **L23** Quantify over every admissible world; the sign selects either this question’s meaning or its negation. + + + **L24** Document the intended scope of Consistent. The corresponding declaration concerns: Consistency rules out simultaneously entailing a question and its negation for every question in Q. Empty Q makes this condition vacuous. This comment is explanatory, not a proof premise. + + + **L25** Define Consistent. Consistency rules out simultaneously entailing a question and its negation for every question in Q. Empty Q makes this condition vacuous. + + + **L26** For every question, prohibit the conjunction of its positive and negative consequences in this same context. + + + **L27** Document the intended scope of consequenceConsistency. The corresponding declaration concerns: Given an admissible witness, proves that no question can have both signed consequences. The witness is an explicit premise. This comment is explanatory, not a proof premise. + + + **L28** Begin provenance metadata for CoreReader.Logic.consequenceConsistency; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L29** Register source unit organon.charter.consistency#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L30** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L31** State the checked result consequenceConsistency. Given an admissible witness, proves that no question can have both signed consequences. The witness is an explicit premise. + + + **L32** Assume an admissible witness for the whole context and conclude its consistency; begin the proof. + + + **L33** Introduce an arbitrary question q and the hypothetical pair h of its positive and negative consequences in the same context. + + + **L34** Extract the common admissible world w and its entire theory/assumptions/scope proof hw from the explicit inhabited premise. + + + **L35** Evaluate both halves of h at the same w and hw; the negative consequence contradicts the positive consequence. + + + **L36** Document the intended scope of emptyTheory. The corresponding declaration concerns: Selects no claims, so every world models this theory. This comment is explanatory, not a proof premise. + + + **L37** Define emptyTheory. Selects no claims, so every world models this theory. + + + **L38** Define singleton. Selects exactly the claim equal to p; this uses equality of predicate functions. + + + **L39** Define union. Combines two sets of claims by disjunction of membership. + + + **L40** State the checked result modelsSingleton. Proves that modeling the singleton theory is equivalent to satisfying its sole claim. The following tactic block proves this explicit type. + + + **L41** Split the equivalence between satisfying the singleton theory and satisfying its sole claim into two implications. + + + **L42** Use the assumed singleton model h on p, whose membership follows from reflexive equality. + + + **L43** For any selected claim q, singleton membership identifies q with p; substitute that identity and return the assumed truth h of p. + + + **L44** State the checked result modelsUnion. Proves that modeling the union is equivalent to modeling both constituent theories at the same world. + + + **L45** State that the same world models the theory union exactly when it models both constituent theories. + + + **L46** Prove the model-of-union equivalence in its forward and reverse directions. + + + **L47** Restrict the union model h to each theory by embedding its membership proof into the left or right disjunct. + + + **L48** Unpack both constituent models, split a union membership into its two alternatives, and use the corresponding model on the same claim and world. + + + **L49** Document the intended scope of premiseP. The corresponding declaration concerns: Reads the first Boolean coordinate as true. This comment is explanatory, not a proof premise. + + + **L50** Define premiseP. Reads the first Boolean coordinate as true. + + + **L51** Define premiseRule. Makes truth of the first Boolean imply truth of the second. + + + **L52** Define premiseNotQ. Requires the second Boolean not to be true. + + + **L53** Define jointTheory. Combines the first-coordinate fact, the implication, and the negated second-coordinate fact. + + + **L54** Hold P, the rule P implies Q, and not Q together through nested theory unions. + + + **L55** Document the intended scope of jointConflict. The corresponding declaration concerns: Exhibits individual models of each of three claims, then proves their conjunction has no model. This comment is explanatory, not a proof premise. + + + **L56** Begin provenance metadata for CoreReader.Logic.jointConflict; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L57** Register source unit organon.charter.consistency#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L58** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L59** State the checked result jointConflict. Exhibits individual models of each of three claims, then proves their conjunction has no model. + + + **L60** The first two conclusions provide separate models for P and its implication rule. + + + **L61** Also require a separate model for not Q, but deny any model of the entire joint theory. + + + **L62** Supply (true,true) as the model of P, using modelsSingleton to turn its first-coordinate equality into the required model proof. + + + **L63** Supply (false,false) for the implication premise: assuming its false first coordinate is true is impossible. + + + **L64** Supply (false,false) for not Q and leave the joint unsatisfiability branch to be proved. + + + **L65** Assume a joint model w with proof hw in order to refute its existence. + + + **L66** Extract the actual first-coordinate fact P from its left membership in the joint theory. + + + **L67** Extract P implies Q from the nested union membership of the rule. + + + **L68** Extract not Q from the other nested union branch at the same world. + + + **L69** Apply the rule to P to derive Q and contradict the extracted not Q. + + + **L70** Document the intended scope of revisionSlice. The corresponding declaration concerns: At time zero requires a true world; at every other natural time requires a false world. This comment is explanatory, not a proof premise. + + + **L71** Define revisionSlice. At time zero requires a true world; at every other natural time requires a false world. + + + **L72** Select the single claim that the world equals the Boolean result of testing time=0. + + + **L73** Document the intended scope of revisionCanReverse. The corresponding declaration concerns: Exhibits satisfiable time-zero and time-one slices whose union is unsatisfiable. No temporal update mechanism is implemented. This comment is explanatory, not a proof premise. + + + **L74** Begin provenance metadata for CoreReader.Logic.revisionCanReverse; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L75** Register source unit organon.charter.consistency.meaning#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L76** Register source unit organon.charter.consistency.meaning#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L77** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L78** State the checked result revisionCanReverse. Exhibits satisfiable time-zero and time-one slices whose union is unsatisfiable. No temporal update mechanism is implemented. + + + **L79** Require time slices 0 and 1 to have separate model witnesses. + + + **L80** Deny a model of their simultaneous union; this does not deny either separate witness. + + + **L81** Give true as the witness for the time-zero singleton theory. + + + **L82** Give false as the witness for time one, and leave the impossibility of holding both slices together. + + + **L83** Assume a world satisfies both time slices simultaneously. + + + **L84** Split this union model into models of the time-zero and time-one theories at the same world. + + + **L85** Extract that the common world equals true from the time-zero singleton. + + + **L86** Extract that the same world equals false from the time-one singleton. + + + **L87** Compose the two equalities through the same world to derive the impossible equality true = false. + + + **L88** Eliminate the impossible equality between distinct Boolean constructors. + + + **L89** Document the intended scope of onQuestion. The corresponding declaration concerns: The sole Unit question asks whether the Boolean world is true. This comment is explanatory, not a proof premise. + + + **L90** Define onQuestion. The sole Unit question asks whether the Boolean world is true. + + + **L91** Define assumptionContext. Varies the assumption selecting the world while fixing its question meaning and unrestricted scope. + + + **L92** Select world b through assumptions, retain the same on-question, and allow every world in scope. + + + **L93** Define meaningContext. Fixes the world assumption to true but varies whether the question means equality to true or false. + + + **L94** Keep the true-world assumption while changing the question to equality with b; scope remains unrestricted. + + + **L95** Define scopeContext. Keeps assumptions empty and the question fixed while selecting the world through scope. + + + **L96** Leave assumptions empty and the question fixed, but let scope select world b. + + + **L97** Document the intended scope of contextDifferences. The corresponding declaration concerns: Proves that changing any one of assumptions, meaning, or scope can reverse polarity, with explicit admissible witnesses in all displayed contexts. This comment is explanatory, not a proof premise. + + + **L98** Begin provenance metadata for CoreReader.Logic.contextDifferences; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L99** Register source unit organon.charter.consistency.meaning#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L100** Register source unit organon.charter.consistency.meaning#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L101** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L102** State the checked result contextDifferences. Proves that changing any one of assumptions, meaning, or scope can reverse polarity, with explicit admissible witnesses in all displayed contexts. + + + **L103** Require a positive answer under true-valued assumptions. + + + **L104** Require the negative answer under false-valued assumptions; the contexts differ. + + + **L105** Require a positive answer for the question meaning equality to true. + + + **L106** Require the negative answer when that question instead means equality to false. + + + **L107** Require the positive answer in the scope restricted to true. + + + **L108** Require the negative answer in the different scope restricted to false. + + + **L109** For either assumption selector, require an actual admissible world. + + + **L110** For either question meaning, require an actual admissible world. + + + **L111** For either scope selector, require an actual admissible world and begin the combined proof. + + + **L112** Show every Boolean world satisfies emptyTheory because membership in that theory is False. + + + **L113** Separate the positive/negative answer pairs for changed assumptions, meaning and scope, then the three nonempty-context witness obligations. + + + **L114** For the true-assumption context, read w = true from the contextual singleton assumptions. + + + **L115** For the false-assumption context, a proposed positive answer contradicts the singleton assumption w = false. + + + **L116** For the true meaning of the question, use the fixed true-world assumption to establish the positive answer. + + + **L117** For the changed false meaning, its proposed truth conflicts with the unchanged true-world assumption. + + + **L118** In the true-scope context, the scope component itself states the required positive answer. + + + **L119** In the false-scope context, a positive answer contradicts the scope component at the same world. + + + **L120** For either chosen assumption b, witness world b satisfies the empty held theory, that singleton assumption and unrestricted scope. + + + **L121** For either question meaning b, true remains a witness because the assumptions are fixed to true and scope is unrestricted. + + + **L122** For either scope selector b, world b satisfies both empty theories and the selected scope by equality. + + + **L123** Document the intended scope of Snapshot. The corresponding declaration concerns: Packages held claims, context and a natural-number revision identity; there is no history validation. This comment is explanatory, not a proof premise. + + + **L124** Declare the data interface Snapshot. Packages held claims, context and a natural-number revision identity; there is no history validation. + + + **L125** Store the theory of simultaneously held claims in the snapshot. + + + **L126** Store the snapshot’s assumptions, question meanings and scope as one Context. + + + **L127** Store a separate natural-number revision identifier; no history validation is implied. + + + **L128** Document the intended scope of SameContent. The corresponding declaration concerns: Defines sameness using claim-membership equivalence, contextual-assumption membership equivalence, pointwise meaning equivalence, and pointwise scope equivalence. This comment is explanatory, not a proof premise. + + + **L129** Define SameContent. Defines sameness using claim-membership equivalence, contextual-assumption membership equivalence, pointwise meaning equivalence, and pointwise scope equivalence. + + + **L130** Require identical held-claim membership for every claim in both snapshots. + + + **L131** Require identical membership for every contextual assumption. + + + **L132** Require equivalent question meanings for every question at every world. + + + **L133** Require equivalent scope predicates at every world. + + + **L134** Document the intended scope of TruthfulReport. The corresponding declaration concerns: Requires a true report if semantic content or revision identity differs. It allows a true report when neither differs and implements no detector. This comment is explanatory, not a proof premise. + + + **L135** Define TruthfulReport. Requires a true report if semantic content or revision identity differs. It allows a true report when neither differs and implements no detector. + + + **L136** Define truthful reporting as a positive flag whenever content differs or the independent revision identifiers differ. + + + **L137** Document the intended scope of semanticChangeMustBeReported. The corresponding declaration concerns: Instantiates the reporting interface with a supplied change proof; it cannot discover changes on its own. This comment is explanatory, not a proof premise. + + + **L138** Begin provenance metadata for CoreReader.Logic.semanticChangeMustBeReported; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L139** Register source unit organon.charter.consistency.meaning#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L140** Register source unit organon.charter.consistency.meaning#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L141** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L142** State the checked result semanticChangeMustBeReported. Instantiates the reporting interface with a supplied change proof; it cannot discover changes on its own. + + + **L143** Assume an actual change: either content differs or the revision identifiers differ. + + + **L144** Assume the reporting obligation and apply it to the preceding change premise to obtain reported=true. + + + **L145** Document the intended scope of representationOrderIrrelevant. The corresponding declaration concerns: Proves swapping the order of two singleton components leaves theory membership unchanged. This comment is explanatory, not a proof premise. + + + **L146** Begin provenance metadata for CoreReader.Logic.representationOrderIrrelevant; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L147** Register source unit organon.charter.consistency.meaning#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L148** Register source unit organon.charter.consistency.meaning#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L149** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L150** State the checked result representationOrderIrrelevant. Proves swapping the order of two singleton components leaves theory membership unchanged. + + + **L151** For any claim r, swapping p and q preserves membership in their singleton-theory union. + + + **L152** For an arbitrary candidate claim r, use commutativity of disjunction to preserve union membership after reordering p and q. + + + **L153** Define contextSnapshot. Wraps a Boolean/Unit context in a snapshot with empty held theory and a default revision of zero. + + + **L154** Construct a snapshot with no held claims, the supplied context, and the supplied revision identifier. + + + **L155** Document the intended scope of hiddenContextChangeRejected. The corresponding declaration concerns: Rejects false reports for three concrete context changes and a revision-only change; also shows reporting true does not make an incompatible assumption hold. This comment is explanatory, not a proof premise. + + + **L156** Begin provenance metadata for CoreReader.Logic.hiddenContextChangeRejected; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L157** Register source unit organon.charter.consistency.meaning#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L158** Register source unit organon.charter.consistency.meaning#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L159** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L160** State the checked result hiddenContextChangeRejected. Rejects false reports for three concrete context changes and a revision-only change; also shows reporting true does not make an incompatible assumption hold. + + + **L161** Reject a false report when actual contextual assumptions change from true to false. + + + **L162** Reject a false report when the question’s actual meaning changes. + + + **L163** Reject a false report when the actual application scope changes. + + + **L164** Reject a false report when revision identity changes from 0 to 1 despite unchanged context. + + + **L165** Permit truthful acknowledgement of the changed assumptions with a true report. + + + **L166** Nevertheless deny that those revised false-world assumptions hold at actual true. + + + **L167** Prepare a semantic inequality: the predicates selecting true and selecting false are distinct functions. + + + **L168** Evaluate any alleged predicate equality at true; it would turn reflexive truth into true = false. + + + **L169** Split the four rejected hidden changes from the final acknowledged-but-false-assumption example. + + + **L170** Assume the hidden assumption change with report=false satisfied TruthfulReport, in order to refute that claim. + + + **L171** A claimed SameContent would equate the changed assumption predicates; their established inequality activates TruthfulReport and forces the false flag to be true. + + + **L172** Close this hidden-change branch because the required true report contradicts the specified false flag. + + + **L173** Assume the changed question meaning could be truthfully reported as unchanged. + + + **L174** At the sole question and world true, the changed meaning contradicts SameContent; the reporting obligation then forces a positive report. + + + **L175** Close this hidden-change branch because the required true report contradicts the specified false flag. + + + **L176** Assume the changed application scope could satisfy the reporting rule with a false change flag. + + + **L177** Compare the two scopes at true to refute SameContent, then apply the reporting obligation to this real scope change. + + + **L178** Close this hidden-change branch because the required true report contradicts the specified false flag. + + + **L179** The distinct revision identities alone activate the reporting rule, contradicting the false report even without a content change. + + + **L180** Construct an always-positive truthful report, while leaving the separate truth of the revised assumption to be refuted. + + + **L181** Extract the revised false-world assumption at actual true; its impossible equality shows acknowledgement did not make it true. + + + **L182** Document the intended scope of tensionWithoutContradiction. The corresponding declaration concerns: Exhibits overlapping lower/upper budget bounds while proving that the two predicates differ. This is a concrete compatible-constraints example. This comment is explanatory, not a proof premise. + + + **L183** Begin provenance metadata for CoreReader.Logic.tensionWithoutContradiction; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L184** Register source unit organon.charter.consistency.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L185** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L186** State the checked result tensionWithoutContradiction. Exhibits overlapping lower/upper budget bounds while proving that the two predicates differ. This is a concrete compatible-constraints example. + + + **L187** Ask for a natural-number budget satisfying both lower bound 4 and upper bound 6. + + + **L188** Also assert that the two bound predicates are not identical, even though jointly satisfiable. + + + **L189** Choose budget 5, check both numeric bounds, and leave the inequality of the two objective predicates. + + + **L190** At budget 0, the upper bound holds but the lower bound cannot; therefore the objective predicates cannot be equal. + + + **L191** Document the intended scope of conflictRequiresChange. The corresponding declaration concerns: Given both signed consequences for one question, proves inconsistency as defined. It does not construct a repair or establish which premise should change. This comment is explanatory, not a proof premise. + + + **L192** Begin provenance metadata for CoreReader.Logic.conflictRequiresChange; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L193** Register source unit organon.charter.consistency.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L194** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L195** State the checked result conflictRequiresChange. Given both signed consequences for one question, proves inconsistency as defined. It does not construct a repair or establish which premise should change. + + + **L196** Assume both opposed consequences for exactly the same theory, context and question. + + + **L197** Any Consistent proof would forbid that given pair; apply it to refute consistency, without constructing a revision. + + + **L198** Document the intended scope of consistentFalse. The corresponding declaration concerns: Exhibits a satisfiable Boolean singleton theory that fails at the separately chosen world false; satisfiability is not truth at every world. This comment is explanatory, not a proof premise. + + + **L199** Begin provenance metadata for CoreReader.Logic.consistentFalse; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L200** Register source unit organon.charter.consistency.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L201** Register source unit organon.relationships.roles#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L202** Register source unit organon.relationships.roles#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L203** Register source unit organon.relationships.roles#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L204** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L205** State the checked result consistentFalse. Exhibits a satisfiable Boolean singleton theory that fails at the separately chosen world false; satisfiability is not truth at every world. + + + **L206** Deny that actual false models the theory whose sole claim is world=true. + + + **L207** Provide true as a model of the singleton theory and separately refute modeling it at actual false. + + + **L208** Singleton modeling at false would force false = true, an impossible Boolean equality. + + + **L209** Document the intended scope of consistentIncomplete. The corresponding declaration concerns: Shows the empty Boolean theory is satisfiable while entailing neither the true-world claim nor its negation. This comment is explanatory, not a proof premise. + + + **L210** Begin provenance metadata for CoreReader.Logic.consistentIncomplete; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L211** Register source unit organon.charter.consistency.limits#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L212** Register source unit organon.relationships.roles#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L213** Register source unit organon.relationships.roles#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L214** Register source unit organon.relationships.roles#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L215** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L216** State the checked result consistentIncomplete. Shows the empty Boolean theory is satisfiable while entailing neither the true-world claim nor its negation. + + + **L217** The inhabited empty theory does not entail the positive true-world answer. + + + **L218** It also does not entail the negative true-world answer; prove these two failures separately. + + + **L219** Show every Boolean world satisfies emptyTheory because membership in that theory is False. + + + **L220** Provide an inhabited empty theory and leave both positive and negative entailments to be refuted. + + + **L221** A purported entailment of world=true fails at the empty theory model false. + + + **L222** A purported entailment of world≠true fails at the empty theory model true. + + + **L223** Document the intended scope of compatibilityNotEntailment. The corresponding declaration concerns: Shows that adding a claim can remain satisfiable even though the original empty theory did not entail that claim. This comment is explanatory, not a proof premise. + + + **L224** Begin provenance metadata for CoreReader.Logic.compatibilityNotEntailment; the mapping identifies the source-correspondence object, not a Lean premise or correctness certificate. + + + **L225** Register source unit organon.grounds.assessment#p1 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L226** Register source unit organon.grounds.assessment#p2 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L227** Register source unit organon.grounds.assessment#p3 with the displayed SHA-256 content identity. This is traceability metadata, not part of the theorem’s proof. + + + **L228** Close the preceding documentation/provenance comment; no executable or logical clause is added. + + + **L229** State the checked result compatibilityNotEntailment. Shows that adding a claim can remain satisfiable even though the original empty theory did not entail that claim. + + + **L230** Require a model where emptyTheory and the positive singleton claim hold together. + + + **L231** Still deny that emptyTheory by itself entails that positive claim. + + + **L232** Use world true to witness compatibility of the empty theory with the positive singleton claim. + + + **L233** Reuse the previously proved failure of positive entailment from the empty theory. + + + **L234** Finish the model witness: no claim can actually belong to emptyTheory. + + + **L236** Close namespace CoreReader.Logic; this adds no proof or premise. + + +### `leanified/CoreReader/Reflexivity.lean` + + +```lean +import Std + +namespace CoreReader.Agency + +inductive Phase | formation | application | revision + deriving DecidableEq, Repr + +structure PrincipleKey where + owner : Nat + localId : Nat + deriving DecidableEq, Repr + +inductive Subject + | system (owner : Nat) + | principle (owner id : Nat) + | process (owner id : Nat) (phase : Phase) + deriving DecidableEq, Repr + +def Subject.owner : Subject → Nat + | .system n => n + | .principle n _ => n + | .process n _ _ => n + +inductive Activity | generation | assessment + deriving DecidableEq, Repr + +inductive QuestionKind | conformity | formationBasis | applicability | revisionGrounds + deriving DecidableEq, Repr + +inductive SampleProgram | alwaysTrue | onlyAtZero + deriving DecidableEq, Repr + +def SampleProgram.run : SampleProgram → Nat → Bool + | .alwaysTrue, _ => true + | .onlyAtZero, n => n == 0 + +/- A generated candidate specifies both the inputs it tests and the scope it proposes to license. -/ +structure MethodDraft where + testedInputs : List Nat + claimedScope : List Nat + deriving DecidableEq, Repr + +def MethodDraft.accepts (draft : MethodDraft) (program : SampleProgram) : Bool := + draft.testedInputs.all program.run + +/- This finite application asks whether a proposed rule's observed inputs support its claimed input scope. -/ +structure Inquiry where + target : Subject + kind : QuestionKind + requestedScope : List Nat + currentMethod : MethodDraft + deriving DecidableEq, Repr + +inductive ReasonContent + | purpose (inputs : List Nat) + | declaredScope (inputs : List Nat) + | observation (input : Nat) (output : Bool) + | counterexample (program : SampleProgram) (input : Nat) + deriving DecidableEq, Repr + +def ReasonContent.identifier : ReasonContent → Nat + | .purpose _ => 0 + | .declaredScope _ => 1 + | .observation _ _ => 2 + | .counterexample _ _ => 3 + +/- Reasons have independently supplied contents, a stable local reference and the actual target they concern. -/ +structure ReasonObject where + reference : Nat + target : Subject + content : ReasonContent + deriving DecidableEq, Repr + +inductive AssessmentResult | supportedWithinScope | insufficient | notApplicable | undetermined + deriving DecidableEq, Repr + +inductive WorkOutcome + | assessment (result : AssessmentResult) + | generated (draft : MethodDraft) + deriving DecidableEq, Repr + +/- A method's question, source reasons and limits are determined before looking at its activity records. +The meaning relation describes application of that method, not its universal adequacy. -/ +structure Principle where + key : PrincipleKey + activity : Activity + declaredMethod : MethodDraft + applicable : Subject → Prop + inquiry : Subject → Inquiry + reasons : Subject → List ReasonObject + limits : Subject → List Nat + meaning : Inquiry → List ReasonObject → List Nat → WorkOutcome → Prop + +structure WorkRecord where + usedPrinciple : PrincipleKey + target : Subject + activity : Activity + inquiry : Inquiry + reasons : List ReasonObject + limits : List Nat + outcome : WorkOutcome + deriving DecidableEq, Repr + +def RegistryCoherent (rules : List Principle) : Prop := + ∀ p ∈ rules, ∀ q ∈ rules, p.key = q.key → p = q + +def TargetResolved (rules : List Principle) : Subject → Prop + | .system owner => ∃ p ∈ rules, p.key.owner = owner + | .principle owner id | .process owner id _ => ∃ p ∈ rules, p.key = ⟨owner,id⟩ + +/- The inquiry names the registered target's declared method contract, not an unrelated candidate. +For a system inquiry this finite model uses the registered generation contract as its assessed artifact. -/ +def TargetContentResolved (rules : List Principle) (question : Inquiry) : Prop := + match question.target with + | .system owner => ∃ p ∈ rules, p.key = ⟨owner,0⟩ ∧ question.currentMethod = p.declaredMethod + | .principle owner id | .process owner id _ => + ∃ p ∈ rules, p.key = ⟨owner,id⟩ ∧ question.currentMethod = p.declaredMethod + +def Performed (records : List WorkRecord) (s : Subject) (a : Activity) : Prop := + ∃ record ∈ records, record.target = s ∧ record.activity = a + +/- The old scope condition remains available without conflating scope with content completion. -/ +def ReflexiveScope (owner : Nat) (rules : List Principle) (records : List WorkRecord) : Prop := + ∀ rule ∈ rules, ∀ s, s.owner = owner → rule.applicable s → Performed records s rule.activity + +/- A record uses a registered principle on the same resolvable target, question, reasons and limits, +and its result must actually follow that principle's method. A negative result can satisfy this relation. -/ +structure ValidApplication (rules : List Principle) (rule : Principle) (s : Subject) + (record : WorkRecord) : Prop where + registered : rule ∈ rules + applicable : rule.applicable s + usedIdentity : record.usedPrinciple = rule.key + targetIdentity : record.target = s + targetResolved : TargetResolved rules s + activityIdentity : record.activity = rule.activity + inquiryIdentity : record.inquiry = rule.inquiry s + inquiryTarget : record.inquiry.target = s + targetContent : TargetContentResolved rules record.inquiry + reasonsIdentity : record.reasons = rule.reasons s + reasonsNonempty : record.reasons ≠ [] + reasonTargets : ∀ reason ∈ record.reasons, reason.target = s + limitsIdentity : record.limits = rule.limits s + followsMeaning : rule.meaning record.inquiry record.reasons record.limits record.outcome + +/- The registered normative interface requires contentful application, not just activity labels. -/ +/-- organon-map CoreReader.Agency.Reflexive +organon.charter.reflexivity#p1 sha256 13293b45c2fa89068c68ae7ef3c5df38f0efadb3ef3873d78a5ba67d9691a757 +organon.charter.reflexivity.meaning#p1 sha256 8a2caede01a43d8b6c60b54c78ac089c51868e9956f316948077ccee2e45c9cc +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +def Reflexive (owner : Nat) (rules : List Principle) (records : List WorkRecord) : Prop := + RegistryCoherent rules ∧ + ∀ rule ∈ rules, ∀ s, s.owner = owner → rule.applicable s → + ∃ record ∈ records, ValidApplication rules rule s record + +theorem Reflexive.toScope {owner : Nat} {rules : List Principle} {records : List WorkRecord} + (h : Reflexive owner rules records) : ReflexiveScope owner rules records := by + intro rule hr s hs ha + obtain ⟨record, hm, hv⟩ := h.2 rule hr s hs ha + exact ⟨record, hm, hv.targetIdentity, hv.activityIdentity⟩ + +/-- organon-map CoreReader.Agency.noSelfExemption +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +theorem noSelfExemption (owner : Nat) (rules : List Principle) (records : List WorkRecord) + (h : Reflexive owner rules records) (rule : Principle) (hr : rule ∈ rules) + (s : Subject) (hs : s.owner = owner) (ha : rule.applicable s) : + Performed records s rule.activity := h.toScope rule hr s hs ha + +def localMethod : MethodDraft := ⟨[0],[0]⟩ + +def inquiryFor (s : Subject) : Inquiry := + match s with + | .process _ _ .formation => ⟨s, .formationBasis, [0], localMethod⟩ + | .process _ _ .application => ⟨s, .applicability, [0], localMethod⟩ + | .process _ _ .revision => ⟨s, .revisionGrounds, [0,1], localMethod⟩ + | _ => ⟨s, .conformity, [0], localMethod⟩ + +/- These original inquiry inputs do not depend on which work records happen to be present. -/ +def sourceReasonContents : QuestionKind → List ReasonContent + | .formationBasis => [.purpose [0], .declaredScope [0], .observation 0 true] + | .applicability | .conformity => [.declaredScope [0], .observation 0 true] + | .revisionGrounds => [.purpose [0,1], .declaredScope [0], .observation 0 true, + .counterexample .onlyAtZero 1] + +def reasonsFor (s : Subject) : List ReasonObject := + (sourceReasonContents (inquiryFor s).kind).map fun content => ⟨content.identifier,s,content⟩ + +/- The application-specific evaluator examines actual scope and sample/counterexample contents. +It is a finite inferential method, not a universal standard for empirical or value claims. -/ +def assessInquiry (question : Inquiry) (reasons : List ReasonObject) (limits : List Nat) : AssessmentResult := + let contents := reasons.map ReasonObject.content + if limits ≠ question.currentMethod.claimedScope then .undetermined else + match question.kind with + | .formationBasis => + if ReasonContent.purpose question.requestedScope ∈ contents ∧ + ReasonContent.declaredScope limits ∈ contents ∧ question.requestedScope = limits + then .supportedWithinScope else .undetermined + | .applicability | .conformity => + if question.requestedScope.all (fun n => limits.contains n) then + if ReasonContent.declaredScope limits ∈ contents ∧ + ReasonContent.observation 0 true ∈ contents ∧ question.requestedScope = [0] + then .supportedWithinScope else .undetermined + else .notApplicable + | .revisionGrounds => + if ReasonContent.purpose question.requestedScope ∈ contents ∧ + ReasonContent.declaredScope limits ∈ contents ∧ + ReasonContent.observation 0 true ∈ contents ∧ + contents.any (fun reason => match reason with + | .counterexample program input => question.requestedScope.contains input && + question.currentMethod.accepts program && + !(program.run input) + | _ => false) + then .insufficient else .undetermined + +def finiteMethodResult (activity : Activity) (question : Inquiry) + (reasons : List ReasonObject) (limits : List Nat) : WorkOutcome := + match activity with + | .generation => .generated ⟨question.currentMethod.testedInputs,question.requestedScope⟩ + | .assessment => .assessment (assessInquiry question reasons limits) + +def finiteMethodMeaning (activity : Activity) (question : Inquiry) + (reasons : List ReasonObject) (limits : List Nat) (outcome : WorkOutcome) : Prop := + outcome = finiteMethodResult activity question reasons limits + +def ownSubjects (owner : Nat) : List Subject := + [.system owner, .principle owner 0, .principle owner 1, + .process owner 0 .formation, .process owner 0 .application, .process owner 0 .revision, + .process owner 1 .formation, .process owner 1 .application, .process owner 1 .revision] + +/- Applying an existing rule is not a generation event in this application. -/ +def generationEligible : Subject → Bool + | .process _ _ .application => false + | _ => true + +def generatingRule (owner : Nat) : Principle where + key := ⟨owner,0⟩ + activity := .generation + declaredMethod := localMethod + applicable s := s ∈ ownSubjects owner ∧ generationEligible s = true + inquiry := inquiryFor + reasons := reasonsFor + limits _ := [0] + meaning := finiteMethodMeaning .generation + +def assessingRule (owner : Nat) : Principle where + key := ⟨owner,1⟩ + activity := .assessment + declaredMethod := localMethod + applicable s := s ∈ ownSubjects owner + inquiry := inquiryFor + reasons := reasonsFor + limits _ := [0] + meaning := finiteMethodMeaning .assessment + +def ownRules (owner : Nat) : List Principle := [generatingRule owner, assessingRule owner] + +/- Recorded verdicts are stated separately from the evaluator, so agreement has to be proved. -/ +def statedOutcome (activity : Activity) (s : Subject) : WorkOutcome := + match activity with + | .generation => .generated ⟨(inquiryFor s).currentMethod.testedInputs,(inquiryFor s).requestedScope⟩ + | .assessment => .assessment (match (inquiryFor s).kind with + | .revisionGrounds => .insufficient + | _ => .supportedWithinScope) + +def recordFor (rule : Principle) (s : Subject) : WorkRecord := + ⟨rule.key,s,rule.activity,rule.inquiry s,rule.reasons s,rule.limits s,statedOutcome rule.activity s⟩ + +theorem reasonsFor_nonempty (s : Subject) : reasonsFor s ≠ [] := by + cases s with + | system owner => simp [reasonsFor, inquiryFor, sourceReasonContents] + | principle owner id => simp [reasonsFor, inquiryFor, sourceReasonContents] + | process owner id phase => cases phase <;> simp [reasonsFor, inquiryFor, sourceReasonContents] + +theorem reasonsFor_target (s : Subject) : ∀ reason ∈ reasonsFor s, reason.target = s := by + intro reason h + obtain ⟨content, _, rfl⟩ := List.mem_map.mp h + rfl + +theorem inquiryFor_target (s : Subject) : (inquiryFor s).target = s := by + cases s with + | system owner => rfl + | principle owner id => rfl + | process owner id phase => cases phase <;> rfl + +/- This proof includes the actual negative revision evaluation for both principle identities. -/ +theorem ownContentEvaluates (activity : Activity) (s : Subject) : + statedOutcome activity s = finiteMethodResult activity (inquiryFor s) (reasonsFor s) [0] := by + cases activity with + | generation => rfl + | assessment => + cases s with + | system owner => rfl + | principle owner id => rfl + | process owner id phase => cases phase <;> rfl + +theorem ownRegistryCoherent (owner : Nat) : RegistryCoherent (ownRules owner) := by + intro p hp q hq hkey + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hp hq + rcases hp with rfl | rfl <;> rcases hq with rfl | rfl + · rfl + · have bad := congrArg PrincipleKey.localId hkey; contradiction + · have bad := congrArg PrincipleKey.localId hkey; contradiction + · rfl + +theorem ownTargetResolved (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) : + TargetResolved (ownRules owner) s := by + simp only [ownSubjects, List.mem_cons, List.not_mem_nil, or_false] at hs + rcases hs with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + simp [TargetResolved, ownRules, generatingRule, assessingRule] + +theorem ownTargetContent (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) : + TargetContentResolved (ownRules owner) (inquiryFor s) := by + simp only [ownSubjects, List.mem_cons, List.not_mem_nil, or_false] at hs + rcases hs with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + simp [TargetContentResolved, inquiryFor, ownRules, generatingRule, assessingRule] + +theorem ownRecordValid (owner : Nat) (rule : Principle) (hr : rule ∈ ownRules owner) + (s : Subject) (ha : rule.applicable s) : + ValidApplication (ownRules owner) rule s (recordFor rule s) := by + have hs : s ∈ ownSubjects owner := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl + · exact ha.1 + · exact ha + have hq : rule.inquiry = inquiryFor := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl <;> rfl + have hg : rule.reasons = reasonsFor := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl <;> rfl + have hl : rule.limits s = [0] := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl <;> rfl + have hm : rule.meaning = finiteMethodMeaning rule.activity := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl <;> rfl + refine ⟨hr, ha, rfl, rfl, ownTargetResolved owner s hs, rfl, rfl, ?_, ?_, rfl, ?_, ?_, rfl, ?_⟩ + · change (rule.inquiry s).target = s + rw [hq]; exact inquiryFor_target s + · change TargetContentResolved (ownRules owner) (rule.inquiry s) + rw [hq]; exact ownTargetContent owner s hs + · change rule.reasons s ≠ [] + rw [hg]; exact reasonsFor_nonempty s + · change ∀ reason ∈ rule.reasons s, reason.target = s + rw [hg]; exact reasonsFor_target s + · change rule.meaning (rule.inquiry s) (rule.reasons s) (rule.limits s) (statedOutcome rule.activity s) + rw [hm, hq, hg, hl] + exact ownContentEvaluates rule.activity s + +def completeOwnWork (owner : Nat) : List WorkRecord := + (ownSubjects owner).flatMap fun s => + if generationEligible s then [recordFor (generatingRule owner) s, recordFor (assessingRule owner) s] + else [recordFor (assessingRule owner) s] + +theorem assessingRecord_member (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) : + recordFor (assessingRule owner) s ∈ completeOwnWork owner := by + apply List.mem_flatMap.mpr + refine ⟨s,hs,?_⟩ + cases generationEligible s <;> simp + +theorem generatingRecord_member (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) + (hg : generationEligible s = true) : recordFor (generatingRule owner) s ∈ completeOwnWork owner := by + exact List.mem_flatMap.mpr ⟨s,hs,by simp [hg]⟩ + +theorem completeOwnWork_reflexive (owner : Nat) : + Reflexive owner (ownRules owner) (completeOwnWork owner) := by + refine ⟨ownRegistryCoherent owner, ?_⟩ + intro rule hr s _ ha + refine ⟨recordFor rule s, ?_, ownRecordValid owner rule hr s ha⟩ + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl + · exact generatingRecord_member owner s ha.1 ha.2 + · exact assessingRecord_member owner s ha + +theorem ownAssessmentPerformed (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) : + Performed (completeOwnWork owner) s .assessment := + ⟨recordFor (assessingRule owner) s, assessingRecord_member owner s hs, rfl, rfl⟩ + +def applicationRule : Principle := + { assessingRule 0 with key := ⟨0,0⟩, applicable := fun s => s = .process 0 0 .application } + +def applicationWork : List WorkRecord := [recordFor applicationRule (.process 0 0 .application)] + +theorem applicationWork_reflexive : Reflexive 0 [applicationRule] applicationWork := by + constructor + · intro p hp q hq _ + simp only [List.mem_singleton] at hp hq + rw [hp,hq] + · intro rule hr s _ ha + simp only [List.mem_singleton] at hr + subst rule + change s = .process 0 0 .application at ha + subst s + refine ⟨recordFor applicationRule (.process 0 0 .application), by simp [applicationWork], ?_⟩ + refine ⟨by simp, rfl, rfl, rfl, ?_, rfl, rfl, rfl, ?_, rfl, ?_, ?_, rfl, ?_⟩ + · exact ⟨applicationRule, by simp, rfl⟩ + · exact ⟨applicationRule, by simp, rfl, rfl⟩ + · exact reasonsFor_nonempty _ + · exact reasonsFor_target _ + · change statedOutcome .assessment (.process 0 0 .application) = finiteMethodResult .assessment (inquiryFor (.process 0 0 .application)) (reasonsFor (.process 0 0 .application)) [0] + exact ownContentEvaluates .assessment _ + +/-- organon-map CoreReader.Agency.applicabilityRetained +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +theorem applicabilityRetained (owner : Nat) (rules : List Principle) (records : List WorkRecord) : + (Reflexive owner rules records → ReflexiveScope owner rules records) ∧ + (ReflexiveScope owner rules records ↔ + ∀ rule ∈ rules, ∀ s, s.owner = owner → (¬ rule.applicable s ∨ Performed records s rule.activity)) ∧ + (Reflexive 0 [applicationRule] applicationWork ∧ + ¬ Performed applicationWork (.system 0) .assessment) := by + classical + refine ⟨Reflexive.toScope, ?_, applicationWork_reflexive, ?_⟩ + · constructor + · intro h rule hr s hs + by_cases ha : rule.applicable s + · exact Or.inr (h rule hr s hs ha) + · exact Or.inl ha + · intro h rule hr s hs ha + exact (h rule hr s hs).resolve_left (not_not_intro ha) + · rintro ⟨record, hm, ht, _⟩ + simp only [applicationWork, List.mem_singleton] at hm + subst record + cases ht + +end CoreReader.Agency +``` + + + + **L1** Imports Std and its dependencies into this module. + + + **L3** Opens namespace CoreReader.Agency; file boundaries do not change declaration identity. + + + **L5** Defines formation, application and revision phase tags. + + + **L6** Generates decidable equality and display instances for the preceding datatype. + + + **L8** Identifies a registered principle by owner and local identifier. + + + **L9** Stores the owning subject identifier. + + + **L10** Stores the principle identifier within its owner. + + + **L11** Generates decidable equality and display instances for the preceding datatype. + + + **L13** Distinguishes system, principle and phase-indexed principle-process objects. + + + **L14** Represents the system itself, identified by its owner number. + + + **L15** Represents a particular principle by owner and local principle identifier. + + + **L16** Represents that principle's formation, application or revision process as a separate subject. + + + **L17** Generates decidable equality and display instances for the preceding datatype. + + + **L19** Extracts the owner's identifier from every subject constructor. + + + **L20** Extracts the owner directly from a system subject. + + + **L21** Extracts a principle's owner while ignoring its local identifier. + + + **L22** Extracts a process subject's owner independently of its principle identifier and phase. + + + **L24** Distinguishes generation work from assessment work. + + + **L25** Generates decidable equality and display instances for the preceding datatype. + + + **L27** Separates conformity, formation basis, applicability and revision-ground questions. + + + **L28** Generates decidable equality and display instances for the preceding datatype. + + + **L30** Provides a constant-true program and a program true only at zero. + + + **L31** Generates decidable equality and display instances for the preceding datatype. + + + **L33** Evaluates those two programs on natural inputs. + + + **L34** The alwaysTrue sample program accepts every natural-number input. + + + **L35** The onlyAtZero program returns true precisely at input zero. + + + **L37** Documents the following definition or result: Stores tested inputs separately from the claimed scope, allowing overextended claims. + + + **L38** Stores tested inputs separately from the claimed scope, allowing overextended claims. + + + **L39** Records the inputs on which this method draft actually tests a program. + + + **L40** Separately records the input scope the draft proposes to authorize. + + + **L41** Generates decidable equality and display instances for the preceding datatype. + + + **L43** Accepts a program when it succeeds on all listed test inputs; untested inputs are unchecked. + + + **L44** Accepts a program when every tested input returns true; claimedScope is not checked here. + + + **L46** Documents the following definition or result: Binds a target and question kind to requested scope and the target's current method content. + + + **L47** Binds a target and question kind to requested scope and the target's current method content. + + + **L48** Identifies the exact subject whose method is being examined. + + + **L49** Distinguishes conformity, formation reasons, applicability and revision reasons as inquiry purposes. + + + **L50** Records the input scope this particular inquiry asks the method to cover. + + + **L51** Attaches the actual method draft under examination, including its tested and claimed inputs. + + + **L52** Generates decidable equality and display instances for the preceding datatype. + + + **L54** Represents purposes, declared scopes, observations and concrete program/input counterexamples. + + + **L55** A purpose reason names the inputs the method is intended to address. + + + **L56** A scope reason states the method's declared input limits. + + + **L57** An observation reason records a specific input and Boolean output. + + + **L58** A counterexample reason names an actual sample program and input to check. + + + **L59** Generates decidable equality and display instances for the preceding datatype. + + + **L61** Assigns a small code to each reason constructor; the code alone is not evidential content. + + + **L62** Uses local reference 0 for purpose reasons; this is a category identifier, not a unique global identity. + + + **L63** Uses local reference 1 for declared-scope reasons. + + + **L64** Uses local reference 2 for observation reasons. + + + **L65** Uses local reference 3 for counterexample reasons. + + + **L67** Documents the following definition or result: Attaches a reason's content and reference to the subject it concerns. + + + **L68** Attaches a reason's content and reference to the subject it concerns. + + + **L69** Stores a local reference identifying this reason in the modeled inquiry. + + + **L70** Identifies the subject this reason actually concerns. + + + **L71** Stores the purpose, scope, observation or counterexample contents of the reason. + + + **L72** Generates decidable equality and display instances for the preceding datatype. + + + **L74** Allows scoped support, insufficiency, nonapplicability and undetermined results. + + + **L75** Generates decidable equality and display instances for the preceding datatype. + + + **L77** Separates an assessment result from a generated method draft. + + + **L78** Packages a verdict as an assessment outcome; a negative verdict is still an assessment. + + + **L79** Packages a newly generated method draft, without asserting that the draft is correct. + + + **L80** Generates decidable equality and display instances for the preceding datatype. + + + **L82** Documents the following definition or result: Registers a rule's identity, activity, declared method, applicability, inquiries, reasons, limits and explicit outcome semantics. + + + **L83** Documents the following definition or result: Registers a rule's identity, activity, declared method, applicability, inquiries, reasons, limits and explicit outcome semantics. + + + **L84** Registers a rule's identity, activity, declared method, applicability, inquiries, reasons, limits and explicit outcome semantics. + + + **L85** Gives the principle an owner/local identifier used to resolve its records. + + + **L86** Specifies whether this principle governs generation or assessment activity. + + + **L87** States the method draft belonging to this registered principle. + + + **L88** States the subjects on which this principle is applicable. + + + **L89** Assigns the actual question to examine for each subject. + + + **L90** Assigns the reasons supplied for each subject's question. + + + **L91** Assigns the retained input limits for each subject's application. + + + **L92** Defines when an outcome follows this principle's question, reasons and limits; no adequacy law is imposed by this field alone. + + + **L94** Stores the actual rule identity, target, activity, inquiry, reasons, limits and outcome used by an application. + + + **L95** Records the exact registered principle key claimed to have been used. + + + **L96** Records the subject on which this work was performed. + + + **L97** Records whether this work was generation or assessment. + + + **L98** Stores the concrete inquiry actually recorded for this work. + + + **L99** Stores the concrete reasons used in this work record. + + + **L100** Stores the input limits retained in this work record. + + + **L101** Stores the recorded assessment verdict or generated method draft. + + + **L102** Generates decidable equality and display instances for the preceding datatype. + + + **L104** Requires equal registered keys to identify the same principle, preventing ambiguous duplicate identities. + + + **L105** Two registered principles sharing one key must be the same principle, preventing ambiguous lookup. + + + **L107** Requires each assessed target to resolve to a registered owner or exact principle key. + + + **L108** A system subject is resolved when the registry contains some principle with that owner. + + + **L109** Principle and process subjects require a registry entry with their exact owner and local identifier. + + + **L111** Documents the following definition or result: Connects the inquiry's current method to the registered target principle's declared method. + + + **L112** Documents the following definition or result: Connects the inquiry's current method to the registered target principle's declared method. + + + **L113** Connects the inquiry's current method to the registered target principle's declared method. + + + **L114** Chooses the lookup rule from the inquiry's actual target kind. + + + **L115** A system inquiry examines the declared method of its owner's registered principle zero. + + + **L116** For a principle or its process, retain that target's actual owner and identifier for lookup. + + + **L117** Requires both exact key lookup and equality between the inquiry's method and that registered principle's method. + + + **L119** Requires an actual stored record with the requested target and activity; validity is checked separately. + + + **L120** Performed means a listed record has this exact subject and activity; by itself it checks no reason contents. + + + **L122** Documents the following definition or result: Retains the owner-and-applicability-conditioned record-coverage interface. + + + **L123** Retains the owner-and-applicability-conditioned record-coverage interface. + + + **L124** Every applicable registered rule must have a performed activity on subjects belonging to the specified owner. + + + **L126** Documents the following definition or result: Checks rule registration, applicability, object identities, resolved method content, nonempty targeted reasons, exact limits and agreement with the rule's semantics. + + + **L127** Documents the following definition or result: Checks rule registration, applicability, object identities, resolved method content, nonempty targeted reasons, exact limits and agreement with the rule's semantics. + + + **L128** Checks rule registration, applicability, object identities, resolved method content, nonempty targeted reasons, exact limits and agreement with the rule's semantics. + + + **L129** The following proof fields certify one particular work record as a valid use of rule on s. + + + **L130** Requires the rule used by the record to belong to this registry. + + + **L131** Requires that same rule to be applicable to the assessed subject. + + + **L132** Checks the record's used-principle key against this rule's exact key. + + + **L133** Checks that the work record targets this exact subject s. + + + **L134** Requires the record's subject to resolve within the same rule registry. + + + **L135** Checks that the recorded activity is the activity governed by this rule. + + + **L136** Checks that the recorded inquiry equals the inquiry this rule assigns to s. + + + **L137** Separately checks that the inquiry itself targets s, rather than an unrelated subject. + + + **L138** Checks that the inquiry's method belongs to its resolved registered target. + + + **L139** Checks the recorded reasons equal those specified by this rule for s. + + + **L140** Requires at least one actual reason in this record. + + + **L141** Requires every recorded reason to concern the same subject s. + + + **L142** Checks that recorded limits equal the rule's limits for s. + + + **L143** Requires the record's outcome to satisfy the rule's actual meaning relation on its inquiry, reasons and limits. + + + **L145** Documents the following definition or result: Requires a coherent registry and a valid recorded application for every applicable same-owner subject and registered rule; this remains a model compliance condition. + + + **L146** Opens provenance metadata binding CoreReader.Agency.Reflexive to the following source references; this metadata is not a proof premise. + + + **L147** Records source reference organon.charter.reflexivity#p1 with content digest 13293b45c2fa89068c68ae7ef3c5df38f0efadb3ef3873d78a5ba67d9691a757; matching a digest establishes source identity, not semantic fidelity. + + + **L148** Records source reference organon.charter.reflexivity.meaning#p1 with content digest 8a2caede01a43d8b6c60b54c78ac089c51868e9956f316948077ccee2e45c9cc; matching a digest establishes source identity, not semantic fidelity. + + + **L149** Records source reference organon.charter.reflexivity.limits#p1 with content digest ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc; matching a digest establishes source identity, not semantic fidelity. + + + **L150** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L151** Requires a coherent registry and a valid recorded application for every applicable same-owner subject and registered rule; this remains a model compliance condition. + + + **L152** Reflexive first requires unambiguous principle registration. + + + **L153** It then ranges over each registered rule and owned subject where that rule is applicable. + + + **L154** For each such application, some listed record must satisfy all ValidApplication content checks. + + + **L156** Forgets content-validity details while extracting target/activity record coverage from full reflexivity. + + + **L157** Assumes full contentful Reflexive compliance and derives its weaker scope-only coverage. + + + **L158** Takes a registered rule, an owned subject and its applicability premise for the scope obligation. + + + **L159** Uses full Reflexive compliance to obtain the actual listed record and its ValidApplication proof. + + + **L160** Keeps that record's membership, target identity and activity identity to prove Performed. + + + **L162** Opens provenance metadata binding CoreReader.Agency.noSelfExemption to the following source references; this metadata is not a proof premise. + + + **L163** Records source reference organon.charter.reflexivity.limits#p1 with content digest ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc; matching a digest establishes source identity, not semantic fidelity. + + + **L164** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L165** Instantiates full reflexivity at a registered applicable same-owner subject, then extracts its performance record. + + + **L166** Requires full Reflexive compliance and actual membership of the rule in the registry. + + + **L167** Also requires the target's owner to match and the rule to be applicable to it. + + + **L168** Specializes the derived scope obligation to those premises, yielding this target's performed activity. + + + **L170** Tests input zero and declares scope zero. + + + **L172** Maps formation to basis, application to applicability, revision to grounds over zero and one, and other objects to conformity. + + + **L173** Chooses the inquiry from the subject's process phase, retaining the same subject as target. + + + **L174** For formation, asks about the basis for a method covering input zero. + + + **L175** For application, asks whether the local method applies on input zero. + + + **L176** For revision, asks about extending the same local method's scope to inputs zero and one. + + + **L177** For a system or principle itself, asks conformity on the local scope {0}. + + + **L179** Documents the following definition or result: Supplies question-specific purpose/scope/observation data, adding a failing untested-input program for revision review. + + + **L180** Supplies question-specific purpose/scope/observation data, adding a failing untested-input program for revision review. + + + **L181** Formation reasons state the purpose {0}, declared scope {0}, and the observed true result at zero. + + + **L182** Applicability and conformity use the declared local scope plus the same observation at zero. + + + **L183** Revision reasons request {0,1} while acknowledging a declared scope of {0} and only a zero observation. + + + **L184** Adds the concrete onlyAtZero program at input one as a revision counterexample. + + + **L186** Attaches every chosen reason's content to this exact inquiry target. + + + **L187** Wraps each source reason with its category reference and the same subject s, preserving its actual content. + + + **L189** Documents the following definition or result: Computes scoped results from actual reason contents and method scope; a program passing current tests but failing a requested input yields insufficiency for revision. + + + **L190** Documents the following definition or result: Computes scoped results from actual reason contents and method scope; a program passing current tests but failing a requested input yields insufficiency for revision. + + + **L191** Computes scoped results from actual reason contents and method scope; a program passing current tests but failing a requested input yields insufficiency for revision. + + + **L192** Extracts reason contents for checking their substantive purpose, scope, observations and counterexamples. + + + **L193** Returns undetermined if supplied limits differ from the examined method's declared scope. + + + **L194** After checking limits, evaluates the specific kind of question asked. + + + **L195** Selects the formation-basis assessment branch. + + + **L196** Requires a purpose reason covering the inquiry's requested inputs. + + + **L197** Also requires an explicit limit declaration and equality of requested and declared scopes. + + + **L198** Formation is supportedWithinScope only when those content checks pass; otherwise it is undetermined. + + + **L199** Uses the same local checks for applicability and conformity questions. + + + **L200** First tests that every requested input belongs to the supplied limits. + + + **L201** Within those limits, requires a reason explicitly declaring that same scope. + + + **L202** Also requires the true observation at zero and a requested scope exactly equal to [0]. + + + **L203** Passing these local checks yields supportedWithinScope; incomplete evidence yields undetermined. + + + **L204** A requested input outside the supplied limits yields notApplicable. + + + **L205** Selects the revision-grounds branch, which searches for an actual scope counterexample. + + + **L206** Requires a reason stating the revised requested scope as the intended purpose. + + + **L207** Requires the old limits to be explicitly present as a declared-scope reason. + + + **L208** Requires the original successful observation at input zero. + + + **L209** Searches the supplied reason contents for a counterexample satisfying the following concrete checks. + + + **L210** A counterexample's input must be inside the newly requested scope. + + + **L211** Its program must nevertheless pass the current method's tested inputs. + + + **L212** That same program must fail at the counterexample input. + + + **L213** Other reason kinds cannot themselves satisfy this counterexample search. + + + **L214** A witnessed testing/scope gap yields insufficient; without those contents, the result is undetermined. + + + **L216** Generation keeps tested inputs and adopts requested scope; assessment executes the reason-sensitive inquiry evaluator. + + + **L217** Supplies the same reasons and limits to the activity-specific result function. + + + **L218** Chooses between generating a draft and evaluating an inquiry. + + + **L219** Generation keeps the method's tested inputs but proposes the inquiry's requested scope; correctness is not certified. + + + **L220** Assessment computes assessInquiry from this question's actual reasons and limits. + + + **L222** Defines acceptable outcome by equality with the disclosed finite evaluation algorithm, not an assumed successful result. + + + **L223** Receives the specific recorded outcome whose compliance with this activity's method is checked. + + + **L224** An outcome follows the method exactly when it equals the computed finiteMethodResult. + + + **L226** Enumerates the owner system, both registered principles and all three phases of each principle. + + + **L227** Includes the system itself and its two principle identities as owned subjects. + + + **L228** Includes formation, application and revision of principle zero as separate subjects. + + + **L229** Also includes all three phases of principle one, giving nine owned subjects total. + + + **L231** Documents the following definition or result: Excludes application-phase processes from this particular generation rule while retaining the other objects. + + + **L232** Excludes application-phase processes from this particular generation rule while retaining the other objects. + + + **L233** Treats applying an already existing principle as ineligible for generation in this application model. + + + **L234** All other represented subject kinds remain eligible for generation. + + + **L236** Registers principle zero for generation with the local method, explicit inquiries/reasons and restricted applicability. + + + **L237** Registers the generation principle under local key zero for this owner. + + + **L238** Makes this rule govern generation work. + + + **L239** Assigns the local test-and-scope draft [0]/[0] to the generation rule. + + + **L240** Generation requires both membership in this owner's nine subjects and generation eligibility. + + + **L241** Uses inquiryFor to supply the subject's actual phase-sensitive question. + + + **L242** Uses reasonsFor to supply the original target-linked reason contents. + + + **L243** Retains [0] as the generation rule's limit for every subject. + + + **L244** Requires the generated outcome to match finiteMethodResult's generation branch. + + + **L246** Registers principle one for assessment of every enumerated own subject with explicit finite evaluation semantics. + + + **L247** Registers the assessment principle under distinct local key one. + + + **L248** Makes this rule govern assessment work. + + + **L249** The assessment principle declares the same local [0]/[0] method contract. + + + **L250** Assessment applies to all nine subjects belonging to this owner. + + + **L251** Assigns the same phase-sensitive inquiry function to the assessment rule. + + + **L252** Assigns the same original target-linked reasons to its assessments. + + + **L253** Retains [0] as the assessment rule's declared limit. + + + **L254** Requires assessment outcomes to equal the evaluator's actual result. + + + **L256** Returns the two distinct registered generation and assessment principles. + + + **L258** Documents the following definition or result: Constructs expected generated drafts and scoped/insufficient assessment results, which are subsequently checked against evaluation. + + + **L259** Constructs expected generated drafts and scoped/insufficient assessment results, which are subsequently checked against evaluation. + + + **L260** Chooses the independently stated record outcome by activity. + + + **L261** The recorded generated draft retains tested inputs and adopts the inquiry's requested scope. + + + **L262** For assessment records, chooses a stated verdict from the inquiry kind rather than calling assessInquiry here. + + + **L263** Revision inquiries are recorded as insufficient. + + + **L264** The remaining represented inquiries are recorded as supportedWithinScope. + + + **L266** Builds a record from the supplied rule and subject; registry membership and content validity require the later ValidApplication proof. + + + **L267** Builds a record from this rule's identity, inquiry, reasons and limits, but uses the separately stated outcome. + + + **L269** Exhausts subject/phase constructors to prove each concrete inquiry has reasons. + + + **L270** Checks reason-list nonemptiness for each kind of subject. + + + **L271** System inquiries use the conformity reasons, which contain scope and observation entries. + + + **L272** Principle inquiries likewise have the nonempty scope-and-observation list. + + + **L273** Each process phase reduces to its actual nonempty formation, application or revision reason list. + + + **L275** Uses the reason-list map construction to prove every reason targets the same subject. + + + **L276** Takes any reason known to occur in this subject's constructed reason list. + + + **L277** Inverts the map construction to recover the source content and replace the reason with its target-tagged wrapper. + + + **L278** That wrapper's target is s by construction, so target equality is reflexive. + + + **L280** Checks each constructor to prove the generated inquiry retains its subject identity. + + + **L281** Checks the inquiry target for system, principle and process subjects separately. + + + **L282** The system inquiry was constructed with that same system as target. + + + **L283** The principle inquiry likewise retains that same principle target. + + + **L284** Every process phase uses the original process subject as its inquiry target. + + + **L286** Documents the following definition or result: Computes every subject/phase assessment and generation case, showing stored expected outcomes agree with the actual algorithm, including insufficiency. + + + **L287** Computes every subject/phase assessment and generation case, showing stored expected outcomes agree with the actual algorithm, including insufficiency. + + + **L288** Requires the independently stated outcome to equal actual evaluation of this subject's question, reasons and [0] limits. + + + **L289** Splits this equality check between generated drafts and assessment verdicts. + + + **L290** Both generation definitions construct the identical tested-input/requested-scope draft. + + + **L291** For assessment, the stated verdict must now be checked against the actual evaluator. + + + **L292** Separates the finite assessment check by subject kind. + + + **L293** The system's conformity contents compute to the stated supportedWithinScope verdict. + + + **L294** The principle's conformity contents compute to that same supportedWithinScope verdict. + + + **L295** Formation/application compute support; revision computes insufficient from the program passing zero but failing one. + + + **L297** Separates local identifiers zero and one to prove the two-rule registry has no ambiguous key. + + + **L298** Takes two registered principles whose keys are assumed equal. + + + **L299** Restricts both registry memberships to the actual generation or assessment rule. + + + **L300** Examines the four resulting pairs of concrete rules. + + + **L301** When both are the generation rule, principle equality holds directly. + + + **L302** Generation key 0 cannot equal assessment key 1; projecting localId produces a contradiction. + + + **L303** The reverse mixed pair would require localId 1=0, also impossible. + + + **L304** When both are the assessment rule, principle equality holds directly. + + + **L306** Checks all nine enumerated subjects resolve to an actual registered owner/principle. + + + **L307** The subject selected from ownSubjects must resolve to this owner's actual registry. + + + **L308** Expands membership hs into the nine concrete owned subjects. + + + **L309** Handles each of those nine subjects with its original owner and principle identifier fixed. + + + **L310** Finds the generation or assessment registry entry matching each target key. + + + **L312** Checks each inquiry's method matches its registered target's declared local method. + + + **L313** Requires the selected subject's inquiry to examine its own registered declared method. + + + **L314** Again enumerates the nine concrete subjects from the actual membership premise. + + + **L315** Checks target-method correspondence separately for each system, principle and phase subject. + + + **L316** Both registered rules declare localMethod, exactly the method inquiryFor assigns to every enumerated target. + + + **L318** Combines identity, reason-target, scope, registry and actual evaluation facts to validate each applicable generated record. + + + **L319** Assumes the chosen registered rule is applicable to this subject s. + + + **L320** Proves the concrete recordFor rule s satisfies every ValidApplication field. + + + **L321** First derives that applicability places s in this owner's subject list. + + + **L322** Uses registry membership to restrict rule to one of the two owned rules. + + + **L323** Separates the generation and assessment applicability conditions. + + + **L324** Generation applicability includes owned-subject membership as its first conjunct. + + + **L325** Assessment applicability is exactly that owned-subject membership. + + + **L326** Establishes that this actual rule uses inquiryFor as its inquiry function. + + + **L327** Reduces registered-rule membership to generation or assessment to inspect its inquiry field. + + + **L328** Both possible rules define their inquiry field as inquiryFor. + + + **L329** Establishes that the chosen rule uses reasonsFor as its reason provider. + + + **L330** Again restricts the rule to the two actual registry entries before inspecting reasons. + + + **L331** Both entries supply exactly reasonsFor. + + + **L332** Establishes that this rule's limits for s are exactly [0]. + + + **L333** Resolves registry membership before inspecting the selected rule's limits. + + + **L334** Both owned rules retain [0] as their limit. + + + **L335** Establishes that the chosen rule's meaning is the result function for its own activity. + + + **L336** Resolves registry membership to inspect generation versus assessment meaning. + + + **L337** In either case, the rule's meaning is finiteMethodMeaning specialized to that rule's activity. + + + **L338** Builds ValidApplication using registry/applicability premises, record identities and resolved target; leaves inquiry, reasons and computed meaning checks to follow. + + + **L339** The remaining inquiry-target goal is about this rule's actual inquiry on s. + + + **L340** Replaces the rule's inquiry with inquiryFor, whose target-preservation theorem proves it targets s. + + + **L341** The remaining method-identity goal checks the registered target of this rule's inquiry. + + + **L342** Rewrites to inquiryFor and uses the concrete owned-target method-resolution theorem. + + + **L343** Reduces record reason nonemptiness to nonemptiness of this rule's supplied reasons. + + + **L344** Rewrites those reasons to reasonsFor and applies its nonempty-list theorem. + + + **L345** Reduces reason-target consistency to every supplied reason targeting s. + + + **L346** Rewrites to reasonsFor and uses its target-preserving construction theorem. + + + **L347** The final obligation compares the separately stated outcome against this rule's actual inquiry, reasons, limits and meaning. + + + **L348** Substitutes the four established identities for meaning, inquiry, reasons and [0] limits. + + + **L349** Uses ownContentEvaluates to prove the recorded outcome equals the actual method result. + + + **L351** Constructs records for all nine subjects, including generation only where its eligibility condition holds. + + + **L352** Builds the full log by concatenating the records assigned to each owned subject. + + + **L353** Eligible subjects receive both a generation record and an assessment record. + + + **L354** Application-phase subjects receive assessment only, matching generation's explicit applicability restriction. + + + **L356** Places each subject's assessment record in the flat-mapped complete work list. + + + **L357** Claims this owned subject's assessment record occurs in the constructed full log. + + + **L358** Uses flatMap membership: choose a subject whose assigned record list contains the desired record. + + + **L359** Chooses the same s and its supplied owned-subject membership hs. + + + **L360** Whether generation is eligible or not, the assigned list contains s's assessment record. + + + **L362** Places a subject's generation record in the work list under explicit generation eligibility. + + + **L363** Adds generation eligibility to owned membership before claiming a generation record in the full log. + + + **L364** Selects s's flatMap branch; hg makes that branch include the requested generation record. + + + **L366** Combines coherent registry, membership and content-valid applications to establish the concrete nonempty reflexivity model. + + + **L367** States full contentful reflexivity for the actual two-rule registry and constructed work log. + + + **L368** Provides the proved registry coherence and leaves contentful coverage for each applicable subject. + + + **L369** Takes an actual registered rule and applicable subject; applicability itself will supply needed owned membership. + + + **L370** Chooses recordFor rule s and its already proved content validity, leaving only its presence in the full log. + + + **L371** Resolves rule membership to the generation or assessment entry. + + + **L372** Splits record membership by those two actual rule cases. + + + **L373** For generation, ha supplies owned membership and eligibility, which place its record in the full log. + + + **L374** For assessment, ha directly supplies the owned membership needed for its record. + + + **L376** Extracts the constructed assessment record for a listed own subject. + + + **L377** Claims a performed assessment on s in the same complete work log. + + + **L378** Uses s's assessment record, its proved log membership and exact target/activity identities as the Performed witness. + + + **L380** Restricts an assessment rule to one application-phase subject and assigns it a resolvable key. + + + **L381** Restricts the assessment rule to exactly principle-zero's application process, with key (0,0). + + + **L383** Stores the one fully specified application assessment record. + + + **L385** Checks the singleton registry and record satisfy full content-valid reflexivity on their restricted applicability. + + + **L386** Separates singleton-registry coherence from coverage of its sole applicable subject. + + + **L387** Takes any two rules in that singleton registry; key equality is unnecessary because membership already identifies both. + + + **L388** Singleton membership makes both rules equal to applicationRule. + + + **L389** Substituting these identities proves the two rules are equal. + + + **L390** Takes an applicable subject for a rule in the singleton application registry. + + + **L391** Uses singleton membership to identify the rule as applicationRule. + + + **L392** Replaces rule with that exact applicationRule throughout the coverage obligation. + + + **L393** Unfolds applicability to show s is exactly owner-zero principle-zero's application process. + + + **L394** Substitutes that exact process for s, fixing the work target. + + + **L395** Selects the sole record in applicationWork and proves its membership; content validity remains to check. + + + **L396** Fills immediate registry, applicability and record-identity fields; leaves target resolution, reasons and computed outcome checks. + + + **L397** The target key resolves to applicationRule itself in the singleton registry. + + + **L398** That same registered rule supplies the localMethod actually examined by the inquiry. + + + **L399** The application inquiry's reasons are nonempty by reasonsFor_nonempty. + + + **L400** Every application reason targets this exact application-process subject. + + + **L401** The remaining meaning obligation is equality of the stated application assessment and its actual finite evaluation. + + + **L402** Uses ownContentEvaluates to certify that equality for the application-phase assessment. + + + **L404** Opens provenance metadata binding CoreReader.Agency.applicabilityRetained to the following source references; this metadata is not a proof premise. + + + **L405** Records source reference organon.charter.reflexivity.limits#p1 with content digest ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc; matching a digest establishes source identity, not semantic fidelity. + + + **L406** Closes the preceding documentation/provenance comment; it adds no executable code. + + + **L407** Derives record scope from full reflexivity, proves its classical conditional/disjunctive equivalence, and gives a valid restricted example with no system assessment. + + + **L408** The first clause retains the implication from full contentful reflexivity to scope coverage. + + + **L409** The second clause restates conditional scope coverage as an either/or obligation. + + + **L410** For each owned subject and registered rule, either the rule is inapplicable or its activity was performed. + + + **L411** The concrete singleton application log satisfies full reflexivity under its restricted rule. + + + **L412** Yet that same log contains no assessment of the system itself, where this rule is not applicable. + + + **L413** Uses classical case splitting on possibly undecidable applicability predicates. + + + **L414** Supplies the general scope projection and concrete restricted witness; leaves the equivalence and missing-system-record proof. + + + **L415** Proves both directions of the applicability-or-performance reformulation. + + + **L416** Assumes conditional scope coverage and fixes a registered rule with an owned subject. + + + **L417** Splits on whether that exact rule is applicable to this subject. + + + **L418** When applicable, coverage supplies the performed activity, satisfying the right disjunct. + + + **L419** When inapplicable, that negative applicability fact satisfies the left disjunct. + + + **L420** For the reverse direction, assumes the disjunction and actual applicability on the owned subject. + + + **L421** Rules out the inapplicable disjunct using ha, leaving the required performed activity. + + + **L422** Assumes a system assessment exists and extracts its listed record plus target identity. + + + **L423** The singleton applicationWork list forces that record to be its application-process record. + + + **L424** Replaces the alleged system-assessment record with that sole process record. + + + **L425** Its process target cannot equal the system target, contradicting the assumed record identity. + + + **L427** Closes the current namespace. + + +### `leanified/CoreReader.lean` + + +```lean +import CoreReader.Integration +``` + + + + **L1** Imports CoreReader.Integration and its dependencies into this module. + diff --git a/lean/philosophy/evidence/README.md b/lean/philosophy/evidence/README.md new file mode 100644 index 0000000..933e133 --- /dev/null +++ b/lean/philosophy/evidence/README.md @@ -0,0 +1,5 @@ +# Selected current checks + +These actual build, declaration/type/dependency and four-view checks were selected from a fresh ordinary-copy execution after the 2026-09-15 source migration. The [independent migration comparison](../reviews/source-migration-2026-09-15.md) supplies the bounded new-source judgment; unchanged executable Lean text and target bodies retain the disclosed earlier interpretation scope. The [provenance follow-up](../reviews/source-migration-provenance-2026-09-15.md) separately reviews two source-hash comments. The preceding complete source/run/readers were preserved and replayed separately before replacement. + +`kernel.json` and `manuscript-check.json` report mechanical checks, not philosophical correctness. `execution-identity.json` records loaded tools and observed runtimes, not tool approval. All partial, nonformal and application-specific limits remain. Reruns write separate ignored `checks/` records rather than changing these selected outputs. diff --git a/lean/philosophy/evidence/audit.lean b/lean/philosophy/evidence/audit.lean new file mode 100644 index 0000000..8a31cb5 --- /dev/null +++ b/lean/philosophy/evidence/audit.lean @@ -0,0 +1,317 @@ +import Lean +import CoreReader +#check CoreReader.Integration.jointWitness +#print axioms CoreReader.Integration.jointWitness +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Integration.jointWitness + Lean.logInfo ("ORGANON_TYPE CoreReader.Integration.jointWitness " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.Generative +#print axioms CoreReader.Agency.Generative +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.Generative + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.Generative " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.permissionNotValuation +#print axioms CoreReader.Agency.permissionNotValuation +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.permissionNotValuation + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.permissionNotValuation " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.revisabilityCovers +#print axioms CoreReader.Agency.revisabilityCovers +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.revisabilityCovers + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.revisabilityCovers " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.revisionWithoutProgress +#print axioms CoreReader.Agency.revisionWithoutProgress +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.revisionWithoutProgress + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.revisionWithoutProgress " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.generationLimits +#print axioms CoreReader.Agency.generationLimits +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.generationLimits + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.generationLimits " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.AchievementAccountability +#print axioms CoreReader.Evidence.AchievementAccountability +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.AchievementAccountability + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.AchievementAccountability " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.achievementNeedsSupport +#print axioms CoreReader.Evidence.achievementNeedsSupport +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.achievementNeedsSupport + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.achievementNeedsSupport " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.consequenceConsistency +#print axioms CoreReader.Logic.consequenceConsistency +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.consequenceConsistency + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.consequenceConsistency " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.jointConflict +#print axioms CoreReader.Logic.jointConflict +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.jointConflict + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.jointConflict " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.revisionCanReverse +#print axioms CoreReader.Logic.revisionCanReverse +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.revisionCanReverse + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.revisionCanReverse " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.contextDifferences +#print axioms CoreReader.Logic.contextDifferences +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.contextDifferences + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.contextDifferences " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.semanticChangeMustBeReported +#print axioms CoreReader.Logic.semanticChangeMustBeReported +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.semanticChangeMustBeReported + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.semanticChangeMustBeReported " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.representationOrderIrrelevant +#print axioms CoreReader.Logic.representationOrderIrrelevant +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.representationOrderIrrelevant + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.representationOrderIrrelevant " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.hiddenContextChangeRejected +#print axioms CoreReader.Logic.hiddenContextChangeRejected +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.hiddenContextChangeRejected + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.hiddenContextChangeRejected " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.tensionWithoutContradiction +#print axioms CoreReader.Logic.tensionWithoutContradiction +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.tensionWithoutContradiction + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.tensionWithoutContradiction " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.conflictRequiresChange +#print axioms CoreReader.Logic.conflictRequiresChange +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.conflictRequiresChange + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.conflictRequiresChange " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.consistentFalse +#print axioms CoreReader.Logic.consistentFalse +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.consistentFalse + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.consistentFalse " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.consistentIncomplete +#print axioms CoreReader.Logic.consistentIncomplete +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.consistentIncomplete + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.consistentIncomplete " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.Reflexive +#print axioms CoreReader.Agency.Reflexive +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.Reflexive + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.Reflexive " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.noSelfExemption +#print axioms CoreReader.Agency.noSelfExemption +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.noSelfExemption + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.noSelfExemption " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.applicabilityRetained +#print axioms CoreReader.Agency.applicabilityRetained +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.applicabilityRetained + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.applicabilityRetained " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.selfTestDoesNotProve +#print axioms CoreReader.Agency.selfTestDoesNotProve +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.selfTestDoesNotProve + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.selfTestDoesNotProve " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.selfOriginDoesNotSupport +#print axioms CoreReader.Evidence.selfOriginDoesNotSupport +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.selfOriginDoesNotSupport + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.selfOriginDoesNotSupport " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.Grounds +#print axioms CoreReader.Evidence.Grounds +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.Grounds + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.Grounds " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.supportWeakening +#print axioms CoreReader.Evidence.supportWeakening +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.supportWeakening + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.supportWeakening " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.scopeRestriction +#print axioms CoreReader.Evidence.scopeRestriction +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.scopeRestriction + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.scopeRestriction " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.assessmentUnion +#print axioms CoreReader.Evidence.assessmentUnion +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.assessmentUnion + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.assessmentUnion " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.labelsCannotWaive +#print axioms CoreReader.Evidence.labelsCannotWaive +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.labelsCannotWaive + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.labelsCannotWaive " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.mixedMissingResponsibility +#print axioms CoreReader.Evidence.mixedMissingResponsibility +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.mixedMissingResponsibility + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.mixedMissingResponsibility " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.articulationNotSupport +#print axioms CoreReader.Evidence.articulationNotSupport +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.articulationNotSupport + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.articulationNotSupport " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.measurementRepeatNotSupport +#print axioms CoreReader.Evidence.measurementRepeatNotSupport +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.measurementRepeatNotSupport + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.measurementRepeatNotSupport " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Logic.compatibilityNotEntailment +#print axioms CoreReader.Logic.compatibilityNotEntailment +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Logic.compatibilityNotEntailment + Lean.logInfo ("ORGANON_TYPE CoreReader.Logic.compatibilityNotEntailment " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.selfAssertionNotReason +#print axioms CoreReader.Evidence.selfAssertionNotReason +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.selfAssertionNotReason + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.selfAssertionNotReason " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.valueWithoutSelfProof +#print axioms CoreReader.Evidence.valueWithoutSelfProof +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.valueWithoutSelfProof + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.valueWithoutSelfProof " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.heterogeneousReasons +#print axioms CoreReader.Evidence.heterogeneousReasons +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.heterogeneousReasons + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.heterogeneousReasons " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.localNotUniversal +#print axioms CoreReader.Evidence.localNotUniversal +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.localNotUniversal + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.localNotUniversal " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.hiddenDifference +#print axioms CoreReader.Evidence.hiddenDifference +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.hiddenDifference + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.hiddenDifference " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.singleObservation +#print axioms CoreReader.Evidence.singleObservation +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.singleObservation + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.singleObservation " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.noUniversalChain +#print axioms CoreReader.Evidence.noUniversalChain +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.noUniversalChain + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.noUniversalChain " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.variableOutcomesStableBound +#print axioms CoreReader.Evidence.variableOutcomesStableBound +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.variableOutcomesStableBound + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.variableOutcomesStableBound " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.verificationReproductionStability +#print axioms CoreReader.Evidence.verificationReproductionStability +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.verificationReproductionStability + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.verificationReproductionStability " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.outputNotExplanation +#print axioms CoreReader.Evidence.outputNotExplanation +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.outputNotExplanation + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.outputNotExplanation " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.applicationContractsDiffer +#print axioms CoreReader.Evidence.applicationContractsDiffer +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.applicationContractsDiffer + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.applicationContractsDiffer " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.externalAssessment +#print axioms CoreReader.Evidence.externalAssessment +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.externalAssessment + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.externalAssessment " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.inventoryNotCapability +#print axioms CoreReader.Agency.inventoryNotCapability +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.inventoryNotCapability + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.inventoryNotCapability " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Choice.statusOnlyFails +#print axioms CoreReader.Choice.statusOnlyFails +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Choice.statusOnlyFails + Lean.logInfo ("ORGANON_TYPE CoreReader.Choice.statusOnlyFails " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Choice.conventionWithReason +#print axioms CoreReader.Choice.conventionWithReason +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Choice.conventionWithReason + Lean.logInfo ("ORGANON_TYPE CoreReader.Choice.conventionWithReason " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Choice.generalGroundsNotChoice +#print axioms CoreReader.Choice.generalGroundsNotChoice +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Choice.generalGroundsNotChoice + Lean.logInfo ("ORGANON_TYPE CoreReader.Choice.generalGroundsNotChoice " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Choice.singleFeasible +#print axioms CoreReader.Choice.singleFeasible +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Choice.singleFeasible + Lean.logInfo ("ORGANON_TYPE CoreReader.Choice.singleFeasible " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Choice.localNotGlobal +#print axioms CoreReader.Choice.localNotGlobal +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Choice.localNotGlobal + Lean.logInfo ("ORGANON_TYPE CoreReader.Choice.localNotGlobal " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Choice.internalReasons +#print axioms CoreReader.Choice.internalReasons +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Choice.internalReasons + Lean.logInfo ("ORGANON_TYPE CoreReader.Choice.internalReasons " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Choice.openNotEquivalent +#print axioms CoreReader.Choice.openNotEquivalent +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Choice.openNotEquivalent + Lean.logInfo ("ORGANON_TYPE CoreReader.Choice.openNotEquivalent " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Integration.revisionKeepsConsistency +#print axioms CoreReader.Integration.revisionKeepsConsistency +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Integration.revisionKeepsConsistency + Lean.logInfo ("ORGANON_TYPE CoreReader.Integration.revisionKeepsConsistency " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Integration.ownCapabilityGrounded +#print axioms CoreReader.Integration.ownCapabilityGrounded +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Integration.ownCapabilityGrounded + Lean.logInfo ("ORGANON_TYPE CoreReader.Integration.ownCapabilityGrounded " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Integration.groundsSelfAssessment +#print axioms CoreReader.Integration.groundsSelfAssessment +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Integration.groundsSelfAssessment + Lean.logInfo ("ORGANON_TYPE CoreReader.Integration.groundsSelfAssessment " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Integration.existingPhilosophyNotPrivileged +#print axioms CoreReader.Integration.existingPhilosophyNotPrivileged +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Integration.existingPhilosophyNotPrivileged + Lean.logInfo ("ORGANON_TYPE CoreReader.Integration.existingPhilosophyNotPrivileged " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Agency.generationNotReflexivity +#print axioms CoreReader.Agency.generationNotReflexivity +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Agency.generationNotReflexivity + Lean.logInfo ("ORGANON_TYPE CoreReader.Agency.generationNotReflexivity " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Integration.charterNotGrounds +#print axioms CoreReader.Integration.charterNotGrounds +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Integration.charterNotGrounds + Lean.logInfo ("ORGANON_TYPE CoreReader.Integration.charterNotGrounds " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Integration.applicationRetainsDuties +#print axioms CoreReader.Integration.applicationRetainsDuties +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Integration.applicationRetainsDuties + Lean.logInfo ("ORGANON_TYPE CoreReader.Integration.applicationRetainsDuties " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Integration.reasonsBelongToCommitments +#print axioms CoreReader.Integration.reasonsBelongToCommitments +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Integration.reasonsBelongToCommitments + Lean.logInfo ("ORGANON_TYPE CoreReader.Integration.reasonsBelongToCommitments " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Evidence.nonExecutableAssessment +#print axioms CoreReader.Evidence.nonExecutableAssessment +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Evidence.nonExecutableAssessment + Lean.logInfo ("ORGANON_TYPE CoreReader.Evidence.nonExecutableAssessment " ++ (Lean.Json.str (reprStr info.type)).compress) +#check CoreReader.Integration.applicationVariation +#print axioms CoreReader.Integration.applicationVariation +run_cmd do + let info ← Lean.getConstInfo `CoreReader.Integration.applicationVariation + Lean.logInfo ("ORGANON_TYPE CoreReader.Integration.applicationVariation " ++ (Lean.Json.str (reprStr info.type)).compress) diff --git a/lean/philosophy/evidence/declaration-types.json b/lean/philosophy/evidence/declaration-types.json new file mode 100644 index 0000000..6a1ded1 --- /dev/null +++ b/lean/philosophy/evidence/declaration-types.json @@ -0,0 +1,254 @@ +{ + "CoreReader.Integration.jointWitness": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.System []))\n (Lean.Expr.lam\n `s\n (Lean.Expr.const `CoreReader.Integration.System [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `CoreReader.Integration.World [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Admissible [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.systemHeld []) (Lean.Expr.bvar 1)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.systemContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.Charter []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.OwnCapabilityDuty []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.systemCapability []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.requirements [])\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.Method.realize [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.method [])\n (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.const `CoreReader.Choice.objectiveReason [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `c\n (Lean.Expr.const `CoreReader.Integration.Commitment [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentClaim [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.System []))\n (Lean.Expr.bvar 1))\n (Lean.Expr.const `CoreReader.Integration.actualSystem [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.actual [])))))))))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default))", + "sha256": "dad931194e28b783758526be24d06dac429ccbeb57a5a3f5c80e0cad222cfac6" + }, + "CoreReader.Agency.Generative": { + "type": "Lean.Expr.forallE\n `p\n (Lean.Expr.const `CoreReader.Agency.Policy [])\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default)", + "sha256": "5abf5b02f1317efd145abf9c7e2250c40fe0338597fbde695b19704a7358b2d9" + }, + "CoreReader.Agency.permissionNotValuation": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Policy.permitsVersion [])\n (Lean.Expr.const `CoreReader.Agency.neutralPolicy []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.const `CoreReader.Agency.neutralPolicy []))))", + "sha256": "48d5f6ad7b8a2cad12991978a9c6e1935da61fd5e29a47bad8be1944ec9d583a" + }, + "CoreReader.Agency.revisabilityCovers": { + "type": "Lean.Expr.forallE\n `p\n (Lean.Expr.const `CoreReader.Agency.Policy [])\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Generative []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `k\n (Lean.Expr.const `CoreReader.Agency.FormKind [])\n (Lean.Expr.forallE\n `v\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `hc\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Policy.current []) (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Form.mk []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Policy.revisable []) (Lean.Expr.bvar 4))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Form.mk []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "f85088f4ea31cbc58e54317eb4757866d4ee7462b1df7211e3502845e2ceadc2" + }, + "CoreReader.Agency.revisionWithoutProgress": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.const `CoreReader.Agency.openPolicy [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `k\n (Lean.Expr.const `CoreReader.Agency.FormKind [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Policy.revisable [])\n (Lean.Expr.const `CoreReader.Agency.openPolicy []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Form.mk []) (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.BinderInfo.default)))\n (Lean.Expr.forallE\n `t\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.stableTrace []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.stableTrace [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `instHAdd [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instAddNat [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))))\n (Lean.BinderInfo.default)))", + "sha256": "0837fbe429c46c0de4ae2dca13e61a8816da6d729be2aa9c82806c1c6fff9927" + }, + "CoreReader.Agency.generationLimits": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.policy [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Policy.permitsVersion [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.policy [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.const `CoreReader.Agency.inflatedState []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLTNat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.inventory [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.inventory [])\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLTNat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.abstractionLayers [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.abstractionLayers [])\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLTNat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.vocabulary [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.vocabulary [])\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.const `CoreReader.Agency.availableResources [])))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Option.some [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 6)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 6)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.letE\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `__src.«_@».CoreReader.Agency 2099545508) \"_hygCtx\") \"_hyg\") 66)\n (Lean.Expr.const `CoreReader.Agency.ExternalResources [])\n (Lean.Expr.const `CoreReader.Agency.availableResources [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.knowledge [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.collaborator [])\n (Lean.Expr.bvar 0)))\n true)))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.letE\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `__src.«_@».CoreReader.Agency 2099545508) \"_hygCtx\") \"_hyg\") 85)\n (Lean.Expr.const `CoreReader.Agency.ExternalResources [])\n (Lean.Expr.const `CoreReader.Agency.availableResources [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.experience [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.collaborator [])\n (Lean.Expr.bvar 0)))\n true)))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.letE\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `__src.«_@».CoreReader.Agency 2099545508) \"_hygCtx\") \"_hyg\") 104)\n (Lean.Expr.const `CoreReader.Agency.ExternalResources [])\n (Lean.Expr.const `CoreReader.Agency.availableResources [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.experience [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.knowledge [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n true)))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.State []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.requirementsMet [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.withinBudget [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.withinBudget [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.const `CoreReader.Agency.inflatedState []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.StableReason [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.Announcement []))\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.report [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.const `CoreReader.Agency.inflatedState []))\n (Lean.Expr.const `CoreReader.Agency.Operation.successor []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.owner [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.owner [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.State []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.before [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.State []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.after [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const\n `CoreReader.Agency.Announcement.reportedNewOperation\n [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.const `CoreReader.Agency.Operation.successor [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.input [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.const\n `CoreReader.Agency.Announcement.expectedOutput\n [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.claim [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.before [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.after [])\n (Lean.Expr.const\n `CoreReader.Agency.inflatedAnnouncement\n []))))))))))))))))))))))))))))", + "sha256": "a66f85d3ecf6568b98ad56fc37ae5f4b09430a9d378970b52f3b1894b32c7905" + }, + "CoreReader.Evidence.AchievementAccountability": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `achievement\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `articulations\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 1))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulation []) (Lean.Expr.bvar 2))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `actualApplicable\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `facets\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 3)))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "e8b9e0ab7116417e1e72a14b1ccdf5099f40dfddff581d7422247d809bc965eb" + }, + "CoreReader.Evidence.achievementNeedsSupport": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `achievement\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Record []) (Lean.Expr.bvar 1)))\n (Lean.Expr.forallE\n `actual\n (Lean.Expr.bvar 2)\n (Lean.Expr.forallE\n `reliableHere\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Compatible []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `support\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `And []) (Lean.Expr.app (Lean.Expr.bvar 4) (Lean.Expr.bvar 2)))\n (Lean.Expr.const `CoreReader.Evidence.ConcreteAchievementExample []))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "822b2cd2c70c2493443582652d19cda0749358f1ae5fe32b0fc2455c2f661082" + }, + "CoreReader.Logic.consequenceConsistency": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `Q\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `t\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Theory []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `c\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Context []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `inhabited\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.bvar 3))\n (Lean.Expr.lam\n `w\n (Lean.Expr.bvar 3)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consistent []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)", + "sha256": "191b2285b41211251808018ed56af50bc998cb2f059f48b01623fed7eeb33511" + }, + "CoreReader.Logic.jointConflict": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.singleton [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.premiseP []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.singleton [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.premiseRule []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.singleton [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.premiseNotQ []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.jointTheory [])))))", + "sha256": "ce600ce368828d06484c984614aec2b600ec72861b52e37df3c9d127e1869630" + }, + "CoreReader.Logic.revisionCanReverse": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))))", + "sha256": "904fee6061e034e3e5a694e9f138baa29300091ad3f835696fa0c2f1b8dfbb75" + }, + "CoreReader.Logic.contextDifferences": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `b\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `b\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.forallE\n `b\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default))))))", + "sha256": "9b30750eff84685cb7297ce22b6084325b978050dd8dec01126589d972d9dda5" + }, + "CoreReader.Logic.semanticChangeMustBeReported": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `Q\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `a\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Snapshot []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `b\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Snapshot []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `reported\n (Lean.Expr.const `Bool [])\n (Lean.Expr.forallE\n `changed\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Or [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.SameContent []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Snapshot.revisionIdentity [])\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Snapshot.revisionIdentity []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 2))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)", + "sha256": "efc916aa358c8aa833410fd4ded0335d1abee82277a97caa895c86c0956981d7" + }, + "CoreReader.Logic.representationOrderIrrelevant": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `p\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `q\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `r\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 2))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2)))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "ce06e20cbe631d314f7bdbadaa1997a5e3e337987ff75a6a1d2c1d9ee48867fe" + }, + "CoreReader.Logic.hiddenContextChangeRejected": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.scopeContext [])\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Models []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Context.assumptions [])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.const `Bool.true [])))))))", + "sha256": "58cca7210751f90e96b303a8c40928a3d735b0ec64e6ce80d5debf837a2ee8d6" + }, + "CoreReader.Logic.tensionWithoutContradiction": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lam\n `budget\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 4)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 4)))))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 6)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 6))))))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.forallE `n (Lean.Expr.const `Nat []) (Lean.Expr.sort (Lean.Level.zero)) (Lean.BinderInfo.default)))\n (Lean.Expr.lam\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 4)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 4)))))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.lam\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 6)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 6)))))\n (Lean.BinderInfo.default))))", + "sha256": "c9dfa385d1b60a11fa792962c10a8b8541b2eb7d20879a306e758de9c40f4bfa" + }, + "CoreReader.Logic.conflictRequiresChange": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `Q\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `t\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Theory []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `c\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Context []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `q\n (Lean.Expr.bvar 2)\n (Lean.Expr.forallE\n `positive\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.forallE\n `negative\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.const `Bool.false []))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consistent []) (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)", + "sha256": "4b3231ac25a534c2699cd8f548a59a7d8beb1cb3923456f10c95081a3b6b5be3" + }, + "CoreReader.Logic.consistentFalse": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Models []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `Bool.false [])))", + "sha256": "617a316a7963ffe373dd9f48edb8ade6c82b6a1018f83c0d7832917977c953e8" + }, + "CoreReader.Logic.consistentIncomplete": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))", + "sha256": "4a043245371faf22b23e9eef01ba9b03c92d959166ff9e68e427b560343dbe8f" + }, + "CoreReader.Agency.Reflexive": { + "type": "Lean.Expr.forallE\n `owner\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `rules\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "edd8696ffc9dbc88b13d4e0a1d24912d33ece35258a72c2714303ec2b75d0247" + }, + "CoreReader.Agency.noSelfExemption": { + "type": "Lean.Expr.forallE\n `owner\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `rules\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Reflexive []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `rule\n (Lean.Expr.const `CoreReader.Agency.Principle [])\n (Lean.Expr.forallE\n `hr\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Membership.mem [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `s\n (Lean.Expr.const `CoreReader.Agency.Subject [])\n (Lean.Expr.forallE\n `hs\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Subject.owner []) (Lean.Expr.bvar 0)))\n (Lean.Expr.bvar 6))\n (Lean.Expr.forallE\n `ha\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Principle.applicable []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Performed []) (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 2))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Principle.activity []) (Lean.Expr.bvar 4)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "af1ee7c715a8432d4c92816c109aee67732d8307aeaab1d6a8d66ef14f4f9e80" + }, + "CoreReader.Agency.applicabilityRetained": { + "type": "Lean.Expr.forallE\n `owner\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `rules\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Reflexive []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.ReflexiveScope []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.ReflexiveScope []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.forallE\n `rule\n (Lean.Expr.const `CoreReader.Agency.Principle [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Membership.mem [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `s\n (Lean.Expr.const `CoreReader.Agency.Subject [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Subject.owner []) (Lean.Expr.bvar 0)))\n (Lean.Expr.bvar 5))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Or [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Principle.applicable [])\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Performed []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Principle.activity [])\n (Lean.Expr.bvar 3))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Reflexive [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.const `CoreReader.Agency.applicationRule []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))))\n (Lean.Expr.const `CoreReader.Agency.applicationWork [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Performed [])\n (Lean.Expr.const `CoreReader.Agency.applicationWork []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Subject.system [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `CoreReader.Agency.Activity.assessment []))))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "bc78545b62c505f56ce296e85615d7fa73b1a61c223696c87dc8bb532f6e9316" + }, + "CoreReader.Agency.selfTestDoesNotProve": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.selfTest [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `List.cons [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app (Lean.Expr.const `List.nil [Lean.Level.zero]) (Lean.Expr.const `Nat [])))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ownArithmeticPrinciple [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.forallE\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.ownArithmeticPrinciple []) (Lean.Expr.bvar 0)))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))", + "sha256": "bbc48f4b905f196e6c939615e1e8deb2b82ba924ea85d87214b3a9db96bcc67d" + }, + "CoreReader.Evidence.selfOriginDoesNotSupport": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.const `CoreReader.Evidence.allTrue []))))\n (Lean.Expr.const `CoreReader.Evidence.OwnedRevisionExample []))))", + "sha256": "3a32d7d0b5d238eb04c1ff3c4040363e9eba221e1304bb0160579141572bd88e" + }, + "CoreReader.Evidence.Grounds": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `claim\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `articulations\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 1))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulation []) (Lean.Expr.bvar 2))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `actualApplicable\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `facets\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 3)))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "4517c2eaf39a10fcd99876dc5a244ff06747ca6c130c8c03c7da6860e7bd2e12" + }, + "CoreReader.Evidence.supportWeakening": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Record []) (Lean.Expr.bvar 0)))\n (Lean.Expr.forallE\n `p\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `q\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 2))\n (Lean.Expr.forallE\n `support\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `weaker\n (Lean.Expr.forallE\n `w\n (Lean.Expr.bvar 4)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 2))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "c687c4deee04291784db05208dfae9b0d299ee0512dcdf74786cea5919b7a9ef" + }, + "CoreReader.Evidence.scopeRestriction": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `X\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Record []) (Lean.Expr.bvar 1)))\n (Lean.Expr.forallE\n `p\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 2)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 2)\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `wide\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 2)\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `narrow\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 3)\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `included\n (Lean.Expr.forallE\n `x\n (Lean.Expr.bvar 4)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 1) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `support\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 4))\n (Lean.Expr.lam\n `w\n (Lean.Expr.bvar 6)\n (Lean.Expr.forallE\n `x\n (Lean.Expr.bvar 6)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 4) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.app (Lean.Expr.bvar 6) (Lean.Expr.bvar 2)) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 5))\n (Lean.Expr.lam\n `w\n (Lean.Expr.bvar 7)\n (Lean.Expr.forallE\n `x\n (Lean.Expr.bvar 7)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 4) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.app (Lean.Expr.bvar 7) (Lean.Expr.bvar 2)) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)", + "sha256": "d20c49b2b30fa2639dcb643d5e085dc69f604e8fcd6b63523a0f635d157a33ce" + }, + "CoreReader.Evidence.assessmentUnion": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `a\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 0))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `b\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 1))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Duties []) (Lean.Expr.bvar 2))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Or []) (Lean.Expr.app (Lean.Expr.bvar 2) (Lean.Expr.bvar 0)))\n (Lean.Expr.app (Lean.Expr.bvar 1) (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Duties []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Duties []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "b4e682692e878b15864ca7fbab372218fd46ce2faacd91e88991bc49ce1b4764" + }, + "CoreReader.Evidence.labelsCannotWaive": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `xs\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `String []))\n (Lean.Expr.forallE\n `ys\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `String []))\n (Lean.Expr.forallE\n `a\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.LabeledDuties []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.LabeledDuties []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "4aa38f6f1cacfad2600cd191577020eebf845efd0f76b6e546aceb92f46a17ad" + }, + "CoreReader.Evidence.mixedMissingResponsibility": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.LabeledDuties []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `List.nil [Lean.Level.zero]) (Lean.Expr.const `String [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Or [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet.value []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.unsupportedPosition []))))\n (Lean.BinderInfo.default))))", + "sha256": "a3b8b9d25b7920c39ba44034d45faba23a579fac6b9bce01044a6ef8270a80c4" + }, + "CoreReader.Evidence.articulationNotSupport": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulated []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.uninformativeArgument [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulation.assumptions []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.uninformativeArgument [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))", + "sha256": "85f13987f0b8fce1cae5bbb59711d18a0c887a38e73b8bd00e1fd6b1c34fbfac" + }, + "CoreReader.Evidence.measurementRepeatNotSupport": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record.test [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.const `Bool.true []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))))\n (Lean.Expr.lam\n `w\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.snd [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))))))\n (Lean.Expr.lam\n `w\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.snd [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.consequence [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.consequence [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))))))))", + "sha256": "a1ca8f88b3e278adc56e4943aeea5513afbc3a4b45fc6aab79322bb788553da8" + }, + "CoreReader.Logic.compatibilityNotEntailment": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))", + "sha256": "244a4c828b24802472a24f81b01a70de6e709e44128ed21a8515578c2498843a" + }, + "CoreReader.Evidence.selfAssertionNotReason": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.commitment [])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.unsupportedPosition []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.unsupportedPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.Position [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.reasons [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.Position [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.commitment [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.consequence [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.JointAdoption [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))", + "sha256": "8a3f43790ce0efbba6a4f2be8e1eebe1ea1ff6f0df1051bad2eeda3a73329895" + }, + "CoreReader.Evidence.valueWithoutSelfProof": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValuePosition.starting []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.commitment [])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.JointAdoption []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.oppositePosition [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.oppositePosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.contradictoryStartingPosition []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.impossibleAdoptionPosition [])))))))", + "sha256": "568b8ffce3fb2209e2c6e258286982e02357a12f7df5daf2df0013af31ace2a5" + }, + "CoreReader.Evidence.heterogeneousReasons": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet.inferential []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet.value []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition []))))\n (Lean.Expr.const `CoreReader.Evidence.JointReasonsExample [])))", + "sha256": "c224d6fd8d50802cf08feb6f03c519161f4161cbcc1ccb85aca1d428bab6507e" + }, + "CoreReader.Evidence.localNotUniversal": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lam\n `outside\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 2451398637) \"_hygCtx\") \"_hyg\") 33)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 2451398637) \"_hygCtx\") \"_hyg\") 57)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])))))))", + "sha256": "c551de35323f24746aadf22a6611ebacdb1cb94e8b4395566041cea3514158ab" + }, + "CoreReader.Evidence.hiddenDifference": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 3849707129) \"_hygCtx\") \"_hyg\") 28)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 3849707129) \"_hygCtx\") \"_hyg\") 45)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))", + "sha256": "9d56436068f437ca82a13d660b482c2c010378472a97d87202c93c58cc14f534" + }, + "CoreReader.Evidence.singleObservation": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.lam\n `f\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.lam\n `f\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.bvar 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])))))", + "sha256": "7e3fa4592c2b19d90c2f858f7168ded7b64f30e40cf7c0232ac87752ced3204c" + }, + "CoreReader.Evidence.noUniversalChain": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.usesObservation []) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet [])))\n (Lean.Expr.const `Bool.false []))", + "sha256": "f0ef7c27557eaa39351f56c8807f56428d4b3bf3e7adfcd888ebd0ecd2ec64a4" + }, + "CoreReader.Evidence.variableOutcomesStableBound": { + "type": "Lean.Expr.letE\n `a\n (Lean.Expr.const `CoreReader.Evidence.Trial [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.letE\n `b\n (Lean.Expr.const `CoreReader.Evidence.Trial [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Reproduced []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Trial.actualOutcome []) (Lean.Expr.bvar 1)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Trial.actualOutcome []) (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Bounded []) (Lean.Expr.bvar 1)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Bounded []) (Lean.Expr.bvar 0)))))\n true)\n true", + "sha256": "a0bb99242c31620ee4c5b6e988883f3aa22b64126ffee1e765f5520bda35f61f" + }, + "CoreReader.Evidence.verificationReproductionStability": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Reproduced [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Reproduced [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2))))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Bounded [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2))))))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Bounded [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Bounded [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))))))", + "sha256": "a92288aebed02e0acbf848f44ff85a32e40821fecafc92bb8ce7dcb89a31c74e" + }, + "CoreReader.Evidence.outputNotExplanation": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))))\n (Lean.Expr.const `CoreReader.Evidence.OutputContractEvidence []))", + "sha256": "43406d330c84bc09d691acee59de1fc29de6234aeb88fe44733b301b919f3fd7" + }, + "CoreReader.Evidence.applicationContractsDiffer": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.explainedProcess [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.explainedProcess []))))\n (Lean.Expr.const `CoreReader.Evidence.ScopedApplicationEvidence []))", + "sha256": "a527a2020908a813787d377f4918c57975e27b6bd8d6449e15be34c05c40489e" + }, + "CoreReader.Evidence.externalAssessment": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.lam\n `certificate\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessorId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 42)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 42))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessedId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 7)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 7))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessorId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessedId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ProcessGrounds [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))))", + "sha256": "fe5654cff59f9fdd8d2c45b06fb9c074424a4dc98b3f9131c1fbce46b08f9cee" + }, + "CoreReader.Agency.inventoryNotCapability": { + "type": "Lean.Expr.forallE\n `kind\n (Lean.Expr.const `CoreReader.Agency.InventoryKind [])\n (Lean.Expr.forallE\n `ops\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.forallE\n `op\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Available [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `HAppend.hAppend [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `instHAppendOfAppend [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.instAppend [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.map [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.lam\n `x\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Item.mk []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.map [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.lam\n `x\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Item.mk []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Available [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.map [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.lam\n `x\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Item.mk []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "c42372dbdafd2e978ce5040103e18e2e8a26326e3f9eae43e2c902e076ab5d23" + }, + "CoreReader.Choice.statusOnlyFails": { + "type": "Lean.Expr.forallE\n `req\n (Lean.Expr.const `CoreReader.Choice.Requirements [])\n (Lean.Expr.forallE\n `i\n (Lean.Expr.const `CoreReader.Choice.Implementation [])\n (Lean.Expr.forallE\n `k\n (Lean.Expr.const `CoreReader.Choice.StatusKind [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.JustifiedChoice []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.Reason.status []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason [])))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "5e18307d2fd827fe08aa1e168caa706d5bcd1aa43c40eec1b7c6ff91b81e66f0" + }, + "CoreReader.Choice.conventionWithReason": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.conventional [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl [])))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.established [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl [])))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `List.cons [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.status [])\n (Lean.Expr.const `CoreReader.Choice.StatusKind.convention [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.output [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))))))", + "sha256": "ac0033fbed40e31d070cb960495ad45eb8726534475c7329dca05c8da8f6a1e5" + }, + "CoreReader.Choice.generalGroundsNotChoice": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Articulated [])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Choice.priorityArticulation [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.AssessmentAccurate []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `selected\n (Lean.Expr.const `CoreReader.Choice.Candidate [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Models [])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Choice.statusFacts []))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.priorityClaim [])\n (Lean.Expr.const `CoreReader.Choice.Candidate.identity [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.priorityClaim [])\n (Lean.Expr.const `CoreReader.Choice.Candidate.successor []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Entails [])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Choice.statusFacts []))\n (Lean.Expr.const `CoreReader.Choice.priorityClaim []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.status [])\n (Lean.Expr.const `CoreReader.Choice.StatusKind.standing [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))))))))))))\n (Lean.Expr.const `CoreReader.Choice.PolicyIndependenceExample [])", + "sha256": "eee90ae5540da7b23ad95176b6a736267b8b4ef0e9413bed8e5045fb71acaddc" + }, + "CoreReader.Choice.singleFeasible": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `candidate\n (Lean.Expr.const `CoreReader.Choice.Candidate [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Feasible [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.implementation []) (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Choice.Candidate.identity [])))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.const `CoreReader.Choice.objectiveReason []))", + "sha256": "f3437f4015fdbcf92e04b7da7b29f047b90d4189c21e558d82314ff75051b319" + }, + "CoreReader.Choice.localNotGlobal": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `x\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.changedOutsideZero []))\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.changedOutsideZero []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))", + "sha256": "e536339546398c5b31cb38c3a821354d883487b067c95607379060c352460ccd" + }, + "CoreReader.Choice.internalReasons": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.explanation []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.applicability []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.simplicity []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.procedure []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.cheapSuccessor []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.simplicity []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.cheapSuccessor []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.simplicity [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason [])))))))))", + "sha256": "1ec7968d246d20d2b1493c1e285053ff3d37fd3fc2c90aa7ce1af6fd73464926" + }, + "CoreReader.Choice.openNotEquivalent": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.const `CoreReader.Choice.objectiveReason [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.successorImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))", + "sha256": "50e8d5c0a1072c29f5281a230d2329b8e7c22f8abc90a8222f7689c81806b65d" + }, + "CoreReader.Integration.revisionKeepsConsistency": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.Charter [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Consistent [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.const `CoreReader.Integration.revisedHeld []))\n (Lean.Expr.const `CoreReader.Integration.context [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.TruthfulReport [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.const `CoreReader.Integration.initialSnapshot []))\n (Lean.Expr.const `CoreReader.Integration.revisedSnapshot []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.TruthfulReport [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.const `CoreReader.Integration.initialSnapshot []))\n (Lean.Expr.const `CoreReader.Integration.revisedSnapshot []))\n (Lean.Expr.const `Bool.false [])))))", + "sha256": "3aab586ee7ffced9c73f73f9eef729d01d47a6bbb0df57d834248a6b2a439e0f" + }, + "CoreReader.Integration.ownCapabilityGrounded": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.OwnCapabilityDuty [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.capability [])\n (Lean.Expr.const `CoreReader.Integration.actual []))", + "sha256": "42bfb4a096464e6d78e2b2fab189eab062eccc80015fff1c83d501d91b7f5a0b" + }, + "CoreReader.Integration.groundsSelfAssessment": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `CoreReader.Integration.World [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.GroundsProvision [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.snd [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Integration.Mode []))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.limits [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentPosition [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.relevantCriticism [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentPosition [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentPositionFor [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds []))\n (Lean.Expr.const `CoreReader.Integration.Mode.waive []))))))", + "sha256": "84129ee9e21d37bed63d1ba724e180ef0d35eaa8a3301454c50137e2e2ba682d" + }, + "CoreReader.Integration.existingPhilosophyNotPrivileged": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.Form []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.form [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.principleForm [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.Mode []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.mode [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.governance [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Integration.proposalRequirements []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.implementation [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.status [])\n (Lean.Expr.const `CoreReader.Choice.StatusKind.standing [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Integration.proposalRequirements []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.implementation [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.output [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.review [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.review [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))))", + "sha256": "1ec61cc64f16f1a54396b2b73da6f7aa90251e6563d882b8f92b3af2d8128151" + }, + "CoreReader.Agency.generationNotReflexivity": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.const `CoreReader.Agency.openPolicy [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Reflexive [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ownRules [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app (Lean.Expr.const `List.nil [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))))", + "sha256": "c6ba911bc5b6a702eeddb7e1c345e58c099b2032b097a36768b315f016ea31a6" + }, + "CoreReader.Integration.charterNotGrounds": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.Charter [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.costAllowanceRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.capability []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.unsupportedCapabilityFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.unsupportedCapabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))))", + "sha256": "27e83eb0e659bf4c081cd29c507d09939dc4a07b00996d95f03220f991771f25" + }, + "CoreReader.Integration.applicationRetainsDuties": { + "type": "Lean.Expr.forallE\n `s\n (Lean.Expr.const `CoreReader.Integration.System [])\n (Lean.Expr.forallE\n `w\n (Lean.Expr.const `CoreReader.Integration.World [])\n (Lean.Expr.forallE\n `req\n (Lean.Expr.const `CoreReader.Choice.Requirements [])\n (Lean.Expr.forallE\n `contract\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Choice.Requirements [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Choice.Implementation [])\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `articulations\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Articulation [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `applicable\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `facets\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.ApplicationDuties [])\n (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Reflexive [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.System.owner []) (Lean.Expr.bvar 7)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.System.rules []) (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 6)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.System.work []) (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 6))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const\n `Membership.mem\n [Lean.Level.succ (Lean.Level.zero), Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.forallE\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const\n `Membership.mem\n [Lean.Level.succ (Lean.Level.zero), Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Claim [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet.claim [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.applicationClaim [])\n (Lean.Expr.bvar 9))\n (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 6))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Articulated [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.bvar 5) (Lean.Expr.bvar 1))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.FacetArticulated [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.bvar 5) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.FacetDischarged [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.bvar 1)))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "651f3b9c399a82d84279c623426939d6383c20da613db99958f86c454866fef3" + }, + "CoreReader.Integration.reasonsBelongToCommitments": { + "type": "Lean.Expr.forallE\n `c\n (Lean.Expr.const `CoreReader.Integration.Commitment [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentClaim []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentFacet []) (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentFacet []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.JointAdoption [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentPosition []) (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.relevantCriticism [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentPosition []) (Lean.Expr.bvar 0)))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentPositionFor []) (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.Mode.waive [])))))))\n (Lean.BinderInfo.default)", + "sha256": "6323d4f56fb47c305d52b3f61a3fd8086550b60929520138401ced1e161120f8" + }, + "CoreReader.Evidence.nonExecutableAssessment": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Grounds []) (Lean.Expr.const `Nat []))\n (Lean.Expr.lam\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `instHAdd [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instAddNat [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation []) (Lean.Expr.const `Nat [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat [])))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.usesObservation []) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet [])))\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.usesObservation []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.const `Bool.true []))))", + "sha256": "6909f108bbe2e4fd72181deb801b653071f204ab688a8a4cc7e99c4ede0d2728" + }, + "CoreReader.Integration.applicationVariation": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.ApplicationDuties [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Integration.outputContract []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.applicationClaim [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.successorRequirements []))\n (Lean.Expr.const `CoreReader.Integration.outputContract []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.applicationClaim [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.successorRequirements []))\n (Lean.Expr.const `CoreReader.Integration.outputContract [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.changedObjectiveFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.changedObjectiveFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))))", + "sha256": "8c23f5b979f61d621e8ee78193561d5f1251459dc992801be540bee18948150e" + } +} diff --git a/lean/philosophy/evidence/execution-identity.json b/lean/philosophy/evidence/execution-identity.json new file mode 100644 index 0000000..2ab482f --- /dev/null +++ b/lean/philosophy/evidence/execution-identity.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "assessment": "self_reported_not_approval", + "sources_at_module_load": { + "skills/organon-core-leanify-prove/scripts/check.js": "74194794f7b058740255aa0ad8099b2c27bc8b4cf82cbf0f1336fc03f5348240", + "skills/organon-core-leanify-prove/scripts/manuscript.js": "e1aed330b703c2a5901e0cbca4b47b4d75602375646a462ced2e268f1aba4dcc", + "skills/organon-core-leanify-prove/scripts/targets.js": "cab6a7a55b852a2f29ca00ef9f03331a30549b2ba16d32d69138f488fdbc8888", + "scripts/lib/sections.js": "35c8cc81ea851e79af7ef9996e800112efa97c71005abecd59287a52ba8da180", + "scripts/lib/frontmatter.js": "42773238b4a39f6d5d374a814b5e23821340d55aea3e1972e5cac5a6820c354e" + }, + "node": { + "status": "observed", + "version": "v22.23.2" + }, + "lean": { + "status": "observed", + "version": "4.33.1" + }, + "lake": { + "status": "observed", + "version": "5.0.0-src+819816b" + } +} diff --git a/lean/philosophy/evidence/inputs-sha256.json b/lean/philosophy/evidence/inputs-sha256.json new file mode 100644 index 0000000..f59f508 --- /dev/null +++ b/lean/philosophy/evidence/inputs-sha256.json @@ -0,0 +1,14 @@ +{ + "run.json": "773ef6bd7c459a65cc678d26d7561c04453c50f0afb92b77bcbf72da6171c8b2", + "PREREGISTERED.md": "242feb5156c4dd9b7d47dcf712a8c196131a2907ea331d06d4aab8ea8fe3a079", + "snapshots/PHILOSOPHY.md": "226fa3522943955d5a0f1f0b88e883c97b3505b3bcfd285329e432757912543f", + "leanified/lakefile.toml": "45b7327bd68ebe8cbca3dccd419df21e4876773005900079cd7c6fdf0f43dd49", + "targets.json": "2400383120ab2d98454597a73cdcaaadf45b8e47b18a646118708dc5d81da2a4", + "leanified/CoreReader/Agency.lean": "b0dca4187a88a0a0f33c3dd6a11bb383907603ef514e80e9e3f09f95ce9633e2", + "leanified/CoreReader/Choice.lean": "07cf17f73802bdd34ae00ecba317ddc0283321cce00f15a84b69df421c3fe25f", + "leanified/CoreReader/Evidence.lean": "18beb2b94450fdab36229b645e2df129348f3e67306104e842e0dce6e72443e8", + "leanified/CoreReader/Integration.lean": "b5ba8617e06f03963c4284344fbe3c662188f1b88542c55cc15beb1cd5f99c03", + "leanified/CoreReader/Logic.lean": "6b70be8964763b6447a2603bde665ff58106678f2e1d421bebd8c6b29ae46e04", + "leanified/CoreReader/Reflexivity.lean": "25292faa71c5585a8f50cb07d72c2f44fa12dcfb125b2b92094f9306fecb4fd0", + "leanified/CoreReader.lean": "80eee78ec3453fefdb26d3dbce97f0447d4b9ffeb4683604dad0c03902a1bfdd" +} diff --git a/lean/philosophy/evidence/kernel.json b/lean/philosophy/evidence/kernel.json new file mode 100644 index 0000000..e0b8cdf --- /dev/null +++ b/lean/philosophy/evidence/kernel.json @@ -0,0 +1,760 @@ +{ + "passed": true, + "semantic_status": "not_evaluated", + "errors": [], + "checked": [ + "CoreReader.Integration.jointWitness", + "CoreReader.Agency.Generative", + "CoreReader.Agency.permissionNotValuation", + "CoreReader.Agency.revisabilityCovers", + "CoreReader.Agency.revisionWithoutProgress", + "CoreReader.Agency.generationLimits", + "CoreReader.Evidence.AchievementAccountability", + "CoreReader.Evidence.achievementNeedsSupport", + "CoreReader.Logic.consequenceConsistency", + "CoreReader.Logic.jointConflict", + "CoreReader.Logic.revisionCanReverse", + "CoreReader.Logic.contextDifferences", + "CoreReader.Logic.semanticChangeMustBeReported", + "CoreReader.Logic.representationOrderIrrelevant", + "CoreReader.Logic.hiddenContextChangeRejected", + "CoreReader.Logic.tensionWithoutContradiction", + "CoreReader.Logic.conflictRequiresChange", + "CoreReader.Logic.consistentFalse", + "CoreReader.Logic.consistentIncomplete", + "CoreReader.Agency.Reflexive", + "CoreReader.Agency.noSelfExemption", + "CoreReader.Agency.applicabilityRetained", + "CoreReader.Agency.selfTestDoesNotProve", + "CoreReader.Evidence.selfOriginDoesNotSupport", + "CoreReader.Evidence.Grounds", + "CoreReader.Evidence.supportWeakening", + "CoreReader.Evidence.scopeRestriction", + "CoreReader.Evidence.assessmentUnion", + "CoreReader.Evidence.labelsCannotWaive", + "CoreReader.Evidence.mixedMissingResponsibility", + "CoreReader.Evidence.articulationNotSupport", + "CoreReader.Evidence.measurementRepeatNotSupport", + "CoreReader.Logic.compatibilityNotEntailment", + "CoreReader.Evidence.selfAssertionNotReason", + "CoreReader.Evidence.valueWithoutSelfProof", + "CoreReader.Evidence.heterogeneousReasons", + "CoreReader.Evidence.localNotUniversal", + "CoreReader.Evidence.hiddenDifference", + "CoreReader.Evidence.singleObservation", + "CoreReader.Evidence.noUniversalChain", + "CoreReader.Evidence.variableOutcomesStableBound", + "CoreReader.Evidence.verificationReproductionStability", + "CoreReader.Evidence.outputNotExplanation", + "CoreReader.Evidence.applicationContractsDiffer", + "CoreReader.Evidence.externalAssessment", + "CoreReader.Agency.inventoryNotCapability", + "CoreReader.Choice.statusOnlyFails", + "CoreReader.Choice.conventionWithReason", + "CoreReader.Choice.generalGroundsNotChoice", + "CoreReader.Choice.singleFeasible", + "CoreReader.Choice.localNotGlobal", + "CoreReader.Choice.internalReasons", + "CoreReader.Choice.openNotEquivalent", + "CoreReader.Integration.revisionKeepsConsistency", + "CoreReader.Integration.ownCapabilityGrounded", + "CoreReader.Integration.groundsSelfAssessment", + "CoreReader.Integration.existingPhilosophyNotPrivileged", + "CoreReader.Agency.generationNotReflexivity", + "CoreReader.Integration.charterNotGrounds", + "CoreReader.Integration.applicationRetainsDuties", + "CoreReader.Integration.reasonsBelongToCommitments", + "CoreReader.Evidence.nonExecutableAssessment", + "CoreReader.Integration.applicationVariation" + ], + "dependencies": { + "CoreReader.Integration.jointWitness": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "CoreReader.Agency.Generative": [], + "CoreReader.Agency.permissionNotValuation": [ + "propext", + "Quot.sound" + ], + "CoreReader.Agency.revisabilityCovers": [], + "CoreReader.Agency.revisionWithoutProgress": [ + "propext", + "Quot.sound" + ], + "CoreReader.Agency.generationLimits": [ + "propext", + "Quot.sound" + ], + "CoreReader.Evidence.AchievementAccountability": [], + "CoreReader.Evidence.achievementNeedsSupport": [ + "propext", + "Quot.sound" + ], + "CoreReader.Logic.consequenceConsistency": [], + "CoreReader.Logic.jointConflict": [], + "CoreReader.Logic.revisionCanReverse": [], + "CoreReader.Logic.contextDifferences": [], + "CoreReader.Logic.semanticChangeMustBeReported": [], + "CoreReader.Logic.representationOrderIrrelevant": [], + "CoreReader.Logic.hiddenContextChangeRejected": [], + "CoreReader.Logic.tensionWithoutContradiction": [], + "CoreReader.Logic.conflictRequiresChange": [], + "CoreReader.Logic.consistentFalse": [], + "CoreReader.Logic.consistentIncomplete": [], + "CoreReader.Agency.Reflexive": [], + "CoreReader.Agency.noSelfExemption": [], + "CoreReader.Agency.applicabilityRetained": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "CoreReader.Agency.selfTestDoesNotProve": [], + "CoreReader.Evidence.selfOriginDoesNotSupport": [ + "propext" + ], + "CoreReader.Evidence.Grounds": [], + "CoreReader.Evidence.supportWeakening": [], + "CoreReader.Evidence.scopeRestriction": [], + "CoreReader.Evidence.assessmentUnion": [], + "CoreReader.Evidence.labelsCannotWaive": [], + "CoreReader.Evidence.mixedMissingResponsibility": [ + "propext" + ], + "CoreReader.Evidence.articulationNotSupport": [ + "propext" + ], + "CoreReader.Evidence.measurementRepeatNotSupport": [ + "propext" + ], + "CoreReader.Logic.compatibilityNotEntailment": [], + "CoreReader.Evidence.selfAssertionNotReason": [ + "propext" + ], + "CoreReader.Evidence.valueWithoutSelfProof": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "CoreReader.Evidence.heterogeneousReasons": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "CoreReader.Evidence.localNotUniversal": [ + "propext" + ], + "CoreReader.Evidence.hiddenDifference": [], + "CoreReader.Evidence.singleObservation": [ + "propext" + ], + "CoreReader.Evidence.noUniversalChain": [ + "propext" + ], + "CoreReader.Evidence.variableOutcomesStableBound": [ + "propext", + "Quot.sound" + ], + "CoreReader.Evidence.verificationReproductionStability": [ + "propext", + "Quot.sound" + ], + "CoreReader.Evidence.outputNotExplanation": [ + "propext" + ], + "CoreReader.Evidence.applicationContractsDiffer": [ + "propext" + ], + "CoreReader.Evidence.externalAssessment": [ + "propext" + ], + "CoreReader.Agency.inventoryNotCapability": [ + "propext", + "Quot.sound" + ], + "CoreReader.Choice.statusOnlyFails": [ + "propext" + ], + "CoreReader.Choice.conventionWithReason": [ + "propext" + ], + "CoreReader.Choice.generalGroundsNotChoice": [ + "propext" + ], + "CoreReader.Choice.singleFeasible": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "CoreReader.Choice.localNotGlobal": [], + "CoreReader.Choice.internalReasons": [], + "CoreReader.Choice.openNotEquivalent": [ + "propext" + ], + "CoreReader.Integration.revisionKeepsConsistency": [ + "propext", + "Quot.sound" + ], + "CoreReader.Integration.ownCapabilityGrounded": [ + "propext", + "Quot.sound" + ], + "CoreReader.Integration.groundsSelfAssessment": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "CoreReader.Integration.existingPhilosophyNotPrivileged": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "CoreReader.Agency.generationNotReflexivity": [ + "propext", + "Quot.sound" + ], + "CoreReader.Integration.charterNotGrounds": [ + "propext", + "Quot.sound" + ], + "CoreReader.Integration.applicationRetainsDuties": [ + "propext" + ], + "CoreReader.Integration.reasonsBelongToCommitments": [ + "propext", + "Classical.choice", + "Quot.sound" + ], + "CoreReader.Evidence.nonExecutableAssessment": [ + "propext" + ], + "CoreReader.Integration.applicationVariation": [ + "propext", + "Quot.sound" + ] + }, + "reported_reviews": [], + "proof_targets": { + "sha256": "2400383120ab2d98454597a73cdcaaadf45b8e47b18a646118708dc5d81da2a4", + "complete": true, + "semantic_status": "not_evaluated", + "entries": [ + { + "id": "T01", + "kind": "boundary", + "reported_status": "accepted", + "declarations": [] + }, + { + "id": "T02", + "kind": "satisfiability", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Integration.jointWitness" + ] + }, + { + "id": "T03", + "kind": "specification", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.Generative" + ] + }, + { + "id": "T04", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.permissionNotValuation" + ] + }, + { + "id": "T05", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.revisabilityCovers", + "CoreReader.Agency.revisionWithoutProgress" + ] + }, + { + "id": "T06", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.generationLimits" + ] + }, + { + "id": "T07", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.AchievementAccountability", + "CoreReader.Evidence.achievementNeedsSupport" + ] + }, + { + "id": "T08", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.consequenceConsistency", + "CoreReader.Logic.jointConflict" + ] + }, + { + "id": "T09", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.revisionCanReverse", + "CoreReader.Logic.contextDifferences" + ] + }, + { + "id": "T10", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.semanticChangeMustBeReported", + "CoreReader.Logic.representationOrderIrrelevant", + "CoreReader.Logic.hiddenContextChangeRejected" + ] + }, + { + "id": "T11", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.tensionWithoutContradiction", + "CoreReader.Logic.conflictRequiresChange" + ] + }, + { + "id": "T12", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.consistentFalse", + "CoreReader.Logic.consistentIncomplete" + ] + }, + { + "id": "T13", + "kind": "specification", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.Reflexive" + ] + }, + { + "id": "T14", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.noSelfExemption", + "CoreReader.Agency.applicabilityRetained", + "CoreReader.Agency.selfTestDoesNotProve", + "CoreReader.Evidence.selfOriginDoesNotSupport" + ] + }, + { + "id": "T15", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.Grounds", + "CoreReader.Evidence.supportWeakening", + "CoreReader.Evidence.scopeRestriction" + ] + }, + { + "id": "T16", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.assessmentUnion", + "CoreReader.Evidence.labelsCannotWaive", + "CoreReader.Evidence.mixedMissingResponsibility" + ] + }, + { + "id": "T17", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.articulationNotSupport", + "CoreReader.Evidence.measurementRepeatNotSupport", + "CoreReader.Logic.compatibilityNotEntailment", + "CoreReader.Evidence.selfAssertionNotReason" + ] + }, + { + "id": "T18", + "kind": "satisfiability", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.valueWithoutSelfProof", + "CoreReader.Evidence.heterogeneousReasons" + ] + }, + { + "id": "T19", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.localNotUniversal", + "CoreReader.Evidence.hiddenDifference" + ] + }, + { + "id": "T20", + "kind": "satisfiability", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.singleObservation", + "CoreReader.Evidence.noUniversalChain", + "CoreReader.Evidence.variableOutcomesStableBound", + "CoreReader.Evidence.verificationReproductionStability" + ] + }, + { + "id": "T21", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.outputNotExplanation", + "CoreReader.Evidence.applicationContractsDiffer", + "CoreReader.Evidence.externalAssessment", + "CoreReader.Agency.inventoryNotCapability" + ] + }, + { + "id": "T22", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Choice.statusOnlyFails", + "CoreReader.Choice.conventionWithReason" + ] + }, + { + "id": "T23", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Choice.generalGroundsNotChoice" + ] + }, + { + "id": "T24", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Choice.singleFeasible", + "CoreReader.Choice.localNotGlobal", + "CoreReader.Choice.internalReasons", + "CoreReader.Choice.openNotEquivalent" + ] + }, + { + "id": "T25", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Integration.revisionKeepsConsistency", + "CoreReader.Integration.ownCapabilityGrounded", + "CoreReader.Integration.groundsSelfAssessment", + "CoreReader.Integration.existingPhilosophyNotPrivileged" + ] + }, + { + "id": "T26", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.generationNotReflexivity", + "CoreReader.Integration.charterNotGrounds", + "CoreReader.Integration.jointWitness" + ] + }, + { + "id": "T27", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Integration.applicationRetainsDuties", + "CoreReader.Integration.reasonsBelongToCommitments" + ] + }, + { + "id": "T28", + "kind": "satisfiability", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.nonExecutableAssessment" + ] + } + ] + }, + "declaration_types": { + "CoreReader.Integration.jointWitness": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.System []))\n (Lean.Expr.lam\n `s\n (Lean.Expr.const `CoreReader.Integration.System [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `CoreReader.Integration.World [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Admissible [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.systemHeld []) (Lean.Expr.bvar 1)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.systemContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.Charter []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.OwnCapabilityDuty []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.systemCapability []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.requirements [])\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.Method.realize [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.method [])\n (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.const `CoreReader.Choice.objectiveReason [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `c\n (Lean.Expr.const `CoreReader.Integration.Commitment [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentClaim [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.System []))\n (Lean.Expr.bvar 1))\n (Lean.Expr.const `CoreReader.Integration.actualSystem [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.actual [])))))))))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default))", + "sha256": "dad931194e28b783758526be24d06dac429ccbeb57a5a3f5c80e0cad222cfac6" + }, + "CoreReader.Agency.Generative": { + "type": "Lean.Expr.forallE\n `p\n (Lean.Expr.const `CoreReader.Agency.Policy [])\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default)", + "sha256": "5abf5b02f1317efd145abf9c7e2250c40fe0338597fbde695b19704a7358b2d9" + }, + "CoreReader.Agency.permissionNotValuation": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Policy.permitsVersion [])\n (Lean.Expr.const `CoreReader.Agency.neutralPolicy []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.const `CoreReader.Agency.neutralPolicy []))))", + "sha256": "48d5f6ad7b8a2cad12991978a9c6e1935da61fd5e29a47bad8be1944ec9d583a" + }, + "CoreReader.Agency.revisabilityCovers": { + "type": "Lean.Expr.forallE\n `p\n (Lean.Expr.const `CoreReader.Agency.Policy [])\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Generative []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `k\n (Lean.Expr.const `CoreReader.Agency.FormKind [])\n (Lean.Expr.forallE\n `v\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `hc\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Policy.current []) (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Form.mk []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Policy.revisable []) (Lean.Expr.bvar 4))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Form.mk []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "f85088f4ea31cbc58e54317eb4757866d4ee7462b1df7211e3502845e2ceadc2" + }, + "CoreReader.Agency.revisionWithoutProgress": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.const `CoreReader.Agency.openPolicy [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `k\n (Lean.Expr.const `CoreReader.Agency.FormKind [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Policy.revisable [])\n (Lean.Expr.const `CoreReader.Agency.openPolicy []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Form.mk []) (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.BinderInfo.default)))\n (Lean.Expr.forallE\n `t\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.stableTrace []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.stableTrace [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `instHAdd [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instAddNat [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))))\n (Lean.BinderInfo.default)))", + "sha256": "0837fbe429c46c0de4ae2dca13e61a8816da6d729be2aa9c82806c1c6fff9927" + }, + "CoreReader.Agency.generationLimits": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.policy [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Policy.permitsVersion [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.policy [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.const `CoreReader.Agency.inflatedState []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLTNat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.inventory [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.inventory [])\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLTNat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.abstractionLayers [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.abstractionLayers [])\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLTNat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.vocabulary [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.vocabulary [])\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.const `CoreReader.Agency.availableResources [])))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Option.some [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 6)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 6)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.letE\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `__src.«_@».CoreReader.Agency 2099545508) \"_hygCtx\") \"_hyg\") 66)\n (Lean.Expr.const `CoreReader.Agency.ExternalResources [])\n (Lean.Expr.const `CoreReader.Agency.availableResources [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.knowledge [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.collaborator [])\n (Lean.Expr.bvar 0)))\n true)))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.letE\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `__src.«_@».CoreReader.Agency 2099545508) \"_hygCtx\") \"_hyg\") 85)\n (Lean.Expr.const `CoreReader.Agency.ExternalResources [])\n (Lean.Expr.const `CoreReader.Agency.availableResources [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.experience [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.collaborator [])\n (Lean.Expr.bvar 0)))\n true)))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.letE\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `__src.«_@».CoreReader.Agency 2099545508) \"_hygCtx\") \"_hyg\") 104)\n (Lean.Expr.const `CoreReader.Agency.ExternalResources [])\n (Lean.Expr.const `CoreReader.Agency.availableResources [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.experience [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.knowledge [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n true)))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.State []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.requirementsMet [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.withinBudget [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.withinBudget [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.const `CoreReader.Agency.inflatedState []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.StableReason [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.Announcement []))\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.report [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.const `CoreReader.Agency.inflatedState []))\n (Lean.Expr.const `CoreReader.Agency.Operation.successor []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.owner [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.owner [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.State []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.before [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.State []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.after [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const\n `CoreReader.Agency.Announcement.reportedNewOperation\n [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.const `CoreReader.Agency.Operation.successor [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.input [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.const\n `CoreReader.Agency.Announcement.expectedOutput\n [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.claim [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.before [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.after [])\n (Lean.Expr.const\n `CoreReader.Agency.inflatedAnnouncement\n []))))))))))))))))))))))))))))", + "sha256": "a66f85d3ecf6568b98ad56fc37ae5f4b09430a9d378970b52f3b1894b32c7905" + }, + "CoreReader.Evidence.AchievementAccountability": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `achievement\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `articulations\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 1))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulation []) (Lean.Expr.bvar 2))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `actualApplicable\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `facets\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 3)))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "e8b9e0ab7116417e1e72a14b1ccdf5099f40dfddff581d7422247d809bc965eb" + }, + "CoreReader.Evidence.achievementNeedsSupport": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `achievement\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Record []) (Lean.Expr.bvar 1)))\n (Lean.Expr.forallE\n `actual\n (Lean.Expr.bvar 2)\n (Lean.Expr.forallE\n `reliableHere\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Compatible []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `support\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `And []) (Lean.Expr.app (Lean.Expr.bvar 4) (Lean.Expr.bvar 2)))\n (Lean.Expr.const `CoreReader.Evidence.ConcreteAchievementExample []))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "822b2cd2c70c2493443582652d19cda0749358f1ae5fe32b0fc2455c2f661082" + }, + "CoreReader.Logic.consequenceConsistency": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `Q\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `t\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Theory []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `c\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Context []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `inhabited\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.bvar 3))\n (Lean.Expr.lam\n `w\n (Lean.Expr.bvar 3)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consistent []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)", + "sha256": "191b2285b41211251808018ed56af50bc998cb2f059f48b01623fed7eeb33511" + }, + "CoreReader.Logic.jointConflict": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.singleton [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.premiseP []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.singleton [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.premiseRule []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.singleton [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.premiseNotQ []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.jointTheory [])))))", + "sha256": "ce600ce368828d06484c984614aec2b600ec72861b52e37df3c9d127e1869630" + }, + "CoreReader.Logic.revisionCanReverse": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))))", + "sha256": "904fee6061e034e3e5a694e9f138baa29300091ad3f835696fa0c2f1b8dfbb75" + }, + "CoreReader.Logic.contextDifferences": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `b\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `b\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.forallE\n `b\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default))))))", + "sha256": "9b30750eff84685cb7297ce22b6084325b978050dd8dec01126589d972d9dda5" + }, + "CoreReader.Logic.semanticChangeMustBeReported": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `Q\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `a\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Snapshot []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `b\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Snapshot []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `reported\n (Lean.Expr.const `Bool [])\n (Lean.Expr.forallE\n `changed\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Or [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.SameContent []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Snapshot.revisionIdentity [])\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Snapshot.revisionIdentity []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 2))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)", + "sha256": "efc916aa358c8aa833410fd4ded0335d1abee82277a97caa895c86c0956981d7" + }, + "CoreReader.Logic.representationOrderIrrelevant": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `p\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `q\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `r\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 2))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2)))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "ce06e20cbe631d314f7bdbadaa1997a5e3e337987ff75a6a1d2c1d9ee48867fe" + }, + "CoreReader.Logic.hiddenContextChangeRejected": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.scopeContext [])\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Models []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Context.assumptions [])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.const `Bool.true [])))))))", + "sha256": "58cca7210751f90e96b303a8c40928a3d735b0ec64e6ce80d5debf837a2ee8d6" + }, + "CoreReader.Logic.tensionWithoutContradiction": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lam\n `budget\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 4)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 4)))))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 6)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 6))))))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.forallE `n (Lean.Expr.const `Nat []) (Lean.Expr.sort (Lean.Level.zero)) (Lean.BinderInfo.default)))\n (Lean.Expr.lam\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 4)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 4)))))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.lam\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 6)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 6)))))\n (Lean.BinderInfo.default))))", + "sha256": "c9dfa385d1b60a11fa792962c10a8b8541b2eb7d20879a306e758de9c40f4bfa" + }, + "CoreReader.Logic.conflictRequiresChange": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `Q\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `t\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Theory []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `c\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Context []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `q\n (Lean.Expr.bvar 2)\n (Lean.Expr.forallE\n `positive\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.forallE\n `negative\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.const `Bool.false []))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consistent []) (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)", + "sha256": "4b3231ac25a534c2699cd8f548a59a7d8beb1cb3923456f10c95081a3b6b5be3" + }, + "CoreReader.Logic.consistentFalse": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Models []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `Bool.false [])))", + "sha256": "617a316a7963ffe373dd9f48edb8ade6c82b6a1018f83c0d7832917977c953e8" + }, + "CoreReader.Logic.consistentIncomplete": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))", + "sha256": "4a043245371faf22b23e9eef01ba9b03c92d959166ff9e68e427b560343dbe8f" + }, + "CoreReader.Agency.Reflexive": { + "type": "Lean.Expr.forallE\n `owner\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `rules\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "edd8696ffc9dbc88b13d4e0a1d24912d33ece35258a72c2714303ec2b75d0247" + }, + "CoreReader.Agency.noSelfExemption": { + "type": "Lean.Expr.forallE\n `owner\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `rules\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Reflexive []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `rule\n (Lean.Expr.const `CoreReader.Agency.Principle [])\n (Lean.Expr.forallE\n `hr\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Membership.mem [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `s\n (Lean.Expr.const `CoreReader.Agency.Subject [])\n (Lean.Expr.forallE\n `hs\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Subject.owner []) (Lean.Expr.bvar 0)))\n (Lean.Expr.bvar 6))\n (Lean.Expr.forallE\n `ha\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Principle.applicable []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Performed []) (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 2))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Principle.activity []) (Lean.Expr.bvar 4)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "af1ee7c715a8432d4c92816c109aee67732d8307aeaab1d6a8d66ef14f4f9e80" + }, + "CoreReader.Agency.applicabilityRetained": { + "type": "Lean.Expr.forallE\n `owner\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `rules\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Reflexive []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.ReflexiveScope []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.ReflexiveScope []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.forallE\n `rule\n (Lean.Expr.const `CoreReader.Agency.Principle [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Membership.mem [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `s\n (Lean.Expr.const `CoreReader.Agency.Subject [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Subject.owner []) (Lean.Expr.bvar 0)))\n (Lean.Expr.bvar 5))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Or [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Principle.applicable [])\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Performed []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Principle.activity [])\n (Lean.Expr.bvar 3))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Reflexive [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.const `CoreReader.Agency.applicationRule []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))))\n (Lean.Expr.const `CoreReader.Agency.applicationWork [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Performed [])\n (Lean.Expr.const `CoreReader.Agency.applicationWork []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Subject.system [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `CoreReader.Agency.Activity.assessment []))))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "bc78545b62c505f56ce296e85615d7fa73b1a61c223696c87dc8bb532f6e9316" + }, + "CoreReader.Agency.selfTestDoesNotProve": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.selfTest [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `List.cons [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app (Lean.Expr.const `List.nil [Lean.Level.zero]) (Lean.Expr.const `Nat [])))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ownArithmeticPrinciple [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.forallE\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.ownArithmeticPrinciple []) (Lean.Expr.bvar 0)))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))", + "sha256": "bbc48f4b905f196e6c939615e1e8deb2b82ba924ea85d87214b3a9db96bcc67d" + }, + "CoreReader.Evidence.selfOriginDoesNotSupport": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.const `CoreReader.Evidence.allTrue []))))\n (Lean.Expr.const `CoreReader.Evidence.OwnedRevisionExample []))))", + "sha256": "3a32d7d0b5d238eb04c1ff3c4040363e9eba221e1304bb0160579141572bd88e" + }, + "CoreReader.Evidence.Grounds": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `claim\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `articulations\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 1))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulation []) (Lean.Expr.bvar 2))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `actualApplicable\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `facets\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 3)))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "4517c2eaf39a10fcd99876dc5a244ff06747ca6c130c8c03c7da6860e7bd2e12" + }, + "CoreReader.Evidence.supportWeakening": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Record []) (Lean.Expr.bvar 0)))\n (Lean.Expr.forallE\n `p\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `q\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 2))\n (Lean.Expr.forallE\n `support\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `weaker\n (Lean.Expr.forallE\n `w\n (Lean.Expr.bvar 4)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 2))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "c687c4deee04291784db05208dfae9b0d299ee0512dcdf74786cea5919b7a9ef" + }, + "CoreReader.Evidence.scopeRestriction": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `X\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Record []) (Lean.Expr.bvar 1)))\n (Lean.Expr.forallE\n `p\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 2)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 2)\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `wide\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 2)\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `narrow\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 3)\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `included\n (Lean.Expr.forallE\n `x\n (Lean.Expr.bvar 4)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 1) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `support\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 4))\n (Lean.Expr.lam\n `w\n (Lean.Expr.bvar 6)\n (Lean.Expr.forallE\n `x\n (Lean.Expr.bvar 6)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 4) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.app (Lean.Expr.bvar 6) (Lean.Expr.bvar 2)) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 5))\n (Lean.Expr.lam\n `w\n (Lean.Expr.bvar 7)\n (Lean.Expr.forallE\n `x\n (Lean.Expr.bvar 7)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 4) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.app (Lean.Expr.bvar 7) (Lean.Expr.bvar 2)) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)", + "sha256": "d20c49b2b30fa2639dcb643d5e085dc69f604e8fcd6b63523a0f635d157a33ce" + }, + "CoreReader.Evidence.assessmentUnion": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `a\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 0))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `b\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 1))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Duties []) (Lean.Expr.bvar 2))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Or []) (Lean.Expr.app (Lean.Expr.bvar 2) (Lean.Expr.bvar 0)))\n (Lean.Expr.app (Lean.Expr.bvar 1) (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Duties []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Duties []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "b4e682692e878b15864ca7fbab372218fd46ce2faacd91e88991bc49ce1b4764" + }, + "CoreReader.Evidence.labelsCannotWaive": { + "type": "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `xs\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `String []))\n (Lean.Expr.forallE\n `ys\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `String []))\n (Lean.Expr.forallE\n `a\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.LabeledDuties []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.LabeledDuties []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)", + "sha256": "4aa38f6f1cacfad2600cd191577020eebf845efd0f76b6e546aceb92f46a17ad" + }, + "CoreReader.Evidence.mixedMissingResponsibility": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.LabeledDuties []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `List.nil [Lean.Level.zero]) (Lean.Expr.const `String [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Or [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet.value []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.unsupportedPosition []))))\n (Lean.BinderInfo.default))))", + "sha256": "a3b8b9d25b7920c39ba44034d45faba23a579fac6b9bce01044a6ef8270a80c4" + }, + "CoreReader.Evidence.articulationNotSupport": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulated []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.uninformativeArgument [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulation.assumptions []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.uninformativeArgument [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))", + "sha256": "85f13987f0b8fce1cae5bbb59711d18a0c887a38e73b8bd00e1fd6b1c34fbfac" + }, + "CoreReader.Evidence.measurementRepeatNotSupport": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record.test [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.const `Bool.true []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))))\n (Lean.Expr.lam\n `w\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.snd [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))))))\n (Lean.Expr.lam\n `w\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.snd [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.consequence [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.consequence [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))))))))", + "sha256": "a1ca8f88b3e278adc56e4943aeea5513afbc3a4b45fc6aab79322bb788553da8" + }, + "CoreReader.Logic.compatibilityNotEntailment": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))", + "sha256": "244a4c828b24802472a24f81b01a70de6e709e44128ed21a8515578c2498843a" + }, + "CoreReader.Evidence.selfAssertionNotReason": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.commitment [])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.unsupportedPosition []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.unsupportedPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.Position [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.reasons [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.Position [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.commitment [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.consequence [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.JointAdoption [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))", + "sha256": "8a3f43790ce0efbba6a4f2be8e1eebe1ea1ff6f0df1051bad2eeda3a73329895" + }, + "CoreReader.Evidence.valueWithoutSelfProof": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValuePosition.starting []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.commitment [])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.JointAdoption []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.oppositePosition [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.oppositePosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.contradictoryStartingPosition []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.impossibleAdoptionPosition [])))))))", + "sha256": "568b8ffce3fb2209e2c6e258286982e02357a12f7df5daf2df0013af31ace2a5" + }, + "CoreReader.Evidence.heterogeneousReasons": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet.inferential []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet.value []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition []))))\n (Lean.Expr.const `CoreReader.Evidence.JointReasonsExample [])))", + "sha256": "c224d6fd8d50802cf08feb6f03c519161f4161cbcc1ccb85aca1d428bab6507e" + }, + "CoreReader.Evidence.localNotUniversal": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lam\n `outside\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 2451398637) \"_hygCtx\") \"_hyg\") 33)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 2451398637) \"_hygCtx\") \"_hyg\") 57)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])))))))", + "sha256": "c551de35323f24746aadf22a6611ebacdb1cb94e8b4395566041cea3514158ab" + }, + "CoreReader.Evidence.hiddenDifference": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 3849707129) \"_hygCtx\") \"_hyg\") 28)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 3849707129) \"_hygCtx\") \"_hyg\") 45)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))", + "sha256": "9d56436068f437ca82a13d660b482c2c010378472a97d87202c93c58cc14f534" + }, + "CoreReader.Evidence.singleObservation": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.lam\n `f\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.lam\n `f\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.bvar 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])))))", + "sha256": "7e3fa4592c2b19d90c2f858f7168ded7b64f30e40cf7c0232ac87752ced3204c" + }, + "CoreReader.Evidence.noUniversalChain": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.usesObservation []) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet [])))\n (Lean.Expr.const `Bool.false []))", + "sha256": "f0ef7c27557eaa39351f56c8807f56428d4b3bf3e7adfcd888ebd0ecd2ec64a4" + }, + "CoreReader.Evidence.variableOutcomesStableBound": { + "type": "Lean.Expr.letE\n `a\n (Lean.Expr.const `CoreReader.Evidence.Trial [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.letE\n `b\n (Lean.Expr.const `CoreReader.Evidence.Trial [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Reproduced []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Trial.actualOutcome []) (Lean.Expr.bvar 1)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Trial.actualOutcome []) (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Bounded []) (Lean.Expr.bvar 1)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Bounded []) (Lean.Expr.bvar 0)))))\n true)\n true", + "sha256": "a0bb99242c31620ee4c5b6e988883f3aa22b64126ffee1e765f5520bda35f61f" + }, + "CoreReader.Evidence.verificationReproductionStability": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Reproduced [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Reproduced [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2))))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Bounded [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2))))))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Bounded [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Bounded [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))))))", + "sha256": "a92288aebed02e0acbf848f44ff85a32e40821fecafc92bb8ce7dcb89a31c74e" + }, + "CoreReader.Evidence.outputNotExplanation": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))))\n (Lean.Expr.const `CoreReader.Evidence.OutputContractEvidence []))", + "sha256": "43406d330c84bc09d691acee59de1fc29de6234aeb88fe44733b301b919f3fd7" + }, + "CoreReader.Evidence.applicationContractsDiffer": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.explainedProcess [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.explainedProcess []))))\n (Lean.Expr.const `CoreReader.Evidence.ScopedApplicationEvidence []))", + "sha256": "a527a2020908a813787d377f4918c57975e27b6bd8d6449e15be34c05c40489e" + }, + "CoreReader.Evidence.externalAssessment": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.lam\n `certificate\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessorId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 42)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 42))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessedId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 7)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 7))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessorId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessedId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ProcessGrounds [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))))", + "sha256": "fe5654cff59f9fdd8d2c45b06fb9c074424a4dc98b3f9131c1fbce46b08f9cee" + }, + "CoreReader.Agency.inventoryNotCapability": { + "type": "Lean.Expr.forallE\n `kind\n (Lean.Expr.const `CoreReader.Agency.InventoryKind [])\n (Lean.Expr.forallE\n `ops\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.forallE\n `op\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Available [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `HAppend.hAppend [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `instHAppendOfAppend [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.instAppend [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.map [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.lam\n `x\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Item.mk []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.map [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.lam\n `x\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Item.mk []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Available [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.map [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.lam\n `x\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Item.mk []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "c42372dbdafd2e978ce5040103e18e2e8a26326e3f9eae43e2c902e076ab5d23" + }, + "CoreReader.Choice.statusOnlyFails": { + "type": "Lean.Expr.forallE\n `req\n (Lean.Expr.const `CoreReader.Choice.Requirements [])\n (Lean.Expr.forallE\n `i\n (Lean.Expr.const `CoreReader.Choice.Implementation [])\n (Lean.Expr.forallE\n `k\n (Lean.Expr.const `CoreReader.Choice.StatusKind [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.JustifiedChoice []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.Reason.status []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason [])))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "5e18307d2fd827fe08aa1e168caa706d5bcd1aa43c40eec1b7c6ff91b81e66f0" + }, + "CoreReader.Choice.conventionWithReason": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.conventional [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl [])))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.established [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl [])))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `List.cons [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.status [])\n (Lean.Expr.const `CoreReader.Choice.StatusKind.convention [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.output [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))))))", + "sha256": "ac0033fbed40e31d070cb960495ad45eb8726534475c7329dca05c8da8f6a1e5" + }, + "CoreReader.Choice.generalGroundsNotChoice": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Articulated [])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Choice.priorityArticulation [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.AssessmentAccurate []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `selected\n (Lean.Expr.const `CoreReader.Choice.Candidate [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Models [])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Choice.statusFacts []))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.priorityClaim [])\n (Lean.Expr.const `CoreReader.Choice.Candidate.identity [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.priorityClaim [])\n (Lean.Expr.const `CoreReader.Choice.Candidate.successor []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Entails [])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Choice.statusFacts []))\n (Lean.Expr.const `CoreReader.Choice.priorityClaim []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.status [])\n (Lean.Expr.const `CoreReader.Choice.StatusKind.standing [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))))))))))))\n (Lean.Expr.const `CoreReader.Choice.PolicyIndependenceExample [])", + "sha256": "eee90ae5540da7b23ad95176b6a736267b8b4ef0e9413bed8e5045fb71acaddc" + }, + "CoreReader.Choice.singleFeasible": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `candidate\n (Lean.Expr.const `CoreReader.Choice.Candidate [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Feasible [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.implementation []) (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Choice.Candidate.identity [])))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.const `CoreReader.Choice.objectiveReason []))", + "sha256": "f3437f4015fdbcf92e04b7da7b29f047b90d4189c21e558d82314ff75051b319" + }, + "CoreReader.Choice.localNotGlobal": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `x\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.changedOutsideZero []))\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.changedOutsideZero []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))", + "sha256": "e536339546398c5b31cb38c3a821354d883487b067c95607379060c352460ccd" + }, + "CoreReader.Choice.internalReasons": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.explanation []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.applicability []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.simplicity []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.procedure []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.cheapSuccessor []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.simplicity []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.cheapSuccessor []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.simplicity [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason [])))))))))", + "sha256": "1ec7968d246d20d2b1493c1e285053ff3d37fd3fc2c90aa7ce1af6fd73464926" + }, + "CoreReader.Choice.openNotEquivalent": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.const `CoreReader.Choice.objectiveReason [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.successorImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))", + "sha256": "50e8d5c0a1072c29f5281a230d2329b8e7c22f8abc90a8222f7689c81806b65d" + }, + "CoreReader.Integration.revisionKeepsConsistency": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.Charter [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Consistent [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.const `CoreReader.Integration.revisedHeld []))\n (Lean.Expr.const `CoreReader.Integration.context [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.TruthfulReport [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.const `CoreReader.Integration.initialSnapshot []))\n (Lean.Expr.const `CoreReader.Integration.revisedSnapshot []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.TruthfulReport [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.const `CoreReader.Integration.initialSnapshot []))\n (Lean.Expr.const `CoreReader.Integration.revisedSnapshot []))\n (Lean.Expr.const `Bool.false [])))))", + "sha256": "3aab586ee7ffced9c73f73f9eef729d01d47a6bbb0df57d834248a6b2a439e0f" + }, + "CoreReader.Integration.ownCapabilityGrounded": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.OwnCapabilityDuty [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.capability [])\n (Lean.Expr.const `CoreReader.Integration.actual []))", + "sha256": "42bfb4a096464e6d78e2b2fab189eab062eccc80015fff1c83d501d91b7f5a0b" + }, + "CoreReader.Integration.groundsSelfAssessment": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `CoreReader.Integration.World [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.GroundsProvision [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.snd [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Integration.Mode []))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.limits [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentPosition [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.relevantCriticism [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentPosition [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentPositionFor [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds []))\n (Lean.Expr.const `CoreReader.Integration.Mode.waive []))))))", + "sha256": "84129ee9e21d37bed63d1ba724e180ef0d35eaa8a3301454c50137e2e2ba682d" + }, + "CoreReader.Integration.existingPhilosophyNotPrivileged": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.Form []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.form [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.principleForm [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.Mode []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.mode [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.governance [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Integration.proposalRequirements []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.implementation [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.status [])\n (Lean.Expr.const `CoreReader.Choice.StatusKind.standing [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Integration.proposalRequirements []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.implementation [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.output [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.review [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.review [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))))", + "sha256": "1ec61cc64f16f1a54396b2b73da6f7aa90251e6563d882b8f92b3af2d8128151" + }, + "CoreReader.Agency.generationNotReflexivity": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.const `CoreReader.Agency.openPolicy [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Reflexive [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ownRules [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app (Lean.Expr.const `List.nil [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))))", + "sha256": "c6ba911bc5b6a702eeddb7e1c345e58c099b2032b097a36768b315f016ea31a6" + }, + "CoreReader.Integration.charterNotGrounds": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.Charter [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.costAllowanceRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.capability []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.unsupportedCapabilityFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.unsupportedCapabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))))", + "sha256": "27e83eb0e659bf4c081cd29c507d09939dc4a07b00996d95f03220f991771f25" + }, + "CoreReader.Integration.applicationRetainsDuties": { + "type": "Lean.Expr.forallE\n `s\n (Lean.Expr.const `CoreReader.Integration.System [])\n (Lean.Expr.forallE\n `w\n (Lean.Expr.const `CoreReader.Integration.World [])\n (Lean.Expr.forallE\n `req\n (Lean.Expr.const `CoreReader.Choice.Requirements [])\n (Lean.Expr.forallE\n `contract\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Choice.Requirements [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Choice.Implementation [])\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `articulations\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Articulation [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `applicable\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `facets\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.ApplicationDuties [])\n (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Reflexive [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.System.owner []) (Lean.Expr.bvar 7)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.System.rules []) (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 6)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.System.work []) (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 6))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const\n `Membership.mem\n [Lean.Level.succ (Lean.Level.zero), Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.forallE\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const\n `Membership.mem\n [Lean.Level.succ (Lean.Level.zero), Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Claim [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet.claim [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.applicationClaim [])\n (Lean.Expr.bvar 9))\n (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 6))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Articulated [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.bvar 5) (Lean.Expr.bvar 1))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.FacetArticulated [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.bvar 5) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.FacetDischarged [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.bvar 1)))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)", + "sha256": "651f3b9c399a82d84279c623426939d6383c20da613db99958f86c454866fef3" + }, + "CoreReader.Integration.reasonsBelongToCommitments": { + "type": "Lean.Expr.forallE\n `c\n (Lean.Expr.const `CoreReader.Integration.Commitment [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentClaim []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentFacet []) (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentFacet []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.JointAdoption [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentPosition []) (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.relevantCriticism [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentPosition []) (Lean.Expr.bvar 0)))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentPositionFor []) (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.Mode.waive [])))))))\n (Lean.BinderInfo.default)", + "sha256": "6323d4f56fb47c305d52b3f61a3fd8086550b60929520138401ced1e161120f8" + }, + "CoreReader.Evidence.nonExecutableAssessment": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Grounds []) (Lean.Expr.const `Nat []))\n (Lean.Expr.lam\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `instHAdd [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instAddNat [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation []) (Lean.Expr.const `Nat [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat [])))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.usesObservation []) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet [])))\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.usesObservation []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.const `Bool.true []))))", + "sha256": "6909f108bbe2e4fd72181deb801b653071f204ab688a8a4cc7e99c4ede0d2728" + }, + "CoreReader.Integration.applicationVariation": { + "type": "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.ApplicationDuties [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Integration.outputContract []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.applicationClaim [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.successorRequirements []))\n (Lean.Expr.const `CoreReader.Integration.outputContract []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.applicationClaim [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.successorRequirements []))\n (Lean.Expr.const `CoreReader.Integration.outputContract [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.changedObjectiveFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.changedObjectiveFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))))", + "sha256": "8c23f5b979f61d621e8ee78193561d5f1251459dc992801be540bee18948150e" + } + }, + "build_returncode": 0, + "audit_returncode": 0, + "kernel_passed": true +} diff --git a/lean/philosophy/evidence/lake-build.log b/lean/philosophy/evidence/lake-build.log new file mode 100644 index 0000000..c5f899f --- /dev/null +++ b/lean/philosophy/evidence/lake-build.log @@ -0,0 +1,10 @@ +✔ [2/9] Built CoreReader.Logic (216ms) +✔ [3/9] Built CoreReader.Reflexivity (559ms) +✔ [4/9] Built CoreReader.Agency (402ms) +✔ [5/9] Built CoreReader.Evidence (424ms) +✔ [6/9] Built CoreReader.Choice (306ms) +✔ [7/9] Built CoreReader.Integration (457ms) +✔ [8/9] Built CoreReader (202ms) +Build completed successfully (9 jobs). +info: core_reproof: no previous manifest, creating one from scratch +info: toolchain not updated; already up-to-date diff --git a/lean/philosophy/evidence/lean-audit.log b/lean/philosophy/evidence/lean-audit.log new file mode 100644 index 0000000..b8fb491 --- /dev/null +++ b/lean/philosophy/evidence/lean-audit.log @@ -0,0 +1,554 @@ +CoreReader.Integration.jointWitness : + ∃ s w, + CoreReader.Logic.Admissible (CoreReader.Integration.systemHeld s) (CoreReader.Integration.systemContext s) w ∧ + CoreReader.Integration.Charter s w ∧ + CoreReader.Integration.OwnCapabilityDuty s w [CoreReader.Integration.capabilityFacet] ∧ + CoreReader.Integration.systemCapability s w ∧ + CoreReader.Choice.JustifiedChoice s.requirements (s.method.realize w) CoreReader.Choice.objectiveReason ∧ + (∀ (c : CoreReader.Integration.Commitment), + CoreReader.Evidence.Grounds (CoreReader.Integration.commitmentClaim c) + CoreReader.Evidence.canonicalArticulation (fun f => f = CoreReader.Integration.commitmentFacet c) + [CoreReader.Integration.commitmentFacet c]) ∧ + s = CoreReader.Integration.actualSystem ∧ w = CoreReader.Integration.actual +'CoreReader.Integration.jointWitness' depends on axioms: [propext, Classical.choice, Quot.sound] +ORGANON_TYPE CoreReader.Integration.jointWitness "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.System []))\n (Lean.Expr.lam\n `s\n (Lean.Expr.const `CoreReader.Integration.System [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `CoreReader.Integration.World [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Admissible [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.systemHeld []) (Lean.Expr.bvar 1)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.systemContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.Charter []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.OwnCapabilityDuty []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.systemCapability []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.requirements [])\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.Method.realize [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.method [])\n (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.const `CoreReader.Choice.objectiveReason [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `c\n (Lean.Expr.const `CoreReader.Integration.Commitment [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentClaim [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.System []))\n (Lean.Expr.bvar 1))\n (Lean.Expr.const `CoreReader.Integration.actualSystem [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.actual [])))))))))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default))" +CoreReader.Agency.Generative (p : CoreReader.Agency.Policy) : Prop +'CoreReader.Agency.Generative' does not depend on any axioms +ORGANON_TYPE CoreReader.Agency.Generative "Lean.Expr.forallE\n `p\n (Lean.Expr.const `CoreReader.Agency.Policy [])\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default)" +CoreReader.Agency.permissionNotValuation : + CoreReader.Agency.neutralPolicy.permitsVersion 0 1 ∧ + 0 ≠ 1 ∧ ¬CoreReader.Agency.Generative CoreReader.Agency.neutralPolicy +'CoreReader.Agency.permissionNotValuation' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Agency.permissionNotValuation "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Policy.permitsVersion [])\n (Lean.Expr.const `CoreReader.Agency.neutralPolicy []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.const `CoreReader.Agency.neutralPolicy []))))" +CoreReader.Agency.revisabilityCovers (p : CoreReader.Agency.Policy) (h : CoreReader.Agency.Generative p) + (k : CoreReader.Agency.FormKind) (v : Nat) (hc : p.current { kind := k, version := v }) : + p.revisable { kind := k, version := v } +'CoreReader.Agency.revisabilityCovers' does not depend on any axioms +ORGANON_TYPE CoreReader.Agency.revisabilityCovers "Lean.Expr.forallE\n `p\n (Lean.Expr.const `CoreReader.Agency.Policy [])\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Generative []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `k\n (Lean.Expr.const `CoreReader.Agency.FormKind [])\n (Lean.Expr.forallE\n `v\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `hc\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Policy.current []) (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Form.mk []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Policy.revisable []) (Lean.Expr.bvar 4))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Form.mk []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)" +CoreReader.Agency.revisionWithoutProgress : + CoreReader.Agency.Generative CoreReader.Agency.openPolicy ∧ + (∀ (k : CoreReader.Agency.FormKind), CoreReader.Agency.openPolicy.revisable { kind := k, version := 0 }) ∧ + ∀ (t : Nat), ¬CoreReader.Agency.Expanded (CoreReader.Agency.stableTrace t) (CoreReader.Agency.stableTrace (t + 1)) +'CoreReader.Agency.revisionWithoutProgress' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Agency.revisionWithoutProgress "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.const `CoreReader.Agency.openPolicy [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `k\n (Lean.Expr.const `CoreReader.Agency.FormKind [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Policy.revisable [])\n (Lean.Expr.const `CoreReader.Agency.openPolicy []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Form.mk []) (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.BinderInfo.default)))\n (Lean.Expr.forallE\n `t\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.stableTrace []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.stableTrace [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `instHAdd [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instAddNat [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))))\n (Lean.BinderInfo.default)))" +CoreReader.Agency.generationLimits : + CoreReader.Agency.Generative CoreReader.Agency.generatingSystem.policy ∧ + CoreReader.Agency.generatingSystem.policy.permitsVersion 0 0 ∧ + ¬CoreReader.Agency.Expanded CoreReader.Agency.generatingSystem.current CoreReader.Agency.inflatedState ∧ + CoreReader.Agency.generatingSystem.current.inventory.length < CoreReader.Agency.inflatedState.inventory.length ∧ + CoreReader.Agency.generatingSystem.current.abstractionLayers.length < + CoreReader.Agency.inflatedState.abstractionLayers.length ∧ + CoreReader.Agency.generatingSystem.current.vocabulary.length < + CoreReader.Agency.inflatedState.vocabulary.length ∧ + CoreReader.Agency.generatingSystem.execute CoreReader.Agency.availableResources = some 6 ∧ + CoreReader.Agency.generatingSystem.execute + (have __src := CoreReader.Agency.availableResources; + { experience := none, knowledge := __src.knowledge, collaborator := __src.collaborator }) = + none ∧ + CoreReader.Agency.generatingSystem.execute + (have __src := CoreReader.Agency.availableResources; + { experience := __src.experience, knowledge := none, collaborator := __src.collaborator }) = + none ∧ + CoreReader.Agency.generatingSystem.execute + (have __src := CoreReader.Agency.availableResources; + { experience := __src.experience, knowledge := __src.knowledge, collaborator := none }) = + none ∧ + CoreReader.Agency.generatingSystem.execute + { experience := none, knowledge := none, collaborator := none } = + none ∧ + ¬CoreReader.Agency.Expanded CoreReader.Agency.generatingSystem.current + CoreReader.Agency.generatingSystem.stableAction ∧ + CoreReader.Agency.generatingSystem.stableAction = CoreReader.Agency.generatingSystem.current ∧ + CoreReader.Agency.generatingSystem.requirementsMet + CoreReader.Agency.generatingSystem.stableAction ∧ + CoreReader.Agency.generatingSystem.withinBudget + CoreReader.Agency.generatingSystem.stableAction ∧ + ¬CoreReader.Agency.generatingSystem.withinBudget CoreReader.Agency.inflatedState ∧ + CoreReader.Agency.StableReason CoreReader.Agency.generatingSystem.current + CoreReader.Agency.inflatedState ∧ + CoreReader.Agency.inflatedAnnouncement = + CoreReader.Agency.generatingSystem.report CoreReader.Agency.inflatedState + CoreReader.Agency.Operation.successor 0 1 ∧ + CoreReader.Agency.inflatedAnnouncement.owner = + CoreReader.Agency.generatingSystem.owner ∧ + CoreReader.Agency.inflatedAnnouncement.before = + CoreReader.Agency.generatingSystem.current ∧ + CoreReader.Agency.inflatedAnnouncement.after = + CoreReader.Agency.inflatedState ∧ + CoreReader.Agency.inflatedAnnouncement.reportedNewOperation = + CoreReader.Agency.Operation.successor ∧ + CoreReader.Agency.inflatedAnnouncement.input = 0 ∧ + CoreReader.Agency.inflatedAnnouncement.expectedOutput = 1 ∧ + ¬CoreReader.Agency.inflatedAnnouncement.claim ∧ + ¬CoreReader.Agency.Expanded + CoreReader.Agency.inflatedAnnouncement.before + CoreReader.Agency.inflatedAnnouncement.after +'CoreReader.Agency.generationLimits' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Agency.generationLimits "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.policy [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Policy.permitsVersion [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.policy [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.const `CoreReader.Agency.inflatedState []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLTNat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.inventory [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.inventory [])\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLTNat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.abstractionLayers [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.abstractionLayers [])\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLTNat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.vocabulary [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.State.vocabulary [])\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.const `CoreReader.Agency.availableResources [])))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Option.some [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 6)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 6)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.letE\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `__src.«_@».CoreReader.Agency 2099545508) \"_hygCtx\") \"_hyg\") 66)\n (Lean.Expr.const `CoreReader.Agency.ExternalResources [])\n (Lean.Expr.const `CoreReader.Agency.availableResources [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.knowledge [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.collaborator [])\n (Lean.Expr.bvar 0)))\n true)))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.letE\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `__src.«_@».CoreReader.Agency 2099545508) \"_hygCtx\") \"_hyg\") 85)\n (Lean.Expr.const `CoreReader.Agency.ExternalResources [])\n (Lean.Expr.const `CoreReader.Agency.availableResources [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.experience [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.collaborator [])\n (Lean.Expr.bvar 0)))\n true)))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.letE\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `__src.«_@».CoreReader.Agency 2099545508) \"_hygCtx\") \"_hyg\") 104)\n (Lean.Expr.const `CoreReader.Agency.ExternalResources [])\n (Lean.Expr.const `CoreReader.Agency.availableResources [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.experience [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.knowledge [])\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n true)))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `Option [Lean.Level.zero]) (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.execute [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ExternalResources.mk [])\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))\n (Lean.Expr.app\n (Lean.Expr.const `Option.none [Lean.Level.zero])\n (Lean.Expr.const `Nat [])))))\n (Lean.Expr.app (Lean.Expr.const `Option.none [Lean.Level.zero]) (Lean.Expr.const `Nat []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.State []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.requirementsMet [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.withinBudget [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.stableAction [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.withinBudget [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.const `CoreReader.Agency.inflatedState []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.StableReason [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem [])))\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.Announcement []))\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.report [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))\n (Lean.Expr.const `CoreReader.Agency.inflatedState []))\n (Lean.Expr.const `CoreReader.Agency.Operation.successor []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.owner [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.owner [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.State []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.before [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.GeneratingSystem.current [])\n (Lean.Expr.const `CoreReader.Agency.generatingSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.State []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.after [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.const `CoreReader.Agency.inflatedState [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.app\n (Lean.Expr.const\n `CoreReader.Agency.Announcement.reportedNewOperation\n [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.const `CoreReader.Agency.Operation.successor [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.input [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.const\n `CoreReader.Agency.Announcement.expectedOutput\n [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app\n (Lean.Expr.const `instOfNatNat [])\n (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.claim [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Expanded [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.before [])\n (Lean.Expr.const `CoreReader.Agency.inflatedAnnouncement [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Announcement.after [])\n (Lean.Expr.const\n `CoreReader.Agency.inflatedAnnouncement\n []))))))))))))))))))))))))))))" +CoreReader.Evidence.AchievementAccountability {W : Type} (achievement : CoreReader.Logic.Claim W) + (articulations : CoreReader.Evidence.Facet W → CoreReader.Evidence.Articulation W) + (actualApplicable : CoreReader.Evidence.Facet W → Prop) (facets : List (CoreReader.Evidence.Facet W)) : Prop +'CoreReader.Evidence.AchievementAccountability' does not depend on any axioms +ORGANON_TYPE CoreReader.Evidence.AchievementAccountability "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `achievement\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `articulations\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 1))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulation []) (Lean.Expr.bvar 2))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `actualApplicable\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `facets\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 3)))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)" +CoreReader.Evidence.achievementNeedsSupport {W : Type} (achievement : CoreReader.Logic.Claim W) + (records : List (CoreReader.Evidence.Record W)) (actual : W) + (reliableHere : CoreReader.Evidence.Compatible records actual) + (support : CoreReader.Evidence.Supports records achievement) : + achievement actual ∧ CoreReader.Evidence.ConcreteAchievementExample +'CoreReader.Evidence.achievementNeedsSupport' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Evidence.achievementNeedsSupport "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `achievement\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Record []) (Lean.Expr.bvar 1)))\n (Lean.Expr.forallE\n `actual\n (Lean.Expr.bvar 2)\n (Lean.Expr.forallE\n `reliableHere\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Compatible []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `support\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `And []) (Lean.Expr.app (Lean.Expr.bvar 4) (Lean.Expr.bvar 2)))\n (Lean.Expr.const `CoreReader.Evidence.ConcreteAchievementExample []))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)" +CoreReader.Logic.consequenceConsistency {W Q : Type} (t : CoreReader.Logic.Theory W) (c : CoreReader.Logic.Context W Q) + (inhabited : ∃ w, CoreReader.Logic.Admissible t c w) : CoreReader.Logic.Consistent t c +'CoreReader.Logic.consequenceConsistency' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.consequenceConsistency "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `Q\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `t\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Theory []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `c\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Context []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `inhabited\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.bvar 3))\n (Lean.Expr.lam\n `w\n (Lean.Expr.bvar 3)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consistent []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)" +CoreReader.Logic.jointConflict : + CoreReader.Logic.Satisfiable (CoreReader.Logic.singleton CoreReader.Logic.premiseP) ∧ + CoreReader.Logic.Satisfiable (CoreReader.Logic.singleton CoreReader.Logic.premiseRule) ∧ + CoreReader.Logic.Satisfiable (CoreReader.Logic.singleton CoreReader.Logic.premiseNotQ) ∧ + ¬CoreReader.Logic.Satisfiable CoreReader.Logic.jointTheory +'CoreReader.Logic.jointConflict' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.jointConflict "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.singleton [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.premiseP []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.singleton [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.premiseRule []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.singleton [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.premiseNotQ []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Satisfiable [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Logic.jointTheory [])))))" +CoreReader.Logic.revisionCanReverse : + CoreReader.Logic.Satisfiable (CoreReader.Logic.revisionSlice 0) ∧ + CoreReader.Logic.Satisfiable (CoreReader.Logic.revisionSlice 1) ∧ + ¬CoreReader.Logic.Satisfiable + (CoreReader.Logic.union (CoreReader.Logic.revisionSlice 0) (CoreReader.Logic.revisionSlice 1)) +'CoreReader.Logic.revisionCanReverse' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.revisionCanReverse "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.revisionSlice [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))))" +CoreReader.Logic.contextDifferences : + (CoreReader.Logic.Consequence CoreReader.Logic.emptyTheory (CoreReader.Logic.assumptionContext true) () true ∧ + CoreReader.Logic.Consequence CoreReader.Logic.emptyTheory (CoreReader.Logic.assumptionContext false) () false) ∧ + (CoreReader.Logic.Consequence CoreReader.Logic.emptyTheory (CoreReader.Logic.meaningContext true) () true ∧ + CoreReader.Logic.Consequence CoreReader.Logic.emptyTheory (CoreReader.Logic.meaningContext false) () false) ∧ + (CoreReader.Logic.Consequence CoreReader.Logic.emptyTheory (CoreReader.Logic.scopeContext true) () true ∧ + CoreReader.Logic.Consequence CoreReader.Logic.emptyTheory (CoreReader.Logic.scopeContext false) () false) ∧ + (∀ (b : Bool), + ∃ w, CoreReader.Logic.Admissible CoreReader.Logic.emptyTheory (CoreReader.Logic.assumptionContext b) w) ∧ + (∀ (b : Bool), + ∃ w, CoreReader.Logic.Admissible CoreReader.Logic.emptyTheory (CoreReader.Logic.meaningContext b) w) ∧ + ∀ (b : Bool), + ∃ w, CoreReader.Logic.Admissible CoreReader.Logic.emptyTheory (CoreReader.Logic.scopeContext b) w +'CoreReader.Logic.contextDifferences' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.contextDifferences "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.const `Unit.unit []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `b\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `b\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.forallE\n `b\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Admissible []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default))))))" +CoreReader.Logic.semanticChangeMustBeReported {W Q : Type} (a b : CoreReader.Logic.Snapshot W Q) (reported : Bool) + (changed : ¬CoreReader.Logic.SameContent a b ∨ a.revisionIdentity ≠ b.revisionIdentity) + (h : CoreReader.Logic.TruthfulReport a b reported) : reported = true +'CoreReader.Logic.semanticChangeMustBeReported' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.semanticChangeMustBeReported "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `Q\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `a\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Snapshot []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `b\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Snapshot []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `reported\n (Lean.Expr.const `Bool [])\n (Lean.Expr.forallE\n `changed\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Or [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.SameContent []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Snapshot.revisionIdentity [])\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Snapshot.revisionIdentity []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 2))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)" +CoreReader.Logic.representationOrderIrrelevant {W : Type} (p q r : CoreReader.Logic.Claim W) : + CoreReader.Logic.union (CoreReader.Logic.singleton p) (CoreReader.Logic.singleton q) r ↔ + CoreReader.Logic.union (CoreReader.Logic.singleton q) (CoreReader.Logic.singleton p) r +'CoreReader.Logic.representationOrderIrrelevant' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.representationOrderIrrelevant "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `p\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `q\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `r\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 2))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.bvar 3))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2)))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)" +CoreReader.Logic.hiddenContextChangeRejected : + ¬CoreReader.Logic.TruthfulReport (CoreReader.Logic.contextSnapshot (CoreReader.Logic.assumptionContext true)) + (CoreReader.Logic.contextSnapshot (CoreReader.Logic.assumptionContext false)) false ∧ + ¬CoreReader.Logic.TruthfulReport (CoreReader.Logic.contextSnapshot (CoreReader.Logic.meaningContext true)) + (CoreReader.Logic.contextSnapshot (CoreReader.Logic.meaningContext false)) false ∧ + ¬CoreReader.Logic.TruthfulReport (CoreReader.Logic.contextSnapshot (CoreReader.Logic.scopeContext true)) + (CoreReader.Logic.contextSnapshot (CoreReader.Logic.scopeContext false)) false ∧ + ¬CoreReader.Logic.TruthfulReport (CoreReader.Logic.contextSnapshot (CoreReader.Logic.scopeContext true)) + (CoreReader.Logic.contextSnapshot (CoreReader.Logic.scopeContext true) 1) false ∧ + CoreReader.Logic.TruthfulReport (CoreReader.Logic.contextSnapshot (CoreReader.Logic.assumptionContext true)) + (CoreReader.Logic.contextSnapshot (CoreReader.Logic.assumptionContext false)) true ∧ + ¬CoreReader.Logic.Models (CoreReader.Logic.assumptionContext false).assumptions true +'CoreReader.Logic.hiddenContextChangeRejected' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.hiddenContextChangeRejected "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.assumptionContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.meaningContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.scopeContext [])\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.scopeContext []) (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.TruthfulReport []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.contextSnapshot [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Models []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Context.assumptions [])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Unit []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.assumptionContext [])\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.const `Bool.true [])))))))" +CoreReader.Logic.tensionWithoutContradiction : (∃ budget, 4 ≤ budget ∧ budget ≤ 6) ∧ ¬(fun n => 4 ≤ n) = fun n => n ≤ 6 +'CoreReader.Logic.tensionWithoutContradiction' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.tensionWithoutContradiction "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lam\n `budget\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 4)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 4)))))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 6)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 6))))))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.forallE `n (Lean.Expr.const `Nat []) (Lean.Expr.sort (Lean.Level.zero)) (Lean.BinderInfo.default)))\n (Lean.Expr.lam\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 4)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 4)))))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.lam\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instLENat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 6)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 6)))))\n (Lean.BinderInfo.default))))" +CoreReader.Logic.conflictRequiresChange {W Q : Type} (t : CoreReader.Logic.Theory W) (c : CoreReader.Logic.Context W Q) + (q : Q) (positive : CoreReader.Logic.Consequence t c q true) (negative : CoreReader.Logic.Consequence t c q false) : + ¬CoreReader.Logic.Consistent t c +'CoreReader.Logic.conflictRequiresChange' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.conflictRequiresChange "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `Q\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `t\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Theory []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `c\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Context []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `q\n (Lean.Expr.bvar 2)\n (Lean.Expr.forallE\n `positive\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.forallE\n `negative\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consequence []) (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.const `Bool.false []))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Consistent []) (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)" +CoreReader.Logic.consistentFalse : + CoreReader.Logic.Satisfiable (CoreReader.Logic.singleton fun w => w = true) ∧ + ¬CoreReader.Logic.Models (CoreReader.Logic.singleton fun w => w = true) false +'CoreReader.Logic.consistentFalse' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.consistentFalse "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Models []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `Bool.false [])))" +CoreReader.Logic.consistentIncomplete : + CoreReader.Logic.Satisfiable CoreReader.Logic.emptyTheory ∧ + (¬CoreReader.Logic.Entails CoreReader.Logic.emptyTheory fun w => w = true) ∧ + ¬CoreReader.Logic.Entails CoreReader.Logic.emptyTheory fun w => w ≠ true +'CoreReader.Logic.consistentIncomplete' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.consistentIncomplete "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))" +CoreReader.Agency.Reflexive (owner : Nat) (rules : List CoreReader.Agency.Principle) + (records : List CoreReader.Agency.WorkRecord) : Prop +'CoreReader.Agency.Reflexive' does not depend on any axioms +ORGANON_TYPE CoreReader.Agency.Reflexive "Lean.Expr.forallE\n `owner\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `rules\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)" +CoreReader.Agency.noSelfExemption (owner : Nat) (rules : List CoreReader.Agency.Principle) + (records : List CoreReader.Agency.WorkRecord) (h : CoreReader.Agency.Reflexive owner rules records) + (rule : CoreReader.Agency.Principle) (hr : rule ∈ rules) (s : CoreReader.Agency.Subject) (hs : s.owner = owner) + (ha : rule.applicable s) : CoreReader.Agency.Performed records s rule.activity +'CoreReader.Agency.noSelfExemption' does not depend on any axioms +ORGANON_TYPE CoreReader.Agency.noSelfExemption "Lean.Expr.forallE\n `owner\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `rules\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Reflexive []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `rule\n (Lean.Expr.const `CoreReader.Agency.Principle [])\n (Lean.Expr.forallE\n `hr\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Membership.mem [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `s\n (Lean.Expr.const `CoreReader.Agency.Subject [])\n (Lean.Expr.forallE\n `hs\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Subject.owner []) (Lean.Expr.bvar 0)))\n (Lean.Expr.bvar 6))\n (Lean.Expr.forallE\n `ha\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Principle.applicable []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Performed []) (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 2))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Principle.activity []) (Lean.Expr.bvar 4)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)" +CoreReader.Agency.applicabilityRetained (owner : Nat) (rules : List CoreReader.Agency.Principle) + (records : List CoreReader.Agency.WorkRecord) : + (CoreReader.Agency.Reflexive owner rules records → CoreReader.Agency.ReflexiveScope owner rules records) ∧ + (CoreReader.Agency.ReflexiveScope owner rules records ↔ + ∀ (rule : CoreReader.Agency.Principle), + rule ∈ rules → + ∀ (s : CoreReader.Agency.Subject), + s.owner = owner → ¬rule.applicable s ∨ CoreReader.Agency.Performed records s rule.activity) ∧ + CoreReader.Agency.Reflexive 0 [CoreReader.Agency.applicationRule] CoreReader.Agency.applicationWork ∧ + ¬CoreReader.Agency.Performed CoreReader.Agency.applicationWork (CoreReader.Agency.Subject.system 0) + CoreReader.Agency.Activity.assessment +'CoreReader.Agency.applicabilityRetained' depends on axioms: [propext, Classical.choice, Quot.sound] +ORGANON_TYPE CoreReader.Agency.applicabilityRetained "Lean.Expr.forallE\n `owner\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n `rules\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Reflexive []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.ReflexiveScope []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.ReflexiveScope []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.forallE\n `rule\n (Lean.Expr.const `CoreReader.Agency.Principle [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Membership.mem [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle [])))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `s\n (Lean.Expr.const `CoreReader.Agency.Subject [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Subject.owner []) (Lean.Expr.bvar 0)))\n (Lean.Expr.bvar 5))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Or [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Principle.applicable [])\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Performed []) (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Principle.activity [])\n (Lean.Expr.bvar 3))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Reflexive [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))\n (Lean.Expr.const `CoreReader.Agency.applicationRule []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Principle []))))\n (Lean.Expr.const `CoreReader.Agency.applicationWork [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Performed [])\n (Lean.Expr.const `CoreReader.Agency.applicationWork []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Subject.system [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `CoreReader.Agency.Activity.assessment []))))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)" +CoreReader.Agency.selfTestDoesNotProve : + CoreReader.Agency.selfTest [1] = true ∧ + CoreReader.Agency.ownArithmeticPrinciple 0 = false ∧ ¬∀ (n : Nat), CoreReader.Agency.ownArithmeticPrinciple n = true +'CoreReader.Agency.selfTestDoesNotProve' does not depend on any axioms +ORGANON_TYPE CoreReader.Agency.selfTestDoesNotProve "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.selfTest [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `List.cons [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app (Lean.Expr.const `List.nil [Lean.Level.zero]) (Lean.Expr.const `Nat [])))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ownArithmeticPrinciple [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.forallE\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.ownArithmeticPrinciple []) (Lean.Expr.bvar 0)))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))" +CoreReader.Evidence.selfOriginDoesNotSupport : + CoreReader.Evidence.localGenerator 0 0 = true ∧ + CoreReader.Evidence.localGenerator 0 1 = false ∧ + CoreReader.Evidence.Compatible [CoreReader.Evidence.zeroRecord] (CoreReader.Evidence.localGenerator 0) ∧ + ¬CoreReader.Evidence.Supports [CoreReader.Evidence.zeroRecord] CoreReader.Evidence.allTrue ∧ + CoreReader.Evidence.OwnedRevisionExample +'CoreReader.Evidence.selfOriginDoesNotSupport' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.selfOriginDoesNotSupport "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.const `CoreReader.Evidence.allTrue []))))\n (Lean.Expr.const `CoreReader.Evidence.OwnedRevisionExample []))))" +CoreReader.Evidence.Grounds {W : Type} (claim : CoreReader.Logic.Claim W) + (articulations : CoreReader.Evidence.Facet W → CoreReader.Evidence.Articulation W) + (actualApplicable : CoreReader.Evidence.Facet W → Prop) (facets : List (CoreReader.Evidence.Facet W)) : Prop +'CoreReader.Evidence.Grounds' does not depend on any axioms +ORGANON_TYPE CoreReader.Evidence.Grounds "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `claim\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 0))\n (Lean.Expr.forallE\n `articulations\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 1))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulation []) (Lean.Expr.bvar 2))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `actualApplicable\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `facets\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 3)))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)" +CoreReader.Evidence.supportWeakening {W : Type} (records : List (CoreReader.Evidence.Record W)) + (p q : CoreReader.Logic.Claim W) (support : CoreReader.Evidence.Supports records p) (weaker : ∀ (w : W), p w → q w) : + CoreReader.Evidence.Supports records q +'CoreReader.Evidence.supportWeakening' does not depend on any axioms +ORGANON_TYPE CoreReader.Evidence.supportWeakening "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Record []) (Lean.Expr.bvar 0)))\n (Lean.Expr.forallE\n `p\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `q\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Claim []) (Lean.Expr.bvar 2))\n (Lean.Expr.forallE\n `support\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.forallE\n `weaker\n (Lean.Expr.forallE\n `w\n (Lean.Expr.bvar 4)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 2))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)" +CoreReader.Evidence.scopeRestriction {W X : Type} (records : List (CoreReader.Evidence.Record W)) (p : W → X → Prop) + (wide narrow : X → Prop) (included : ∀ (x : X), narrow x → wide x) + (support : CoreReader.Evidence.Supports records fun w => ∀ (x : X), wide x → p w x) : + CoreReader.Evidence.Supports records fun w => ∀ (x : X), narrow x → p w x +'CoreReader.Evidence.scopeRestriction' does not depend on any axioms +ORGANON_TYPE CoreReader.Evidence.scopeRestriction "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `X\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `records\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Record []) (Lean.Expr.bvar 1)))\n (Lean.Expr.forallE\n `p\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 2)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 2)\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `wide\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 2)\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `narrow\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.bvar 3)\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `included\n (Lean.Expr.forallE\n `x\n (Lean.Expr.bvar 4)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 1) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `support\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 4))\n (Lean.Expr.lam\n `w\n (Lean.Expr.bvar 6)\n (Lean.Expr.forallE\n `x\n (Lean.Expr.bvar 6)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 4) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.app (Lean.Expr.bvar 6) (Lean.Expr.bvar 2)) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Supports []) (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 5))\n (Lean.Expr.lam\n `w\n (Lean.Expr.bvar 7)\n (Lean.Expr.forallE\n `x\n (Lean.Expr.bvar 7)\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 4) (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.app (Lean.Expr.bvar 7) (Lean.Expr.bvar 2)) (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit))\n (Lean.BinderInfo.implicit)" +CoreReader.Evidence.assessmentUnion {W : Type} (a b : CoreReader.Evidence.Facet W → Prop) : + (CoreReader.Evidence.Duties fun f => a f ∨ b f) ↔ CoreReader.Evidence.Duties a ∧ CoreReader.Evidence.Duties b +'CoreReader.Evidence.assessmentUnion' does not depend on any axioms +ORGANON_TYPE CoreReader.Evidence.assessmentUnion "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `a\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 0))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `b\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 1))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Duties []) (Lean.Expr.bvar 2))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Or []) (Lean.Expr.app (Lean.Expr.bvar 2) (Lean.Expr.bvar 0)))\n (Lean.Expr.app (Lean.Expr.bvar 1) (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Duties []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Duties []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)" +CoreReader.Evidence.labelsCannotWaive {W : Type} (xs ys : List String) (a : CoreReader.Evidence.Facet W → Prop) : + CoreReader.Evidence.LabeledDuties xs a ↔ CoreReader.Evidence.LabeledDuties ys a +'CoreReader.Evidence.labelsCannotWaive' does not depend on any axioms +ORGANON_TYPE CoreReader.Evidence.labelsCannotWaive "Lean.Expr.forallE\n `W\n (Lean.Expr.sort (Lean.Level.succ (Lean.Level.zero)))\n (Lean.Expr.forallE\n `xs\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `String []))\n (Lean.Expr.forallE\n `ys\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `String []))\n (Lean.Expr.forallE\n `a\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.bvar 2))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.LabeledDuties []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.LabeledDuties []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.implicit)" +CoreReader.Evidence.mixedMissingResponsibility : + CoreReader.Evidence.FacetDischarged CoreReader.Evidence.switchEmpirical ∧ + ¬CoreReader.Evidence.LabeledDuties [] fun f => + f = CoreReader.Evidence.switchEmpirical ∨ + f = CoreReader.Evidence.Facet.value CoreReader.Evidence.unsupportedPosition +'CoreReader.Evidence.mixedMissingResponsibility' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.mixedMissingResponsibility "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.LabeledDuties []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `List.nil [Lean.Level.zero]) (Lean.Expr.const `String [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Or [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet.value []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.unsupportedPosition []))))\n (Lean.BinderInfo.default))))" +CoreReader.Evidence.articulationNotSupport : + CoreReader.Evidence.Articulated CoreReader.Evidence.uninformativeArgument ∧ + ¬CoreReader.Logic.Entails CoreReader.Evidence.uninformativeArgument.assumptions fun w => w = true +'CoreReader.Evidence.articulationNotSupport' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.articulationNotSupport "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulated []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.uninformativeArgument [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Articulation.assumptions []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.uninformativeArgument [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))" +CoreReader.Evidence.measurementRepeatNotSupport : + CoreReader.Evidence.temperatureRecord.test (true, false) = true ∧ + CoreReader.Evidence.Compatible [CoreReader.Evidence.temperatureRecord, CoreReader.Evidence.temperatureRecord] + (true, false) ∧ + CoreReader.Evidence.Compatible [CoreReader.Evidence.temperatureRecord, CoreReader.Evidence.temperatureRecord] + (true, true) ∧ + (¬CoreReader.Evidence.Supports [CoreReader.Evidence.temperatureRecord] fun w => w.snd = true) ∧ + (¬CoreReader.Evidence.Supports [CoreReader.Evidence.temperatureRecord, CoreReader.Evidence.temperatureRecord] + fun w => w.snd = true) ∧ + CoreReader.Evidence.Compatible [CoreReader.Evidence.actionRecord, CoreReader.Evidence.actionRecord] + (true, 0) ∧ + CoreReader.Evidence.Compatible [CoreReader.Evidence.actionRecord, CoreReader.Evidence.actionRecord] + (true, 3) ∧ + ¬CoreReader.Evidence.Supports [CoreReader.Evidence.actionRecord] + CoreReader.Evidence.announcementPosition.consequence ∧ + ¬CoreReader.Evidence.Supports [CoreReader.Evidence.actionRecord, CoreReader.Evidence.actionRecord] + CoreReader.Evidence.announcementPosition.consequence ∧ + ¬CoreReader.Evidence.ValueProcedure CoreReader.Evidence.announcementPosition +'CoreReader.Evidence.measurementRepeatNotSupport' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.measurementRepeatNotSupport "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record.test [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.const `Bool.false []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.const `Bool.true []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))))\n (Lean.Expr.lam\n `w\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero]) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.snd [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))))\n (Lean.Expr.const `CoreReader.Evidence.temperatureRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool [])))))))\n (Lean.Expr.lam\n `w\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.snd [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.consequence [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])))\n (Lean.Expr.const `CoreReader.Evidence.actionRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.consequence [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))))))))" +CoreReader.Logic.compatibilityNotEntailment : + CoreReader.Logic.Satisfiable + (CoreReader.Logic.union CoreReader.Logic.emptyTheory (CoreReader.Logic.singleton fun w => w = true)) ∧ + ¬CoreReader.Logic.Entails CoreReader.Logic.emptyTheory fun w => w = true +'CoreReader.Logic.compatibilityNotEntailment' does not depend on any axioms +ORGANON_TYPE CoreReader.Logic.compatibilityNotEntailment "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.union []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))" +CoreReader.Evidence.selfAssertionNotReason : + (CoreReader.Evidence.unsupportedPosition.commitment true ∧ + ¬CoreReader.Evidence.ValueProcedure CoreReader.Evidence.unsupportedPosition) ∧ + (CoreReader.Evidence.announcementPosition.reasons ≠ [] ∧ + CoreReader.Evidence.announcementPosition.commitment (true, 0) ∧ + ¬CoreReader.Evidence.announcementPosition.consequence (true, 0) ∧ + ¬CoreReader.Evidence.ValueProcedure CoreReader.Evidence.announcementPosition) ∧ + CoreReader.Evidence.JointAdoption CoreReader.Evidence.announcementPosition +'CoreReader.Evidence.selfAssertionNotReason' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.selfAssertionNotReason "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.commitment [])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.unsupportedPosition []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.unsupportedPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.Position [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.reasons [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.Position [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.commitment [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.consequence [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.mk [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Bool.true []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.JointAdoption [])\n (Lean.Expr.const `CoreReader.Evidence.BudgetWorld []))\n (Lean.Expr.const `CoreReader.Evidence.announcementPosition [])))" +CoreReader.Evidence.valueWithoutSelfProof : + CoreReader.Evidence.ValueProcedure CoreReader.Evidence.switchPosition ∧ + CoreReader.Logic.Satisfiable CoreReader.Evidence.switchPosition.starting ∧ + ¬CoreReader.Logic.Entails CoreReader.Logic.emptyTheory CoreReader.Evidence.switchPosition.commitment ∧ + (CoreReader.Evidence.JointAdoption CoreReader.Evidence.oppositePosition ∧ + ¬CoreReader.Evidence.ValueProcedure CoreReader.Evidence.oppositePosition) ∧ + ¬CoreReader.Evidence.ValueProcedure CoreReader.Evidence.contradictoryStartingPosition ∧ + ¬CoreReader.Evidence.ValueProcedure CoreReader.Evidence.impossibleAdoptionPosition +'CoreReader.Evidence.valueWithoutSelfProof' depends on axioms: [propext, Classical.choice, Quot.sound] +ORGANON_TYPE CoreReader.Evidence.valueWithoutSelfProof "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Satisfiable []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValuePosition.starting []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.Entails []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.emptyTheory []) (Lean.Expr.const `Bool [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.commitment [])\n (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.JointAdoption []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.oppositePosition [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.oppositePosition [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.contradictoryStartingPosition []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.ValueProcedure []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.impossibleAdoptionPosition [])))))))" +CoreReader.Evidence.heterogeneousReasons : + CoreReader.Evidence.FacetDischarged CoreReader.Evidence.switchEmpirical ∧ + CoreReader.Evidence.FacetDischarged + (CoreReader.Evidence.Facet.inferential (CoreReader.Logic.singleton fun w => w = true) fun w => w = true) ∧ + CoreReader.Evidence.FacetDischarged (CoreReader.Evidence.Facet.value CoreReader.Evidence.switchPosition) ∧ + CoreReader.Evidence.JointReasonsExample +'CoreReader.Evidence.heterogeneousReasons' depends on axioms: [propext, Classical.choice, Quot.sound] +ORGANON_TYPE CoreReader.Evidence.heterogeneousReasons "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet.inferential []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Logic.singleton []) (Lean.Expr.const `Bool []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `Bool [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet.value []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchPosition []))))\n (Lean.Expr.const `CoreReader.Evidence.JointReasonsExample [])))" +CoreReader.Evidence.localNotUniversal : + (∃ outside, outside ≠ 0) ∧ + (CoreReader.Evidence.Compatible [CoreReader.Evidence.zeroRecord] fun x => true) ∧ + CoreReader.Evidence.Compatible [CoreReader.Evidence.zeroRecord] (CoreReader.Evidence.localGenerator 0) ∧ + (CoreReader.Evidence.allTrue fun x => true) ∧ + ¬CoreReader.Evidence.allTrue (CoreReader.Evidence.localGenerator 0) ∧ + ¬CoreReader.Evidence.Supports [CoreReader.Evidence.zeroRecord] CoreReader.Evidence.allTrue +'CoreReader.Evidence.localNotUniversal' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.localNotUniversal "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lam\n `outside\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 2451398637) \"_hygCtx\") \"_hyg\") 33)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 2451398637) \"_hygCtx\") \"_hyg\") 57)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])))))))" +CoreReader.Evidence.hiddenDifference : + (∀ (n : Nat), n = 0 → (fun x => true) n = CoreReader.Evidence.localGenerator 0 n) ∧ + (fun x => true) 1 ≠ CoreReader.Evidence.localGenerator 0 1 +'CoreReader.Evidence.hiddenDifference' does not depend on any axioms +ORGANON_TYPE CoreReader.Evidence.hiddenDifference "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 3849707129) \"_hygCtx\") \"_hyg\") 28)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.lam\n (Lean.Name.mkNum (Lean.Name.mkStr (Lean.Name.mkStr (Lean.Name.mkNum `x.«_@».CoreReader.Evidence 3849707129) \"_hygCtx\") \"_hyg\") 45)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool.true [])\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.localGenerator [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))" +CoreReader.Evidence.singleObservation : + [CoreReader.Evidence.zeroRecord].length = 1 ∧ + (∃ f, CoreReader.Evidence.Compatible [CoreReader.Evidence.zeroRecord] f) ∧ + (CoreReader.Evidence.Supports [CoreReader.Evidence.zeroRecord] fun f => f 0 = true) ∧ + ¬CoreReader.Evidence.Supports [CoreReader.Evidence.zeroRecord] CoreReader.Evidence.allTrue +'CoreReader.Evidence.singleObservation' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.singleObservation "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.length [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.lam\n `f\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.lam\n `f\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.bvar 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.const `Bool.true []))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Supports [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))\n (Lean.Expr.const `CoreReader.Evidence.zeroRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `Nat [])\n (Lean.Expr.const `Bool [])\n (Lean.BinderInfo.default))))))\n (Lean.Expr.const `CoreReader.Evidence.allTrue [])))))" +CoreReader.Evidence.noUniversalChain : + CoreReader.Evidence.FacetDischarged CoreReader.Evidence.arithmeticFacet ∧ + CoreReader.Evidence.usesObservation CoreReader.Evidence.arithmeticFacet = false +'CoreReader.Evidence.noUniversalChain' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.noUniversalChain "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.usesObservation []) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet [])))\n (Lean.Expr.const `Bool.false []))" +CoreReader.Evidence.variableOutcomesStableBound : + have a := { setting := 0, actualOutcome := 1, recordedOutcome := 1 }; + have b := { setting := 0, actualOutcome := 2, recordedOutcome := 2 }; + CoreReader.Evidence.Reproduced a b ∧ + a.actualOutcome ≠ b.actualOutcome ∧ CoreReader.Evidence.Bounded a ∧ CoreReader.Evidence.Bounded b +'CoreReader.Evidence.variableOutcomesStableBound' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Evidence.variableOutcomesStableBound "Lean.Expr.letE\n `a\n (Lean.Expr.const `CoreReader.Evidence.Trial [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.letE\n `b\n (Lean.Expr.const `CoreReader.Evidence.Trial [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Reproduced []) (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Trial.actualOutcome []) (Lean.Expr.bvar 1)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Trial.actualOutcome []) (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Bounded []) (Lean.Expr.bvar 1)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Bounded []) (Lean.Expr.bvar 0)))))\n true)\n true" +CoreReader.Evidence.verificationReproductionStability : + (CoreReader.Evidence.Verified { setting := 0, actualOutcome := 1, recordedOutcome := 1 } ∧ + CoreReader.Evidence.Verified { setting := 1, actualOutcome := 1, recordedOutcome := 1 } ∧ + ¬CoreReader.Evidence.Reproduced { setting := 0, actualOutcome := 1, recordedOutcome := 1 } + { setting := 1, actualOutcome := 1, recordedOutcome := 1 }) ∧ + (CoreReader.Evidence.Reproduced { setting := 0, actualOutcome := 1, recordedOutcome := 1 } + { setting := 0, actualOutcome := 3, recordedOutcome := 2 } ∧ + ¬CoreReader.Evidence.Verified { setting := 0, actualOutcome := 3, recordedOutcome := 2 } ∧ + ¬CoreReader.Evidence.Bounded { setting := 0, actualOutcome := 3, recordedOutcome := 2 }) ∧ + CoreReader.Evidence.Bounded { setting := 0, actualOutcome := 1, recordedOutcome := 1 } ∧ + CoreReader.Evidence.Bounded { setting := 0, actualOutcome := 2, recordedOutcome := 0 } ∧ + ¬CoreReader.Evidence.Verified { setting := 0, actualOutcome := 2, recordedOutcome := 0 } +'CoreReader.Evidence.verificationReproductionStability' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Evidence.verificationReproductionStability "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Reproduced [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Reproduced [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2))))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Bounded [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2))))))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Bounded [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Bounded [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Verified [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Trial.mk [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 2)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 2)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))))))" +CoreReader.Evidence.outputNotExplanation : + CoreReader.Evidence.OutputContract CoreReader.Evidence.outputOnlyProcess ∧ + ¬CoreReader.Evidence.ExplanationContract CoreReader.Evidence.outputOnlyProcess ∧ + CoreReader.Evidence.OutputContractEvidence +'CoreReader.Evidence.outputNotExplanation' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.outputNotExplanation "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))))\n (Lean.Expr.const `CoreReader.Evidence.OutputContractEvidence []))" +CoreReader.Evidence.applicationContractsDiffer : + (CoreReader.Evidence.OutputContract CoreReader.Evidence.outputOnlyProcess ∧ + ¬(CoreReader.Evidence.OutputContract CoreReader.Evidence.outputOnlyProcess ∧ + CoreReader.Evidence.ExplanationContract CoreReader.Evidence.outputOnlyProcess)) ∧ + (CoreReader.Evidence.OutputContract CoreReader.Evidence.explainedProcess ∧ + CoreReader.Evidence.ExplanationContract CoreReader.Evidence.explainedProcess) ∧ + CoreReader.Evidence.ScopedApplicationEvidence +'CoreReader.Evidence.applicationContractsDiffer' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.applicationContractsDiffer "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.explainedProcess [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.explainedProcess []))))\n (Lean.Expr.const `CoreReader.Evidence.ScopedApplicationEvidence []))" +CoreReader.Evidence.externalAssessment : + (∃ certificate, + certificate.assessorId = 42 ∧ + certificate.assessedId = 7 ∧ + certificate.assessorId ≠ certificate.assessedId ∧ + CoreReader.Evidence.OutputContract CoreReader.Evidence.outputOnlyProcess) ∧ + CoreReader.Evidence.ProcessGrounds CoreReader.Evidence.outputOnlyProcess CoreReader.Evidence.OutputContract ∧ + ¬CoreReader.Evidence.ExplanationContract CoreReader.Evidence.outputOnlyProcess +'CoreReader.Evidence.externalAssessment' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.externalAssessment "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Exists [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))\n (Lean.Expr.lam\n `certificate\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessorId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 42)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 42))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessedId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 7)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 7))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessorId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExternalCertificate.assessedId [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess [])))))\n (Lean.BinderInfo.default))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ProcessGrounds [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))\n (Lean.Expr.const `CoreReader.Evidence.OutputContract [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ExplanationContract [])\n (Lean.Expr.const `CoreReader.Evidence.outputOnlyProcess []))))" +CoreReader.Agency.inventoryNotCapability (kind : CoreReader.Agency.InventoryKind) + (ops : List CoreReader.Agency.Operation) (op : CoreReader.Agency.Operation) : + CoreReader.Agency.Available + (List.map (fun x => { kind := kind, content := x }) ops ++ List.map (fun x => { kind := kind, content := x }) ops) + op ↔ + CoreReader.Agency.Available (List.map (fun x => { kind := kind, content := x }) ops) op +'CoreReader.Agency.inventoryNotCapability' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Agency.inventoryNotCapability "Lean.Expr.forallE\n `kind\n (Lean.Expr.const `CoreReader.Agency.InventoryKind [])\n (Lean.Expr.forallE\n `ops\n (Lean.Expr.app (Lean.Expr.const `List [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.forallE\n `op\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Available [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `HAppend.hAppend [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `instHAppendOfAppend [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.instAppend [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Item []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.map [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.lam\n `x\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Item.mk []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.map [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.lam\n `x\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Item.mk []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.bvar 1))))\n (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Available [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.map [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Agency.Operation []))\n (Lean.Expr.const `CoreReader.Agency.Item []))\n (Lean.Expr.lam\n `x\n (Lean.Expr.const `CoreReader.Agency.Operation [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Agency.Item.mk []) (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)" +CoreReader.Choice.statusOnlyFails (req : CoreReader.Choice.Requirements) (i : CoreReader.Choice.Implementation) + (k : CoreReader.Choice.StatusKind) : ¬CoreReader.Choice.JustifiedChoice req i [CoreReader.Choice.Reason.status k] +'CoreReader.Choice.statusOnlyFails' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Choice.statusOnlyFails "Lean.Expr.forallE\n `req\n (Lean.Expr.const `CoreReader.Choice.Requirements [])\n (Lean.Expr.forallE\n `i\n (Lean.Expr.const `CoreReader.Choice.Implementation [])\n (Lean.Expr.forallE\n `k\n (Lean.Expr.const `CoreReader.Choice.StatusKind [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.JustifiedChoice []) (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.Reason.status []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason [])))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)" +CoreReader.Choice.conventionWithReason : + CoreReader.Choice.identityImpl.conventional = true ∧ + CoreReader.Choice.identityImpl.established = true ∧ + CoreReader.Choice.JustifiedChoice CoreReader.Choice.identityRequirements CoreReader.Choice.identityImpl + [CoreReader.Choice.Reason.status CoreReader.Choice.StatusKind.convention, + CoreReader.Choice.Reason.method CoreReader.Choice.MethodReason.output] +'CoreReader.Choice.conventionWithReason' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Choice.conventionWithReason "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.conventional [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl [])))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.established [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl [])))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `List.cons [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.status [])\n (Lean.Expr.const `CoreReader.Choice.StatusKind.convention [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.output [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))))))" +CoreReader.Choice.generalGroundsNotChoice : + (CoreReader.Evidence.Articulated CoreReader.Choice.priorityArticulation ∧ + CoreReader.Choice.AssessmentAccurate false ∧ + (∀ (selected : CoreReader.Choice.Candidate), CoreReader.Logic.Models CoreReader.Choice.statusFacts selected) ∧ + CoreReader.Choice.priorityClaim CoreReader.Choice.Candidate.identity ∧ + ¬CoreReader.Choice.priorityClaim CoreReader.Choice.Candidate.successor ∧ + ¬CoreReader.Logic.Entails CoreReader.Choice.statusFacts CoreReader.Choice.priorityClaim ∧ + ¬CoreReader.Choice.JustifiedChoice CoreReader.Choice.identityRequirements CoreReader.Choice.identityImpl + [CoreReader.Choice.Reason.status CoreReader.Choice.StatusKind.standing]) ∧ + CoreReader.Choice.PolicyIndependenceExample +'CoreReader.Choice.generalGroundsNotChoice' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Choice.generalGroundsNotChoice "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Articulated [])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Choice.priorityArticulation [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.AssessmentAccurate []) (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `selected\n (Lean.Expr.const `CoreReader.Choice.Candidate [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Models [])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Choice.statusFacts []))\n (Lean.Expr.bvar 0))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.priorityClaim [])\n (Lean.Expr.const `CoreReader.Choice.Candidate.identity [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.priorityClaim [])\n (Lean.Expr.const `CoreReader.Choice.Candidate.successor []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Entails [])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Choice.statusFacts []))\n (Lean.Expr.const `CoreReader.Choice.priorityClaim []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.status [])\n (Lean.Expr.const `CoreReader.Choice.StatusKind.standing [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))))))))))))\n (Lean.Expr.const `CoreReader.Choice.PolicyIndependenceExample [])" +CoreReader.Choice.singleFeasible : + (∀ (candidate : CoreReader.Choice.Candidate), + CoreReader.Choice.Feasible CoreReader.Choice.identityRequirements (CoreReader.Choice.implementation candidate) ↔ + candidate = CoreReader.Choice.Candidate.identity) ∧ + CoreReader.Choice.JustifiedChoice CoreReader.Choice.identityRequirements CoreReader.Choice.identityImpl + CoreReader.Choice.objectiveReason +'CoreReader.Choice.singleFeasible' depends on axioms: [propext, Classical.choice, Quot.sound] +ORGANON_TYPE CoreReader.Choice.singleFeasible "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `candidate\n (Lean.Expr.const `CoreReader.Choice.Candidate [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Iff [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Feasible [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Choice.implementation []) (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Choice.Candidate.identity [])))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.const `CoreReader.Choice.objectiveReason []))" +CoreReader.Choice.localNotGlobal : + (∀ (x : Nat), x = 0 → CoreReader.Choice.identityImpl.run x = CoreReader.Choice.changedOutsideZero.run x) ∧ + CoreReader.Choice.identityImpl.run 1 ≠ CoreReader.Choice.changedOutsideZero.run 1 +'CoreReader.Choice.localNotGlobal' does not depend on any axioms +ORGANON_TYPE CoreReader.Choice.localNotGlobal "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `x\n (Lean.Expr.const `Nat [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.changedOutsideZero []))\n (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.changedOutsideZero []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))" +CoreReader.Choice.internalReasons : + CoreReader.Choice.Relevant CoreReader.Choice.identityRequirements CoreReader.Choice.identityImpl + (CoreReader.Choice.Reason.method CoreReader.Choice.MethodReason.explanation) ∧ + CoreReader.Choice.Relevant CoreReader.Choice.identityRequirements CoreReader.Choice.identityImpl + (CoreReader.Choice.Reason.method CoreReader.Choice.MethodReason.applicability) ∧ + CoreReader.Choice.Relevant CoreReader.Choice.identityRequirements CoreReader.Choice.identityImpl + (CoreReader.Choice.Reason.method CoreReader.Choice.MethodReason.simplicity) ∧ + CoreReader.Choice.Relevant CoreReader.Choice.identityRequirements CoreReader.Choice.identityImpl + (CoreReader.Choice.Reason.method CoreReader.Choice.MethodReason.procedure) ∧ + CoreReader.Choice.Relevant CoreReader.Choice.identityRequirements CoreReader.Choice.cheapSuccessor + (CoreReader.Choice.Reason.method CoreReader.Choice.MethodReason.simplicity) ∧ + ¬CoreReader.Choice.JustifiedChoice CoreReader.Choice.identityRequirements CoreReader.Choice.cheapSuccessor + [CoreReader.Choice.Reason.method CoreReader.Choice.MethodReason.simplicity] +'CoreReader.Choice.internalReasons' does not depend on any axioms +ORGANON_TYPE CoreReader.Choice.internalReasons "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.explanation []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.applicability []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.simplicity []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.procedure []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Relevant [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.cheapSuccessor []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.simplicity []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.cheapSuccessor []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.simplicity [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason [])))))))))" +CoreReader.Choice.openNotEquivalent : + CoreReader.Choice.JustifiedChoice CoreReader.Choice.identityRequirements CoreReader.Choice.identityImpl + CoreReader.Choice.objectiveReason ∧ + CoreReader.Choice.identityImpl.run 0 ≠ CoreReader.Choice.successorImpl.run 0 +'CoreReader.Choice.openNotEquivalent' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Choice.openNotEquivalent "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.const `CoreReader.Choice.objectiveReason [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Ne [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.identityImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Implementation.run [])\n (Lean.Expr.const `CoreReader.Choice.successorImpl []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))" +CoreReader.Integration.revisionKeepsConsistency : + CoreReader.Integration.Charter CoreReader.Integration.actualSystem CoreReader.Integration.actual ∧ + CoreReader.Logic.Consistent CoreReader.Integration.revisedHeld CoreReader.Integration.context ∧ + CoreReader.Logic.TruthfulReport CoreReader.Integration.initialSnapshot CoreReader.Integration.revisedSnapshot + true ∧ + ¬CoreReader.Logic.TruthfulReport CoreReader.Integration.initialSnapshot CoreReader.Integration.revisedSnapshot + false +'CoreReader.Integration.revisionKeepsConsistency' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Integration.revisionKeepsConsistency "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.Charter [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Consistent [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.const `CoreReader.Integration.revisedHeld []))\n (Lean.Expr.const `CoreReader.Integration.context [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.TruthfulReport [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.const `CoreReader.Integration.initialSnapshot []))\n (Lean.Expr.const `CoreReader.Integration.revisedSnapshot []))\n (Lean.Expr.const `Bool.true [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.TruthfulReport [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.Question []))\n (Lean.Expr.const `CoreReader.Integration.initialSnapshot []))\n (Lean.Expr.const `CoreReader.Integration.revisedSnapshot []))\n (Lean.Expr.const `Bool.false [])))))" +CoreReader.Integration.ownCapabilityGrounded : + CoreReader.Integration.OwnCapabilityDuty CoreReader.Integration.actualSystem CoreReader.Integration.actual + [CoreReader.Integration.capabilityFacet] ∧ + CoreReader.Integration.capability CoreReader.Integration.actual +'CoreReader.Integration.ownCapabilityGrounded' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Integration.ownCapabilityGrounded "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.OwnCapabilityDuty [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.capability [])\n (Lean.Expr.const `CoreReader.Integration.actual []))" +CoreReader.Integration.groundsSelfAssessment : + CoreReader.Evidence.Grounds (fun w => CoreReader.Integration.GroundsProvision w.snd) + CoreReader.Evidence.canonicalArticulation + (fun f => f = CoreReader.Integration.commitmentFacet CoreReader.Integration.Commitment.grounds) + [CoreReader.Integration.commitmentFacet CoreReader.Integration.Commitment.grounds] ∧ + (CoreReader.Integration.commitmentPosition CoreReader.Integration.Commitment.grounds).limits + CoreReader.Integration.actual ∧ + (CoreReader.Integration.commitmentPosition CoreReader.Integration.Commitment.grounds).relevantCriticism + CoreReader.Integration.actual ∧ + ¬CoreReader.Evidence.ValueProcedure + (CoreReader.Integration.commitmentPositionFor CoreReader.Integration.Commitment.grounds + CoreReader.Integration.Mode.waive) +'CoreReader.Integration.groundsSelfAssessment' depends on axioms: [propext, Classical.choice, Quot.sound] +ORGANON_TYPE CoreReader.Integration.groundsSelfAssessment "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.lam\n `w\n (Lean.Expr.const `CoreReader.Integration.World [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.GroundsProvision [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Prod.snd [Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Candidate []))\n (Lean.Expr.const `CoreReader.Integration.Mode []))\n (Lean.Expr.bvar 0)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentFacet [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.limits [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentPosition [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.relevantCriticism [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentPosition [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds [])))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.commitmentPositionFor [])\n (Lean.Expr.const `CoreReader.Integration.Commitment.grounds []))\n (Lean.Expr.const `CoreReader.Integration.Mode.waive []))))))" +CoreReader.Integration.existingPhilosophyNotPrivileged : + (CoreReader.Integration.currentPhilosophy CoreReader.Integration.actualSystem CoreReader.Integration.actual).form = + CoreReader.Integration.actualSystem.principleForm ∧ + (CoreReader.Integration.currentPhilosophy CoreReader.Integration.actualSystem CoreReader.Integration.actual).mode = + CoreReader.Integration.actualSystem.governance CoreReader.Integration.actual ∧ + ¬CoreReader.Choice.JustifiedChoice CoreReader.Integration.proposalRequirements + (CoreReader.Integration.currentPhilosophy CoreReader.Integration.actualSystem + CoreReader.Integration.actual).implementation + [CoreReader.Choice.Reason.status CoreReader.Choice.StatusKind.standing] ∧ + CoreReader.Choice.JustifiedChoice CoreReader.Integration.proposalRequirements + (CoreReader.Integration.currentPhilosophy CoreReader.Integration.actualSystem + CoreReader.Integration.actual).implementation + [CoreReader.Choice.Reason.method CoreReader.Choice.MethodReason.output] ∧ + (CoreReader.Integration.currentPhilosophy CoreReader.Integration.actualSystem + CoreReader.Integration.actual).review + 0 = + 1 ∧ + (CoreReader.Integration.currentPhilosophy CoreReader.Integration.actualSystem + CoreReader.Integration.actual).review + 1 = + 0 +'CoreReader.Integration.existingPhilosophyNotPrivileged' depends on axioms: [propext, Classical.choice, Quot.sound] +ORGANON_TYPE CoreReader.Integration.existingPhilosophyNotPrivileged "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Agency.Form []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.form [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.principleForm [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.const `CoreReader.Integration.Mode []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.mode [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.System.governance [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Integration.proposalRequirements []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.implementation [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.status [])\n (Lean.Expr.const `CoreReader.Choice.StatusKind.standing [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.JustifiedChoice [])\n (Lean.Expr.const `CoreReader.Integration.proposalRequirements []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.implementation [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Choice.Reason.method [])\n (Lean.Expr.const `CoreReader.Choice.MethodReason.output [])))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.const `CoreReader.Choice.Reason [])))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.review [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.PhilosophyMethod.review [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.currentPhilosophy [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))))))" +CoreReader.Agency.generationNotReflexivity : + CoreReader.Agency.Generative CoreReader.Agency.openPolicy ∧ + ¬CoreReader.Agency.Reflexive 0 (CoreReader.Agency.ownRules 0) [] +'CoreReader.Agency.generationNotReflexivity' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Agency.generationNotReflexivity "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Generative [])\n (Lean.Expr.const `CoreReader.Agency.openPolicy [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Reflexive [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0)))))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.ownRules [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 0)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))\n (Lean.Expr.app (Lean.Expr.const `List.nil [Lean.Level.zero]) (Lean.Expr.const `CoreReader.Agency.WorkRecord []))))" +CoreReader.Integration.charterNotGrounds : + CoreReader.Integration.Charter CoreReader.Integration.actualSystem CoreReader.Integration.actual ∧ + CoreReader.Evidence.Compatible [CoreReader.Integration.costAllowanceRecord] CoreReader.Integration.actual ∧ + ¬CoreReader.Evidence.Grounds CoreReader.Integration.capability CoreReader.Evidence.canonicalArticulation + (fun f => f = CoreReader.Integration.unsupportedCapabilityFacet) + [CoreReader.Integration.unsupportedCapabilityFacet] +'CoreReader.Integration.charterNotGrounds' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Integration.charterNotGrounds "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.Charter [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Compatible [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.costAllowanceRecord []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.zero])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Record [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.const `CoreReader.Integration.capability []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.unsupportedCapabilityFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.unsupportedCapabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))))" +CoreReader.Integration.applicationRetainsDuties (s : CoreReader.Integration.System) (w : CoreReader.Integration.World) + (req : CoreReader.Choice.Requirements) + (contract : CoreReader.Choice.Requirements → CoreReader.Choice.Implementation → Prop) + (articulations : + CoreReader.Evidence.Facet CoreReader.Integration.World → + CoreReader.Evidence.Articulation CoreReader.Integration.World) + (applicable : CoreReader.Evidence.Facet CoreReader.Integration.World → Prop) + (facets : List (CoreReader.Evidence.Facet CoreReader.Integration.World)) + (h : CoreReader.Integration.ApplicationDuties s w req contract articulations applicable facets) : + CoreReader.Agency.Reflexive s.owner (s.rules w) (s.work w) ∧ + (∀ (f : CoreReader.Evidence.Facet CoreReader.Integration.World), applicable f → f ∈ facets) ∧ + ∀ (f : CoreReader.Evidence.Facet CoreReader.Integration.World), + f ∈ facets → + f.claim = CoreReader.Integration.applicationClaim s req contract ∧ + CoreReader.Evidence.Articulated (articulations f) ∧ + CoreReader.Evidence.FacetArticulated (articulations f) f ∧ CoreReader.Evidence.FacetDischarged f +'CoreReader.Integration.applicationRetainsDuties' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Integration.applicationRetainsDuties "Lean.Expr.forallE\n `s\n (Lean.Expr.const `CoreReader.Integration.System [])\n (Lean.Expr.forallE\n `w\n (Lean.Expr.const `CoreReader.Integration.World [])\n (Lean.Expr.forallE\n `req\n (Lean.Expr.const `CoreReader.Choice.Requirements [])\n (Lean.Expr.forallE\n `contract\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Choice.Requirements [])\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.const `CoreReader.Choice.Implementation [])\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `articulations\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Articulation [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `applicable\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.sort (Lean.Level.zero))\n (Lean.BinderInfo.default))\n (Lean.Expr.forallE\n `facets\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.forallE\n `h\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.ApplicationDuties [])\n (Lean.Expr.bvar 6))\n (Lean.Expr.bvar 5))\n (Lean.Expr.bvar 4))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 1))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Agency.Reflexive [])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.System.owner []) (Lean.Expr.bvar 7)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.System.rules []) (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 6)))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.System.work []) (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 6))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.forallE\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app (Lean.Expr.bvar 3) (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const\n `Membership.mem\n [Lean.Level.succ (Lean.Level.zero), Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.bvar 3))\n (Lean.Expr.bvar 1))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)))\n (Lean.Expr.forallE\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.forallE\n (Lean.Name.mkNum `a._@._internal._hyg 0)\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const\n `Membership.mem\n [Lean.Level.succ (Lean.Level.zero), Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.const `List [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.app\n (Lean.Expr.const `List.instMembership [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))\n (Lean.Expr.bvar 2))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Logic.Claim [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet.claim [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.applicationClaim [])\n (Lean.Expr.bvar 9))\n (Lean.Expr.bvar 7))\n (Lean.Expr.bvar 6))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Articulated [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.bvar 5) (Lean.Expr.bvar 1))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.FacetArticulated [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.bvar 5) (Lean.Expr.bvar 1)))\n (Lean.Expr.bvar 1)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.FacetDischarged [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.bvar 1)))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default))\n (Lean.BinderInfo.default)" +CoreReader.Integration.reasonsBelongToCommitments (c : CoreReader.Integration.Commitment) : + CoreReader.Evidence.Grounds (CoreReader.Integration.commitmentClaim c) CoreReader.Evidence.canonicalArticulation + (fun f => f = CoreReader.Integration.commitmentFacet c) [CoreReader.Integration.commitmentFacet c] ∧ + CoreReader.Evidence.JointAdoption (CoreReader.Integration.commitmentPosition c) ∧ + (CoreReader.Integration.commitmentPosition c).relevantCriticism CoreReader.Integration.actual ∧ + ¬CoreReader.Evidence.ValueProcedure + (CoreReader.Integration.commitmentPositionFor c CoreReader.Integration.Mode.waive) +'CoreReader.Integration.reasonsBelongToCommitments' depends on axioms: [propext, Classical.choice, Quot.sound] +ORGANON_TYPE CoreReader.Integration.reasonsBelongToCommitments "Lean.Expr.forallE\n `c\n (Lean.Expr.const `CoreReader.Integration.Commitment [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentClaim []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentFacet []) (Lean.Expr.bvar 1)))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentFacet []) (Lean.Expr.bvar 0)))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.JointAdoption [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentPosition []) (Lean.Expr.bvar 0))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValuePosition.relevantCriticism [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentPosition []) (Lean.Expr.bvar 0)))\n (Lean.Expr.const `CoreReader.Integration.actual [])))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.ValueProcedure [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Integration.commitmentPositionFor []) (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.Mode.waive [])))))))\n (Lean.BinderInfo.default)" +CoreReader.Evidence.nonExecutableAssessment : + CoreReader.Evidence.Grounds (fun n => n + 1 = 3) CoreReader.Evidence.canonicalArticulation + (fun f => f = CoreReader.Evidence.arithmeticFacet) [CoreReader.Evidence.arithmeticFacet] ∧ + CoreReader.Evidence.usesObservation CoreReader.Evidence.arithmeticFacet = false ∧ + CoreReader.Evidence.FacetDischarged CoreReader.Evidence.switchEmpirical ∧ + CoreReader.Evidence.usesObservation CoreReader.Evidence.switchEmpirical = true +'CoreReader.Evidence.nonExecutableAssessment' depends on axioms: [propext] +ORGANON_TYPE CoreReader.Evidence.nonExecutableAssessment "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Grounds []) (Lean.Expr.const `Nat []))\n (Lean.Expr.lam\n `n\n (Lean.Expr.const `Nat [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero])\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `instHAdd [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `instAddNat [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 1)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat []))\n (Lean.Expr.lit (Lean.Literal.natVal 3)))\n (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 3)))))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation []) (Lean.Expr.const `Nat [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat [])))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.Facet []) (Lean.Expr.const `Nat []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.usesObservation []) (Lean.Expr.const `Nat []))\n (Lean.Expr.const `CoreReader.Evidence.arithmeticFacet [])))\n (Lean.Expr.const `Bool.false [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.FacetDischarged []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool []))\n (Lean.Expr.app\n (Lean.Expr.app (Lean.Expr.const `CoreReader.Evidence.usesObservation []) (Lean.Expr.const `Bool []))\n (Lean.Expr.const `CoreReader.Evidence.switchEmpirical [])))\n (Lean.Expr.const `Bool.true []))))" +CoreReader.Integration.applicationVariation : + CoreReader.Integration.ApplicationDuties CoreReader.Integration.actualSystem CoreReader.Integration.actual + CoreReader.Choice.identityRequirements CoreReader.Integration.outputContract + CoreReader.Evidence.canonicalArticulation (fun f => f = CoreReader.Integration.capabilityFacet) + [CoreReader.Integration.capabilityFacet] ∧ + ¬CoreReader.Integration.applicationClaim CoreReader.Integration.actualSystem + CoreReader.Integration.successorRequirements CoreReader.Integration.outputContract + CoreReader.Integration.actual ∧ + ¬CoreReader.Evidence.Grounds + (CoreReader.Integration.applicationClaim CoreReader.Integration.actualSystem + CoreReader.Integration.successorRequirements CoreReader.Integration.outputContract) + CoreReader.Evidence.canonicalArticulation (fun f => f = CoreReader.Integration.changedObjectiveFacet) + [CoreReader.Integration.changedObjectiveFacet] +'CoreReader.Integration.applicationVariation' depends on axioms: [propext, Quot.sound] +ORGANON_TYPE CoreReader.Integration.applicationVariation "Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.ApplicationDuties [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.actual []))\n (Lean.Expr.const `CoreReader.Choice.identityRequirements []))\n (Lean.Expr.const `CoreReader.Integration.outputContract []))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.capabilityFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))))))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `And [])\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.applicationClaim [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.successorRequirements []))\n (Lean.Expr.const `CoreReader.Integration.outputContract []))\n (Lean.Expr.const `CoreReader.Integration.actual []))))\n (Lean.Expr.app\n (Lean.Expr.const `Not [])\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Grounds [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Integration.applicationClaim [])\n (Lean.Expr.const `CoreReader.Integration.actualSystem []))\n (Lean.Expr.const `CoreReader.Integration.successorRequirements []))\n (Lean.Expr.const `CoreReader.Integration.outputContract [])))\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.canonicalArticulation [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.lam\n `f\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World []))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.succ (Lean.Level.zero))])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.bvar 0))\n (Lean.Expr.const `CoreReader.Integration.changedObjectiveFacet []))\n (Lean.BinderInfo.default)))\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.app\n (Lean.Expr.const `List.cons [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))\n (Lean.Expr.const `CoreReader.Integration.changedObjectiveFacet []))\n (Lean.Expr.app\n (Lean.Expr.const `List.nil [Lean.Level.succ (Lean.Level.zero)])\n (Lean.Expr.app\n (Lean.Expr.const `CoreReader.Evidence.Facet [])\n (Lean.Expr.const `CoreReader.Integration.World [])))))))" diff --git a/lean/philosophy/evidence/manuscript-check.json b/lean/philosophy/evidence/manuscript-check.json new file mode 100644 index 0000000..3214ff9 --- /dev/null +++ b/lean/philosophy/evidence/manuscript-check.json @@ -0,0 +1,521 @@ +{ + "passed": true, + "semantic_status": "not_evaluated", + "current_source": "current", + "current_baseline": "not_selected", + "errors": [], + "entries": [ + { + "id": "organon.preamble.p1", + "kernel": "passed", + "reported_fidelity": "not_applicable", + "reported_status": "not_applicable", + "effective_status": "not_applicable", + "context_only": true + }, + { + "id": "organon.preamble.p2", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter", + "kernel": "not_checked", + "reported_fidelity": "not_applicable", + "reported_status": "not_applicable", + "effective_status": "not_applicable" + }, + { + "id": "organon.charter.overview.p1", + "kernel": "not_checked", + "reported_fidelity": "not_applicable", + "reported_status": "not_applicable", + "effective_status": "not_applicable" + }, + { + "id": "organon.charter.overview.p2", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.overview.p3", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.self-transcendence.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "incomplete", + "effective_status": "incomplete" + }, + { + "id": "organon.charter.self-transcendence.orientation.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.self-transcendence.non-finality.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.self-transcendence.limits.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.self-transcendence.limits.p2", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.consistency.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.consistency.meaning.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.consistency.meaning.p2", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.consistency.limits.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.charter.reflexivity.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "incomplete", + "effective_status": "incomplete" + }, + { + "id": "organon.charter.reflexivity.meaning.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "incomplete", + "effective_status": "incomplete" + }, + { + "id": "organon.charter.reflexivity.limits.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.assessment.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.assessment.p2", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.assessment.p3", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.scope.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.scope.p2", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.scope.p3", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.capabilities.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.capabilities.p2", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.implementations.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.implementations.p2", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.grounds.implementations.limits.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.relationships", + "kernel": "not_checked", + "reported_fidelity": "not_applicable", + "reported_status": "not_applicable", + "effective_status": "not_applicable" + }, + { + "id": "organon.relationships.roles.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.relationships.roles.p2", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.relationships.roles.p3", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + }, + { + "id": "organon.relationships.terms.p1", + "kernel": "passed", + "reported_fidelity": "partial", + "reported_status": "limited", + "effective_status": "limited" + } + ], + "manifest_sha256": "fbadb527c043cd26fd81b06b6ea76c16731ec56ca6b91b5bcc3329cfcf1d73ce", + "proof_targets": { + "sha256": "2400383120ab2d98454597a73cdcaaadf45b8e47b18a646118708dc5d81da2a4", + "complete": true, + "semantic_status": "not_evaluated", + "entries": [ + { + "id": "T01", + "kind": "boundary", + "reported_status": "accepted", + "declarations": [] + }, + { + "id": "T02", + "kind": "satisfiability", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Integration.jointWitness" + ] + }, + { + "id": "T03", + "kind": "specification", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.Generative" + ] + }, + { + "id": "T04", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.permissionNotValuation" + ] + }, + { + "id": "T05", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.revisabilityCovers", + "CoreReader.Agency.revisionWithoutProgress" + ] + }, + { + "id": "T06", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.generationLimits" + ] + }, + { + "id": "T07", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.AchievementAccountability", + "CoreReader.Evidence.achievementNeedsSupport" + ] + }, + { + "id": "T08", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.consequenceConsistency", + "CoreReader.Logic.jointConflict" + ] + }, + { + "id": "T09", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.revisionCanReverse", + "CoreReader.Logic.contextDifferences" + ] + }, + { + "id": "T10", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.semanticChangeMustBeReported", + "CoreReader.Logic.representationOrderIrrelevant", + "CoreReader.Logic.hiddenContextChangeRejected" + ] + }, + { + "id": "T11", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.tensionWithoutContradiction", + "CoreReader.Logic.conflictRequiresChange" + ] + }, + { + "id": "T12", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Logic.consistentFalse", + "CoreReader.Logic.consistentIncomplete" + ] + }, + { + "id": "T13", + "kind": "specification", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.Reflexive" + ] + }, + { + "id": "T14", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.noSelfExemption", + "CoreReader.Agency.applicabilityRetained", + "CoreReader.Agency.selfTestDoesNotProve", + "CoreReader.Evidence.selfOriginDoesNotSupport" + ] + }, + { + "id": "T15", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.Grounds", + "CoreReader.Evidence.supportWeakening", + "CoreReader.Evidence.scopeRestriction" + ] + }, + { + "id": "T16", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.assessmentUnion", + "CoreReader.Evidence.labelsCannotWaive", + "CoreReader.Evidence.mixedMissingResponsibility" + ] + }, + { + "id": "T17", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.articulationNotSupport", + "CoreReader.Evidence.measurementRepeatNotSupport", + "CoreReader.Logic.compatibilityNotEntailment", + "CoreReader.Evidence.selfAssertionNotReason" + ] + }, + { + "id": "T18", + "kind": "satisfiability", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.valueWithoutSelfProof", + "CoreReader.Evidence.heterogeneousReasons" + ] + }, + { + "id": "T19", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.localNotUniversal", + "CoreReader.Evidence.hiddenDifference" + ] + }, + { + "id": "T20", + "kind": "satisfiability", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.singleObservation", + "CoreReader.Evidence.noUniversalChain", + "CoreReader.Evidence.variableOutcomesStableBound", + "CoreReader.Evidence.verificationReproductionStability" + ] + }, + { + "id": "T21", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.outputNotExplanation", + "CoreReader.Evidence.applicationContractsDiffer", + "CoreReader.Evidence.externalAssessment", + "CoreReader.Agency.inventoryNotCapability" + ] + }, + { + "id": "T22", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Choice.statusOnlyFails", + "CoreReader.Choice.conventionWithReason" + ] + }, + { + "id": "T23", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Choice.generalGroundsNotChoice" + ] + }, + { + "id": "T24", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Choice.singleFeasible", + "CoreReader.Choice.localNotGlobal", + "CoreReader.Choice.internalReasons", + "CoreReader.Choice.openNotEquivalent" + ] + }, + { + "id": "T25", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Integration.revisionKeepsConsistency", + "CoreReader.Integration.ownCapabilityGrounded", + "CoreReader.Integration.groundsSelfAssessment", + "CoreReader.Integration.existingPhilosophyNotPrivileged" + ] + }, + { + "id": "T26", + "kind": "nonentailment", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Agency.generationNotReflexivity", + "CoreReader.Integration.charterNotGrounds", + "CoreReader.Integration.jointWitness" + ] + }, + { + "id": "T27", + "kind": "theorem", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Integration.applicationRetainsDuties", + "CoreReader.Integration.reasonsBelongToCommitments" + ] + }, + { + "id": "T28", + "kind": "satisfiability", + "reported_status": "accepted", + "declarations": [ + "CoreReader.Evidence.nonExecutableAssessment" + ] + } + ] + } +} diff --git a/lean/philosophy/leanified/CoreReader.lean b/lean/philosophy/leanified/CoreReader.lean new file mode 100644 index 0000000..d7a0677 --- /dev/null +++ b/lean/philosophy/leanified/CoreReader.lean @@ -0,0 +1 @@ +import CoreReader.Integration diff --git a/lean/philosophy/leanified/CoreReader/Agency.lean b/lean/philosophy/leanified/CoreReader/Agency.lean new file mode 100644 index 0000000..c5f9f59 --- /dev/null +++ b/lean/philosophy/leanified/CoreReader/Agency.lean @@ -0,0 +1,286 @@ +import CoreReader.Reflexivity + +namespace CoreReader.Agency + +inductive FormKind | organization | method | principle | appearance | artifact + deriving DecidableEq, Repr + +structure Form where + kind : FormKind + version : Nat + deriving DecidableEq, Repr + +inductive Aim | expandUnderstandingAndConstruction | preserveSafeOperation + deriving DecidableEq, Repr + +/- A policy records an adopted valuation, current forms, and permission. It does not assert that valuation is correct or enacted. -/ +structure Policy where + worthPursuing : Aim → Prop + current : Form → Prop + revisable : Form → Prop + permitsVersion : Nat → Nat → Prop + +/- The normative specification keeps valuation and revisability separate from realized transitions. -/ +/-- organon-map CoreReader.Agency.Generative +organon.charter.overview#p2 sha256 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c +organon.charter.overview#p3 sha256 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c +organon.charter.self-transcendence#p1 sha256 f4ca590e2ae15e3882f70c7b2bc46a8911c97cee547c8b137b5493fbf862c8c0 +organon.charter.self-transcendence.orientation#p1 sha256 7f9b85c0816b3d69e417cf3cbe17b7b59931388f84d799ce6730c998037358bf +organon.charter.self-transcendence.non-finality#p1 sha256 4ae4497523e79e0606ab3849c47b6ea16f8888a952e063e6966eb36b750f3df8 +organon.charter.self-transcendence.limits#p1 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.charter.self-transcendence.limits#p2 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +-/ +def Generative (p : Policy) : Prop := + p.worthPursuing .expandUnderstandingAndConstruction ∧ + ∀ f, p.current f → p.revisable f + +def openPolicy : Policy where + worthPursuing a := a = .expandUnderstandingAndConstruction ∨ a = .preserveSafeOperation + current f := f.version = 0 + revisable _ := True + permitsVersion _ _ := True + +def neutralPolicy : Policy := { openPolicy with worthPursuing := fun _ => False } + +/- Permitting a real version change does not supply an adopted value position. -/ +/-- organon-map CoreReader.Agency.permissionNotValuation +organon.charter.self-transcendence.orientation#p1 sha256 7f9b85c0816b3d69e417cf3cbe17b7b59931388f84d799ce6730c998037358bf +-/ +theorem permissionNotValuation : + neutralPolicy.permitsVersion 0 1 ∧ (0 : Nat) ≠ 1 ∧ ¬ Generative neutralPolicy := by + simp [neutralPolicy, openPolicy, Generative] + +/- This is an explicit consequence of the adopted specification, not evidence of actual revision. -/ +/-- organon-map CoreReader.Agency.revisabilityCovers +organon.charter.self-transcendence.non-finality#p1 sha256 4ae4497523e79e0606ab3849c47b6ea16f8888a952e063e6966eb36b750f3df8 +organon.relationships.terms#p1 sha256 0d22f818e4466a5ab4272607ac0ab26997270cf05c64ce9ac547e866068907d1 +-/ +theorem revisabilityCovers (p : Policy) (h : Generative p) (k : FormKind) (v : Nat) + (hc : p.current ⟨k, v⟩) : p.revisable ⟨k, v⟩ := h.2 _ hc + +inductive Operation | copy | successor + deriving DecidableEq, Repr + +def Operation.run : Operation → Nat → Nat + | .copy, n => n + | .successor, n => n + 1 + +inductive InventoryKind | document | term | tool | artifact + deriving DecidableEq, Repr + +structure Item where + kind : InventoryKind + content : Operation + deriving DecidableEq, Repr + +/- Available represented operations are the contents present, not their number of occurrences. -/ +def Available (xs : List Item) (op : Operation) : Prop := + ∃ item ∈ xs, item.content = op + +/- Duplicating any inventory category preserves exactly the represented operation content. -/ +/-- organon-map CoreReader.Agency.inventoryNotCapability +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem inventoryNotCapability (kind : InventoryKind) (ops : List Operation) (op : Operation) : + Available ((ops.map fun x => Item.mk kind x) ++ (ops.map fun x => Item.mk kind x)) op ↔ + Available (ops.map fun x => Item.mk kind x) op := by + simp only [Available, List.mem_append] + constructor + · rintro ⟨x, hx | hx, hop⟩ <;> exact ⟨x, hx, hop⟩ + · rintro ⟨x, hx, hop⟩ + exact ⟨x, Or.inl hx, hop⟩ + +structure State where + understood : List Operation + constructed : List Operation + inventory : List Item + abstractionLayers : List Operation + vocabulary : List Operation + deriving DecidableEq, Repr + +/- A gain must identify an operation newly understood or constructed; this is a disclosed finite capability representation. -/ +def Expanded (before after : State) : Prop := + (∃ op, op ∈ after.understood ∧ op ∉ before.understood) ∨ + (∃ op, op ∈ after.constructed ∧ op ∉ before.constructed) + +def baseState : State := + ⟨[.copy], [.copy], [⟨.artifact, .copy⟩], [.copy], [.copy]⟩ + +def inflatedState : State := + { baseState with + inventory := baseState.inventory ++ baseState.inventory + abstractionLayers := [.copy, .copy] + vocabulary := [.copy, .copy] } + +def stableTrace (_time : Nat) : State := baseState + +/- A revisable policy can govern an unchanged trace; no improvement is hidden in revisability. -/ +/-- organon-map CoreReader.Agency.revisionWithoutProgress +organon.charter.self-transcendence.non-finality#p1 sha256 4ae4497523e79e0606ab3849c47b6ea16f8888a952e063e6966eb36b750f3df8 +organon.relationships.terms#p1 sha256 0d22f818e4466a5ab4272607ac0ab26997270cf05c64ce9ac547e866068907d1 +-/ +theorem revisionWithoutProgress : + Generative openPolicy ∧ + (∀ k : FormKind, openPolicy.revisable ⟨k, 0⟩) ∧ + (∀ t, ¬ Expanded (stableTrace t) (stableTrace (t + 1))) := by + simp [Generative, openPolicy, stableTrace, Expanded] + +structure ExternalResources where + experience : Option Nat + knowledge : Option Nat + collaborator : Option Nat + deriving DecidableEq, Repr + +/- This interpreter actually needs all three external inputs to produce the modeled result. -/ +def assistedExecution (r : ExternalResources) : Option Nat := do + let e ← r.experience + let k ← r.knowledge + let c ← r.collaborator + pure (Operation.copy.run (e + k + c)) + +def availableResources : ExternalResources := ⟨some 1, some 2, some 3⟩ + +/- Stability has a concrete stated reason in this workload: preserve its operation while staying within the one-item budget. -/ +def StableReason (before proposed : State) : Prop := + before.constructed = proposed.constructed ∧ + before.inventory.length ≤ 1 ∧ ¬ proposed.inventory.length ≤ 1 + +/- The policy, current capabilities, execution interface and workload constraints belong to one generating system. -/ +structure GeneratingSystem where + owner : Nat + policy : Policy + current : State + execute : ExternalResources → Option Nat + applicationBudget : Nat + requiredOperations : List Operation +/- The modeled system uses the assisted interpreter under a one-item budget and a copy-operation requirement. -/ +def generatingSystem : GeneratingSystem where + owner := 0 + policy := openPolicy + current := baseState + execute := assistedExecution + applicationBudget := 1 + requiredOperations := [.copy] +/- A stable action retains this system's own current state. -/ +def GeneratingSystem.stableAction (system : GeneratingSystem) : State := system.current +def GeneratingSystem.requirementsMet (system : GeneratingSystem) (state : State) : Prop := + ∀ operation, operation ∈ system.requiredOperations → operation ∈ state.constructed +def GeneratingSystem.withinBudget (system : GeneratingSystem) (state : State) : Prop := + state.inventory.length ≤ system.applicationBudget +/- An expansion report identifies the actual before/after states and the operation/performance it asserts was added. -/ +structure Announcement where + owner : Nat + before : State + after : State + reportedNewOperation : Operation + input : Nat + expectedOutput : Nat + deriving DecidableEq, Repr +/- Reports are generated by this system and identify its actual current state as their baseline. -/ +def GeneratingSystem.report (system : GeneratingSystem) (after : State) + (operation : Operation) (input expectedOutput : Nat) : Announcement := + ⟨system.owner, system.current, after, operation, input, expectedOutput⟩ +/- Report content is interpreted against those very states and the named operation's actual behavior. -/ +def Announcement.claim (report : Announcement) : Prop := + report.reportedNewOperation ∈ report.after.constructed ∧ + report.reportedNewOperation ∉ report.before.constructed ∧ + report.reportedNewOperation.run report.input = report.expectedOutput +/- A true report of this form entails a represented construction expansion. -/ +theorem announcementClaimImpliesExpansion (report : Announcement) (h : report.claim) : + Expanded report.before report.after := Or.inr ⟨report.reportedNewOperation, h.1, h.2.1⟩ +/- This concrete self-report asserts a successor operation for the actual inventory-only inflation. -/ +def inflatedAnnouncement : Announcement := generatingSystem.report inflatedState .successor 0 1 +/- The report asserts a real successor result but its named operation is absent from its own after-state. -/ +theorem inflatedAnnouncementRefuted : + inflatedAnnouncement.before = baseState ∧ inflatedAnnouncement.after = inflatedState ∧ + inflatedAnnouncement.reportedNewOperation = .successor ∧ + inflatedAnnouncement.input = 0 ∧ inflatedAnnouncement.expectedOutput = 1 ∧ + ¬ inflatedAnnouncement.claim ∧ ¬ Expanded inflatedAnnouncement.before inflatedAnnouncement.after := by + simp [inflatedAnnouncement, GeneratingSystem.report, generatingSystem, Announcement.claim, Expanded, baseState, inflatedState] + +/- These transitions share one initial state; only extension adds an actual new operation. -/ +inductive TransitionCase | inflate | extend + deriving DecidableEq, Repr + +def extendedState : State := + { baseState with understood := [.copy, .successor], constructed := [.copy, .successor] } +def transitionBefore (_transition : TransitionCase) : State := baseState +def transitionAfter : TransitionCase → State + | .inflate => inflatedState + | .extend => extendedState +/- Both alternatives are assessed under the same concrete input condition. -/ +def transitionInput (_transition : TransitionCase) : Nat := 0 +def transitionAnnouncement (transition : TransitionCase) : Announcement := + generatingSystem.report (transitionAfter transition) .successor (transitionInput transition) 1 + +/- Eleven boundary branches share a content-bearing trace and executable dependency model. They do not assert a universal law of human capability. -/ +/-- organon-map CoreReader.Agency.generationLimits +organon.charter.self-transcendence.limits#p1 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.charter.self-transcendence.limits#p2 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +-/ +theorem generationLimits : + Generative generatingSystem.policy ∧ + generatingSystem.policy.permitsVersion 0 0 ∧ + ¬ Expanded generatingSystem.current inflatedState ∧ + generatingSystem.current.inventory.length < inflatedState.inventory.length ∧ + generatingSystem.current.abstractionLayers.length < inflatedState.abstractionLayers.length ∧ + generatingSystem.current.vocabulary.length < inflatedState.vocabulary.length ∧ + generatingSystem.execute availableResources = some 6 ∧ + generatingSystem.execute { availableResources with experience := none } = none ∧ + generatingSystem.execute { availableResources with knowledge := none } = none ∧ + generatingSystem.execute { availableResources with collaborator := none } = none ∧ + generatingSystem.execute ⟨none, none, none⟩ = none ∧ + ¬ Expanded generatingSystem.current generatingSystem.stableAction ∧ + generatingSystem.stableAction = generatingSystem.current ∧ + generatingSystem.requirementsMet generatingSystem.stableAction ∧ + generatingSystem.withinBudget generatingSystem.stableAction ∧ + ¬ generatingSystem.withinBudget inflatedState ∧ + StableReason generatingSystem.current inflatedState ∧ + (inflatedAnnouncement = generatingSystem.report inflatedState .successor 0 1 ∧ + inflatedAnnouncement.owner = generatingSystem.owner ∧ + inflatedAnnouncement.before = generatingSystem.current ∧ inflatedAnnouncement.after = inflatedState ∧ + inflatedAnnouncement.reportedNewOperation = .successor ∧ + inflatedAnnouncement.input = 0 ∧ inflatedAnnouncement.expectedOutput = 1 ∧ + ¬ inflatedAnnouncement.claim ∧ ¬ Expanded inflatedAnnouncement.before inflatedAnnouncement.after) := by + simp [generatingSystem, GeneratingSystem.stableAction, GeneratingSystem.requirementsMet, + GeneratingSystem.withinBudget, GeneratingSystem.report, Generative, openPolicy, Expanded, + baseState, inflatedState, assistedExecution, availableResources, Operation.run, + StableReason, inflatedAnnouncement, Announcement.claim] + +/- The empty work log omits an actually applicable system assessment despite an open generative policy. -/ +/-- organon-map CoreReader.Agency.generationNotReflexivity +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem generationNotReflexivity : + Generative openPolicy ∧ ¬ Reflexive 0 (ownRules 0) [] := by + constructor + · simp [Generative, openPolicy] + · intro h + have bad := noSelfExemption 0 (ownRules 0) [] h (assessingRule 0) (by simp [ownRules]) + (.system 0) rfl (by simp [assessingRule, ownSubjects]) + simp [Performed] at bad + +/- The same proposed arithmetic principle is used in the self-test and in the universal correctness claim. -/ +def ownArithmeticPrinciple (n : Nat) : Bool := decide (n + 1 = 2 * n) + +def selfTest (samples : List Nat) : Bool := samples.all ownArithmeticPrinciple + +/- A genuine evaluation on the selected sample succeeds, while the same principle fails at zero. -/ +/-- organon-map CoreReader.Agency.selfTestDoesNotProve +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +theorem selfTestDoesNotProve : + selfTest [1] = true ∧ ownArithmeticPrinciple 0 = false ∧ + ¬ (∀ n, ownArithmeticPrinciple n = true) := by + constructor + · decide + constructor + · decide + · intro h + have bad := h 0 + contradiction + +end CoreReader.Agency diff --git a/lean/philosophy/leanified/CoreReader/Choice.lean b/lean/philosophy/leanified/CoreReader/Choice.lean new file mode 100644 index 0000000..3683f85 --- /dev/null +++ b/lean/philosophy/leanified/CoreReader/Choice.lean @@ -0,0 +1,293 @@ +import CoreReader.Evidence + +namespace CoreReader.Choice +open CoreReader.Logic CoreReader.Evidence + +inductive StatusKind | name | convention | standing + deriving DecidableEq, Repr + +inductive MethodReason | output | explanation | applicability | simplicity | procedure + deriving DecidableEq, Repr + +inductive Reason | status (kind : StatusKind) | method (kind : MethodReason) + deriving DecidableEq, Repr + +/- An implementation has observable behavior, a stated domain, an explanation formula and an execution trace. -/ +structure Implementation where + name : String + conventional : Bool + established : Bool + run : Nat → Nat + cost : Nat + domain : Nat → Prop + explanation : Nat → Nat + trace : Nat → List Nat + +/- An application selects relevant objectives and constraints; no universal ranking or score is prescribed. -/ +structure Requirements where + inputs : Nat → Prop + expected : Nat → Nat + budget : Nat + values : MethodReason → Prop + +/- These are explicit, content-based interpretations of possible method reasons in this application. -/ +def MethodContent (req : Requirements) (i : Implementation) : MethodReason → Prop + | .output => ∀ x, req.inputs x → i.run x = req.expected x + | .explanation => ∀ x, req.inputs x → i.explanation x = i.run x + | .applicability => ∀ x, req.inputs x → i.domain x + | .simplicity => i.cost ≤ req.budget + | .procedure => ∀ x, req.inputs x → (i.trace x).getLast? = some (i.run x) + +/- The extra choice commitment requires both selected relevance and actual reason content; pure status supplies neither. -/ +def Relevant (req : Requirements) (i : Implementation) : Reason → Prop + | .status _ => False + | .method kind => req.values kind ∧ MethodContent req i kind + +def Feasible (req : Requirements) (i : Implementation) : Prop := + (∀ x, req.inputs x → i.run x = req.expected x) ∧ i.cost ≤ req.budget + +/- In this application, a relevant reason is eligible only after its stated output and budget requirements hold. -/ +def JustifiedChoice (req : Requirements) (i : Implementation) (reasons : List Reason) : Prop := + Feasible req i ∧ ∃ reason ∈ reasons, Relevant req i reason + +/- This proves the structural effect of the adopted choice commitment for each of its three status-only cases. -/ +/-- organon-map CoreReader.Choice.statusOnlyFails +organon.grounds.implementations#p1 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +organon.grounds.implementations#p2 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +-/ +theorem statusOnlyFails (req : Requirements) (i : Implementation) (k : StatusKind) : + ¬ JustifiedChoice req i [.status k] := by + rintro ⟨_, reason, hr, hv⟩ + simp only [List.mem_singleton] at hr + subst reason + exact hv + +def identityImpl : Implementation where + name := "Existing identity implementation" + conventional := true + established := true + run n := n + cost := 1 + domain _ := True + explanation n := n + trace n := [n] + +def successorImpl : Implementation where + name := "Successor implementation" + conventional := false + established := false + run n := n + 1 + cost := 2 + domain _ := True + explanation n := n + 1 + trace n := [n, n + 1] + +def changedOutsideZero : Implementation := + { identityImpl with + name := "Changed outside zero" + conventional := false + established := false + run := fun n => if n = 0 then 0 else n + 1 + explanation := fun n => if n = 0 then 0 else n + 1 + trace := fun n => [if n = 0 then 0 else n + 1] } + +def identityRequirements : Requirements where + inputs _ := True + expected n := n + budget := 1 + values _ := True + +def objectiveReason : List Reason := [.method .output] + +theorem identityOutputReason : Relevant identityRequirements identityImpl (.method .output) := by + exact ⟨trivial, fun _ _ => rfl⟩ + +theorem identityFeasible : Feasible identityRequirements identityImpl := + ⟨fun _ _ => rfl, by decide⟩ + +theorem identityJustified : JustifiedChoice identityRequirements identityImpl objectiveReason := + ⟨identityFeasible, .method .output, by simp [objectiveReason], identityOutputReason⟩ + +/- A conventional existing implementation can be selected for an actual requirement, not for status alone. -/ +/-- organon-map CoreReader.Choice.conventionWithReason +organon.grounds.implementations#p1 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +organon.grounds.implementations#p2 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +-/ +theorem conventionWithReason : + identityImpl.conventional = true ∧ identityImpl.established = true ∧ + JustifiedChoice identityRequirements identityImpl [.status .convention, .method .output] := by + exact ⟨rfl, rfl, identityFeasible, .method .output, by simp, identityOutputReason⟩ + +inductive Candidate | identity | successor + deriving DecidableEq, Repr + +def implementation : Candidate → Implementation + | .identity => identityImpl + | .successor => successorImpl + +/- Feasibility is decided by the same stated behavior and resource requirement for either candidate. -/ +/-- organon-map CoreReader.Choice.singleFeasible +organon.grounds.implementations.limits#p1 sha256 db9b5f1803baab0e1b05a3a9e068948667412afa7d692e1da3869ca54be4b870 +-/ +theorem singleFeasible : + (∀ candidate, Feasible identityRequirements (implementation candidate) ↔ candidate = .identity) ∧ + JustifiedChoice identityRequirements identityImpl objectiveReason := by + constructor + · intro candidate + cases candidate + · simp [Feasible, identityRequirements, implementation, identityImpl] + · simp [Feasible, identityRequirements, implementation, successorImpl] + · exact identityJustified + +/- The same observed input can conceal a relevant difference at another input. -/ +/-- organon-map CoreReader.Choice.localNotGlobal +organon.grounds.implementations.limits#p1 sha256 db9b5f1803baab0e1b05a3a9e068948667412afa7d692e1da3869ca54be4b870 +-/ +theorem localNotGlobal : + (∀ x, x = 0 → identityImpl.run x = changedOutsideZero.run x) ∧ + identityImpl.run 1 ≠ changedOutsideZero.run 1 := by + constructor + · intro x hx; subst x; rfl + · decide + +/- This candidate is cheap enough but misses the required identity output. -/ +def cheapSuccessor : Implementation := { successorImpl with cost := 1 } + +theorem eligibleInternalReasonNotSufficient : + Relevant identityRequirements cheapSuccessor (.method .simplicity) ∧ + ¬ JustifiedChoice identityRequirements cheapSuccessor [.method .simplicity] := by + refine ⟨⟨trivial, by change 1 ≤ 1; decide⟩, ?_⟩ + intro h + have bad := h.1.1 0 trivial + cases bad + +/- Each of the four internal-method reasons is eligible because of its actual selected requirement and content. -/ +/-- organon-map CoreReader.Choice.internalReasons +organon.grounds.implementations.limits#p1 sha256 db9b5f1803baab0e1b05a3a9e068948667412afa7d692e1da3869ca54be4b870 +-/ +theorem internalReasons : + Relevant identityRequirements identityImpl (.method .explanation) ∧ + Relevant identityRequirements identityImpl (.method .applicability) ∧ + Relevant identityRequirements identityImpl (.method .simplicity) ∧ + Relevant identityRequirements identityImpl (.method .procedure) ∧ + (Relevant identityRequirements cheapSuccessor (.method .simplicity) ∧ + ¬ JustifiedChoice identityRequirements cheapSuccessor [.method .simplicity]) := by + exact ⟨⟨trivial, fun _ _ => rfl⟩, ⟨trivial, fun _ _ => trivial⟩, + ⟨trivial, by change 1 ≤ 1; decide⟩, ⟨trivial, fun _ _ => rfl⟩, eligibleInternalReasonNotSufficient⟩ + +/- Openness about reasons does not make two actual behaviors identical or reject the existing implementation. -/ +/-- organon-map CoreReader.Choice.openNotEquivalent +organon.grounds.implementations.limits#p1 sha256 db9b5f1803baab0e1b05a3a9e068948667412afa7d692e1da3869ca54be4b870 +-/ +theorem openNotEquivalent : + JustifiedChoice identityRequirements identityImpl objectiveReason ∧ + identityImpl.run 0 ≠ successorImpl.run 0 := by + exact ⟨identityJustified, by decide⟩ + +/- A priority interpretation chooses one of the same two actual implementations. -/ +def priorityClaim : Claim Candidate := fun selected => selected = .identity + +def statusFacts : Theory Candidate := union + (singleton (fun _ => identityImpl.conventional = true)) + (singleton (fun _ => identityImpl.established = true)) + +/- Both interpretations have exactly the same true conventional and established status facts. -/ +theorem statusFactsModel (selected : Candidate) : Models statusFacts selected := by + exact (modelsUnion _ _ _).2 ⟨(modelsSingleton _ _).2 rfl, (modelsSingleton _ _).2 rfl⟩ + +def priorityArticulation : Articulation Candidate := + ⟨["priority", "conventional use", "established status"], statusFacts, + [fun _ => identityImpl.conventional = true, fun _ => identityImpl.established = true], + fun _ => True⟩ + +/- This procedure reports whether the actual status premises entail that very priority claim over its stated two-candidate scope. -/ +def AssessmentAccurate (report : Bool) : Prop := + report = true ↔ Entails statusFacts priorityClaim + +theorem statusDoesNotEntailPriority : ¬ Entails statusFacts priorityClaim := by + intro h + have bad := h .successor (statusFactsModel .successor) + cases bad + +theorem statusAssessmentNonEntailment : + Articulated priorityArticulation ∧ AssessmentAccurate false ∧ + (∀ selected, Models statusFacts selected) ∧ + priorityClaim .identity ∧ ¬ priorityClaim .successor ∧ + ¬ Entails statusFacts priorityClaim ∧ + ¬ JustifiedChoice identityRequirements identityImpl [.status .standing] := by + refine ⟨⟨by simp [priorityArticulation], by simp [priorityArticulation]⟩, + ⟨(by intro h; cases h), (fun h => False.elim (statusDoesNotEntailPriority h))⟩, + statusFactsModel, rfl, (by intro h; cases h), statusDoesNotEntailPriority, + statusOnlyFails _ _ _⟩ + +/- An assessment identifies the exact premises and priority question whose entailment it reports. -/ +structure PriorityAssessment where + premises : Theory Candidate + question : Claim Candidate + report : Bool +/- Accuracy concerns the actual reported entailment question, independently of a later choice policy. -/ +def PriorityAssessment.accurate (assessment : PriorityAssessment) : Prop := + assessment.report = true ↔ Entails assessment.premises assessment.question +/- Both policies receive this same correctly negative status-only priority audit. -/ +def statusPriorityAudit : PriorityAssessment := ⟨statusFacts, priorityClaim, false⟩ +/- Priority reasons are a policy component independent of the assessment's report and objects. -/ +structure ChoicePolicy where + selected : Candidate + priorityReasons : List Reason + assessment : PriorityAssessment +/- This is completion of the specified assessment procedure only, not full compliance with philosophical Grounds. -/ +def GeneralAssessmentFulfilled (policy : ChoicePolicy) : Prop := + Articulated priorityArticulation ∧ policy.assessment = statusPriorityAudit ∧ policy.assessment.accurate +/- The additional choice norm separately tests the reasons actually used to prioritize the selected implementation. -/ +def AdditionalChoiceNorm (policy : ChoicePolicy) : Prop := + JustifiedChoice identityRequirements (implementation policy.selected) policy.priorityReasons +/- This policy retains status alone as its priority reason despite receiving the correctly negative status audit. -/ +def statusPriorityPolicy : ChoicePolicy := ⟨.identity, [.status .standing], statusPriorityAudit⟩ +/- This policy selects the same implementation using its actual relevant output reason after the same audit. -/ +def outputPriorityPolicy : ChoicePolicy := ⟨.identity, objectiveReason, statusPriorityAudit⟩ +/- The shared negative result is mathematically accurate for its actual status premises and question. -/ +theorem statusPriorityAuditAccurate : statusPriorityAudit.accurate := by + constructor + · intro h; cases h + · intro h; exact False.elim (statusDoesNotEntailPriority h) +/- These independently variable policies share facts, selected implementation and completed audit, but differ on the extra choice norm. -/ +def PolicyIndependenceExample : Prop := + statusPriorityPolicy.selected = outputPriorityPolicy.selected ∧ + statusPriorityPolicy.assessment = outputPriorityPolicy.assessment ∧ + statusPriorityPolicy.assessment.premises = statusFacts ∧ + statusPriorityPolicy.assessment.question = priorityClaim ∧ + statusPriorityPolicy.assessment.report = false ∧ + (∀ selected, Models statusPriorityPolicy.assessment.premises selected) ∧ + statusPriorityPolicy.priorityReasons ≠ outputPriorityPolicy.priorityReasons ∧ + GeneralAssessmentFulfilled statusPriorityPolicy ∧ GeneralAssessmentFulfilled outputPriorityPolicy ∧ + ¬ AdditionalChoiceNorm statusPriorityPolicy ∧ AdditionalChoiceNorm outputPriorityPolicy +/- Changing the actual priority reasons changes choice compliance while the accurate audit remains identical. -/ +theorem policyIndependenceExample : PolicyIndependenceExample := by + have articulated : Articulated priorityArticulation := + ⟨by simp [priorityArticulation], by simp [priorityArticulation]⟩ + refine ⟨rfl,rfl,rfl,rfl,rfl,statusFactsModel,?_, + ⟨articulated,rfl,statusPriorityAuditAccurate⟩, + ⟨articulated,rfl,statusPriorityAuditAccurate⟩,?_,?_⟩ + · decide + · exact statusOnlyFails identityRequirements identityImpl .standing + · exact identityJustified + +/- A correctly articulated, completed negative assessment does not enforce the additional selection rule. +This is only independence from represented assessment procedures: keeping this unsupported priority would fail general support proportionality too. -/ +/-- organon-map CoreReader.Choice.generalGroundsNotChoice +organon.grounds.implementations#p1 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +organon.grounds.implementations#p2 sha256 bb2a822a304d4a20f513218f356ddbeeca8ee139e3ed802213591e9ff6c5095c +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem generalGroundsNotChoice : + (Articulated priorityArticulation ∧ AssessmentAccurate false ∧ + (∀ selected, Models statusFacts selected) ∧ + priorityClaim .identity ∧ ¬ priorityClaim .successor ∧ + ¬ Entails statusFacts priorityClaim ∧ + ¬ JustifiedChoice identityRequirements identityImpl [.status .standing]) ∧ + PolicyIndependenceExample := + ⟨statusAssessmentNonEntailment, policyIndependenceExample⟩ + +end CoreReader.Choice diff --git a/lean/philosophy/leanified/CoreReader/Evidence.lean b/lean/philosophy/leanified/CoreReader/Evidence.lean new file mode 100644 index 0000000..8b45614 --- /dev/null +++ b/lean/philosophy/leanified/CoreReader/Evidence.lean @@ -0,0 +1,848 @@ +import CoreReader.Logic +import CoreReader.Agency + +namespace CoreReader.Evidence +open CoreReader.Logic +open CoreReader.Agency + +/- An observation records the outcome of a specified test on the represented world. -/ +structure Record (W : Type) where + test : W → Bool + observed : Bool +/- Compatible worlds reproduce the actual contents of every recorded observation. -/ +def Compatible {W : Type} (records : List (Record W)) (w : W) : Prop := + ∀ r, r ∈ records → r.test w = r.observed +/- Inferential support requires the same claim in every evidence-compatible world. -/ +def Supports {W : Type} (records : List (Record W)) (claim : Claim W) : Prop := + ∀ w, Compatible records w → claim w +/- Articulation identifies concepts, premises, reason contents and an application limit. -/ +structure Articulation (W : Type) where + concepts : List String + assumptions : Theory W + reasons : List (Claim W) + limits : Claim W +/- Nonempty identifiable concepts and reasons are procedural articulation requirements. -/ +def Articulated {W : Type} (a : Articulation W) : Prop := + a.concepts ≠ [] ∧ a.reasons ≠ [] +/- This application model interprets an adopted option through its actual outcomes and stated goals/constraints. -/ +structure ValuePosition (W : Type) where + Position : Type + Outcome : Type + adopted : Position + selected : W → Position + outcome : W → Position → Outcome + objective : Outcome → Prop + constraints : W → Position → Prop + starting : Theory W + reasons : List (W → Position → Prop) + limits : Claim W + relevantCriticism : Claim W + response : W → Option String +/- The adopted position's claim is derived from the same selected option used by the outcome interpretation. -/ +def ValuePosition.commitment {W : Type} (v : ValuePosition W) : Claim W := + fun w => v.selected w = v.adopted +/- Assessed consequences concern this adopted option's actual outcome, objective and constraints. -/ +def ValuePosition.consequence {W : Type} (v : ValuePosition W) : Claim W := + fun w => v.objective (v.outcome w v.adopted) ∧ v.constraints w v.adopted +/- Articulated reasons specialize the actual option-indexed premises to the adopted option. -/ +def ValuePosition.activeReasons {W : Type} (v : ValuePosition W) : List (Claim W) := + v.reasons.map (fun reason w => reason w v.adopted) +/- A joint witness excludes inconsistent starts and impossible adoption states. -/ +def JointAdoption {W : Type} (v : ValuePosition W) : Prop := + ∃ w, Models v.starting w ∧ v.limits w ∧ v.commitment w ∧ + ∀ reason, reason ∈ v.reasons → reason w v.adopted +/- This declared option/outcome adapter checks joint reasons for an assessed consequence; it is not a necessary deductive form for all value justification. -/ +def ValueProcedure {W : Type} (v : ValuePosition W) : Prop := + v.reasons ≠ [] ∧ JointAdoption v ∧ + (∀ w, Models v.starting w → v.limits w → + (∀ reason, reason ∈ v.reasons → reason w v.adopted) → v.consequence w) ∧ + (∀ w, v.limits w → v.relevantCriticism w → ∃ answer, v.response w = some answer ∧ answer ≠ "") +/- A facet carries its specific contents; several different facets can have the same conclusion. -/ +inductive Facet (W : Type) where + | empirical (records : List (Record W)) (scope conclusion uncertainty : Claim W) + | inferential (assumptions : Theory W) (conclusion : Claim W) + | value (position : ValuePosition W) +/- The claim referred to by each assessment facet is explicit. -/ +def Facet.claim {W : Type} : Facet W → Claim W + | .empirical _ _ p _ => p + | .inferential _ p => p + | .value v => v.commitment +/- These disclosed semantic adapters implement selected nature-specific checks; passing them does not establish all real empirical or value adequacy. -/ +def FacetDischarged {W : Type} : Facet W → Prop + | .empirical records scope p uncertainty => + (∃ w, Compatible records w ∧ scope w) ∧ + Supports records (fun w => scope w → p w) ∧ Supports records uncertainty + | .inferential assumptions p => Satisfiable assumptions ∧ Entails assumptions p + | .value v => ValueProcedure v +/- This model's semantic adapter identifies the actual assumptions, reason content and limit of a facet. -/ +def FacetArticulated {W : Type} (a : Articulation W) : Facet W → Prop + | .empirical records scope _ _ => + a.assumptions = singleton (Compatible records) ∧ a.reasons = [Compatible records] ∧ a.limits = scope + | .inferential assumptions _ => + a.assumptions = assumptions ∧ a.reasons = [Models assumptions] ∧ a.limits = (fun _ => True) + | .value v => a.assumptions = v.starting ∧ a.reasons = v.activeReasons ∧ a.limits = v.limits +/- A canonical articulation exposes this adapter; the source does not mandate this particular representation of grounds. -/ +def canonicalArticulation {W : Type} : Facet W → Articulation W + | .empirical records scope _ _ => + ⟨["recorded test outcomes", "observation conditions"], singleton (Compatible records), [Compatible records], scope⟩ + | .inferential assumptions _ => + ⟨["stated assumptions", "semantic consequence"], assumptions, [Models assumptions], fun _ => True⟩ + | .value v => + ⟨["adopted position", "reasons and consequences"], v.starting, v.activeReasons, v.limits⟩ +/- Canonical articulation is connected to the very facet whose grounds it identifies. -/ +theorem canonicalFacetArticulated {W : Type} (f : Facet W) : + FacetArticulated (canonicalArticulation f) f := by + cases f <;> exact ⟨rfl, rfl, rfl⟩ +/- A discharged facet has nonempty canonical reason articulation, including the value procedure's reason requirement. -/ +theorem canonicalArticulated {W : Type} (f : Facet W) (h : FacetDischarged f) : + Articulated (canonicalArticulation f) := by + cases f with + | empirical records scope p uncertainty => simp [Articulated, canonicalArticulation] + | inferential assumptions p => simp [Articulated, canonicalArticulation] + | value v => + refine ⟨by simp [canonicalArticulation], ?_⟩ + simpa [canonicalArticulation, ValuePosition.activeReasons] using h.1 +/- This model of the Grounds obligation binds each actual facet to its claim and articulation. Its disclosed FacetDischarged adapters do not replace all source-level assessment responsibilities or prove real adequacy. -/ +/-- organon-map CoreReader.Evidence.Grounds +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +def Grounds {W : Type} (claim : Claim W) (articulations : Facet W → Articulation W) + (actualApplicable : Facet W → Prop) (facets : List (Facet W)) : Prop := + facets ≠ [] ∧ (∀ facet, actualApplicable facet → facet ∈ facets) ∧ + ∀ facet, facet ∈ facets → facet.claim = claim ∧ Articulated (articulations facet) ∧ + FacetArticulated (articulations facet) facet ∧ FacetDischarged facet +/- The achievement obligation requires grounds for this very claim, without making observation a universal prerequisite. -/ +/-- organon-map CoreReader.Evidence.AchievementAccountability +organon.charter.self-transcendence.limits#p1 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.charter.self-transcendence.limits#p2 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +def AchievementAccountability {W : Type} (achievement : Claim W) (articulations : Facet W → Articulation W) + (actualApplicable : Facet W → Prop) (facets : List (Facet W)) : Prop := + Grounds achievement articulations actualApplicable facets +/- The concrete achievement claim refers to each transition's own before/after states. -/ +def transitionAchievement : Claim TransitionCase := + fun transition => Expanded (transitionBefore transition) (transitionAfter transition) +/- This observation inspects an actually constructed successor and its output under that transition's input condition. -/ +def transitionPerformanceRecord : Record TransitionCase := + ⟨fun transition => (transitionAfter transition).constructed.any + (fun operation => operation == .successor && decide (operation.run (transitionInput transition) = 1)), true⟩ +/- The positive report test reads its asserted operation, input and output; it does not verify their presence in the after-state. -/ +def transitionReportRecord : Record TransitionCase := + ⟨fun transition => + let report := transitionAnnouncement transition + report.reportedNewOperation == .successor && report.input == 0 && report.expectedOutput == 1, true⟩ +/- Only the genuine extension matches the operation/performance observation in this two-transition model. -/ +theorem transitionPerformanceCompatible : + ∀ transition, Compatible [transitionPerformanceRecord] transition ↔ transition = .extend := by + intro transition + constructor + · intro h + have observed := h transitionPerformanceRecord (List.mem_singleton.mpr rfl) + cases transition + · cases observed + · rfl + · intro h; cases h + intro record hr; have hr' := List.mem_singleton.mp hr; subst record + rfl +/- A compatible performance observation establishes the same transition's report content and hence its represented expansion. -/ +theorem transitionSupported : Supports [transitionPerformanceRecord] transitionAchievement := by + intro transition compatible + have h := (transitionPerformanceCompatible transition).1 compatible + subst transition + have reportTrue : (transitionAnnouncement .extend).claim := by + simp [transitionAnnouncement, transitionAfter, transitionInput, + Announcement.claim, GeneratingSystem.report, generatingSystem, extendedState, baseState, Operation.run] + exact announcementClaimImpliesExpansion _ reportTrue +/- The actual scope is the shared input-zero condition, with no probabilistic inference introduced. -/ +def transitionFacet : Facet TransitionCase := + .empirical [transitionPerformanceRecord] (fun transition => transitionInput transition = 0) + transitionAchievement (fun _ => True) +/- The empirical assessment has a real compatible witness and supports this scoped achievement. -/ +theorem transitionFacetDischarged : FacetDischarged transitionFacet := by + refine ⟨⟨.extend, (transitionPerformanceCompatible _).2 rfl, rfl⟩, ?_, ?_⟩ + · intro transition compatible _; exact transitionSupported transition compatible + · intro _ _; trivial +/- Every applicable facet of this specified achievement has matching articulation and actual discharged evidence. -/ +theorem transitionAccountable : + AchievementAccountability transitionAchievement canonicalArticulation + (fun facet => facet = transitionFacet) [transitionFacet] := by + refine ⟨by simp, ?_, ?_⟩ + · intro facet hf; subst facet; exact List.mem_singleton.mpr rfl + · intro facet hf; have hf' := List.mem_singleton.mp hf; subst facet + exact ⟨rfl, canonicalArticulated _ transitionFacetDischarged, + canonicalFacetArticulated _, transitionFacetDischarged⟩ +/- Both actual transitions issue the same positive report about their own identified state pair. -/ +theorem transitionReportCompatible (transition : TransitionCase) : + Compatible [transitionReportRecord] transition := by + intro record hr; have hr' := List.mem_singleton.mp hr; subst record + rfl +/- Inflation is a concrete report-compatible counterworld, so the positive report alone does not support the same achievement claim. -/ +theorem transitionReportDoesNotSupport : + Compatible [transitionReportRecord] .inflate ∧ ¬ transitionAchievement .inflate ∧ + ¬ Supports [transitionReportRecord] transitionAchievement := by + have noExpansion : ¬ transitionAchievement .inflate := by + simp [transitionAchievement, transitionBefore, transitionAfter, Expanded, baseState, inflatedState] + exact ⟨transitionReportCompatible _, noExpansion, fun h => noExpansion (h _ (transitionReportCompatible _))⟩ +/- These concrete obligations, positive evidence and negative report case all refer to the same state-pair and input semantics. -/ +def ConcreteAchievementExample : Prop := + AchievementAccountability transitionAchievement canonicalArticulation + (fun facet => facet = transitionFacet) [transitionFacet] ∧ + Compatible [transitionPerformanceRecord] .extend ∧ + Supports [transitionPerformanceRecord] transitionAchievement ∧ transitionAchievement .extend ∧ + (Compatible [transitionReportRecord] .inflate ∧ ¬ transitionAchievement .inflate ∧ + ¬ Supports [transitionReportRecord] transitionAchievement) ∧ + (∀ transition, (transitionAnnouncement transition).before = transitionBefore transition ∧ + (transitionAnnouncement transition).after = transitionAfter transition ∧ + (transitionAnnouncement transition).input = transitionInput transition ∧ transitionInput transition = 0) +/- The concrete example jointly inhabits accountability, evidence compatibility, actual gain, and the report-only countermodel. -/ +theorem concreteAchievementExample : ConcreteAchievementExample := by + refine ⟨transitionAccountable, (transitionPerformanceCompatible _).2 rfl, transitionSupported, + transitionSupported .extend ((transitionPerformanceCompatible _).2 rfl), + transitionReportDoesNotSupport, ?_⟩ + intro transition; exact ⟨rfl,rfl,rfl,rfl⟩ +/- Semantic evidence yields truth only at a world that actually satisfies those evidence conditions. -/ +/-- organon-map CoreReader.Evidence.achievementNeedsSupport +organon.charter.self-transcendence.limits#p1 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.charter.self-transcendence.limits#p2 sha256 6dade83f0b7fcc004bdb37b6726c15b31b06a377de4e86d506c9d2e67847029d +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem achievementNeedsSupport {W : Type} (achievement : Claim W) (records : List (Record W)) + (actual : W) (reliableHere : Compatible records actual) (support : Supports records achievement) : + achievement actual ∧ ConcreteAchievementExample := + ⟨support actual reliableHere, concreteAchievementExample⟩ +/- Weakening a conclusion preserves support; this makes no claim about weakening the evidence. -/ +/-- organon-map CoreReader.Evidence.supportWeakening +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem supportWeakening {W : Type} (records : List (Record W)) (p q : Claim W) + (support : Supports records p) (weaker : ∀ w, p w → q w) : Supports records q := + fun w hw => weaker w (support w hw) +/- Discarding the only informative observation loses support for the unchanged switch claim. -/ +theorem evidenceWeakeningCanLoseSupport : + Supports ([⟨id, true⟩] : List (Record Bool)) (fun w => w = true) ∧ + ¬ Supports ([] : List (Record Bool)) (fun w => w = true) := by + refine ⟨?_, ?_⟩ + · intro w hw; exact hw ⟨id,true⟩ (by simp) + · intro h; have bad := h false (by intro r hr; cases hr); cases bad +/- Restricting the quantified application domain preserves a supported universal conclusion. -/ +/-- organon-map CoreReader.Evidence.scopeRestriction +organon.grounds#p1 sha256 4ee74dc8617388ee75d63b507176ecb73b8527758b648f7c588d3ae7f3445ec6 +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem scopeRestriction {W X : Type} (records : List (Record W)) (p : W → X → Prop) + (wide narrow : X → Prop) (included : ∀ x, narrow x → wide x) + (support : Supports records (fun w => ∀ x, wide x → p w x)) : + Supports records (fun w => ∀ x, narrow x → p w x) := + fun w hw x hx => support w hw x (included x hx) +/- Actual applicability, rather than an optional classifier label, determines facet responsibility. -/ +def Duties {W : Type} (applicable : Facet W → Prop) : Prop := + ∀ f, applicable f → FacetDischarged f +def LabeledDuties {W : Type} (_labels : List String) (applicable : Facet W → Prop) : Prop := + Duties applicable +/- Combining applicable facets requires both sets of substantive duties. -/ +/-- organon-map CoreReader.Evidence.assessmentUnion +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem assessmentUnion {W : Type} (a b : Facet W → Prop) : + Duties (fun f => a f ∨ b f) ↔ Duties a ∧ Duties b := by + constructor + · intro h; exact ⟨fun f hf => h f (Or.inl hf), fun f hf => h f (Or.inr hf)⟩ + · rintro ⟨ha,hb⟩ f (hf|hf); exact ha f hf; exact hb f hf +/- Omitting or changing labels does not remove an applicable duty. -/ +/-- organon-map CoreReader.Evidence.labelsCannotWaive +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem labelsCannotWaive {W : Type} (xs ys : List String) (a : Facet W → Prop) : + LabeledDuties xs a ↔ LabeledDuties ys a := Iff.rfl +/- The observed switch is the outcome itself, not a record identifier. -/ +def switchRecord : Record Bool := ⟨id, true⟩ +theorem switchCompatible (w : Bool) : Compatible [switchRecord] w ↔ w = true := by + constructor + · intro h; exact h switchRecord (by simp) + · intro hw r hr; simp only [List.mem_singleton] at hr; cases hr; exact hw +theorem switchSupported : Supports [switchRecord] (fun w : Bool => w = true) := + fun w hw => (switchCompatible w).1 hw +/- The candidate action has specific benefit and cost outcomes; its inactive alternative has neither. -/ +def optionBenefit (selected : Bool) : Nat := if selected then 4 else 0 +def optionCost (selected : Bool) : Nat := if selected then 3 else 0 +/- The report describes each option's actual cost and benefit; it does not itself assert which option ought to be selected. -/ +def optionReport (selected : Bool) : Prop := + optionCost selected ≤ 3 ∧ optionBenefit selected = (if selected then 4 else 0) +/- The on position connects its own selected option to that option's benefit/cost outcome. -/ +def switchPosition : ValuePosition Bool where + Position := Bool + Outcome := Nat × Nat + adopted := true + selected := id + outcome := fun _ option => (optionBenefit option, optionCost option) + objective := fun result => result.2 < result.1 + constraints := fun _ option => optionCost option ≤ 3 + starting := singleton (fun w => w = true) + reasons := [fun _ option => optionReport option] + limits := fun _ => True + relevantCriticism := fun w => w = false + response := fun w => if w then some "benefit exceeds cost within budget" else some "reconsider if the budget no longer permits this cost" +theorem switchValueProcedure : ValueProcedure switchPosition := by + refine ⟨by simp [switchPosition], ?_, ?_, ?_⟩ + · refine ⟨true, (modelsSingleton _ _).2 rfl, trivial, rfl, ?_⟩ + intro reason hr + have hr' : reason = (fun (_ : Bool) (option : Bool) => optionReport option) := List.mem_singleton.mp hr + subst reason + exact ⟨by decide, rfl⟩ + · intro w _ _ allReasons + have evidence := allReasons (fun (_ : Bool) (option : Bool) => optionReport option) (List.mem_singleton.mpr rfl) + change optionReport true at evidence + have benefitAboveBudget : 3 < optionBenefit true := by rw [evidence.2]; decide + exact ⟨Nat.lt_of_le_of_lt evidence.1 benefitAboveBudget, evidence.1⟩ + · intro w _ _; cases w <;> simp [switchPosition] +/- Adopting the other option updates the adopted starting state too, so rejection cannot be blamed on an inconsistent start. -/ +def oppositePosition : ValuePosition Bool := + { switchPosition with adopted := false, starting := singleton (fun w => w = false) } +/- The alternative has a joint adoption witness but its actual zero benefit/cost fails the adopted strict-benefit objective. -/ +theorem oppositePositionRejected : JointAdoption oppositePosition ∧ ¬ ValueProcedure oppositePosition := by + have witness : JointAdoption oppositePosition := by + refine ⟨false, (modelsSingleton _ _).2 rfl, trivial, rfl, ?_⟩ + intro reason hr + have hr' : reason = (fun (_ : Bool) (option : Bool) => optionReport option) := List.mem_singleton.mp hr + subst reason + exact ⟨by decide, rfl⟩ + refine ⟨witness, ?_⟩ + intro h + have allReasons : ∀ reason, reason ∈ oppositePosition.reasons → reason false oppositePosition.adopted := by + intro reason hr + have hr' : reason = (fun (_ : Bool) (option : Bool) => optionReport option) := List.mem_singleton.mp hr + subst reason + exact ⟨by decide, rfl⟩ + have bad := h.2.2.1 false ((modelsSingleton _ _).2 rfl) trivial allReasons + exact Nat.lt_irrefl 0 bad.1 +/- Contradictory starting assumptions and an impossible selected/adopted equality are separate inadmissible variants. -/ +def contradictoryStartingPosition : ValuePosition Bool := + { switchPosition with starting := singleton (fun _ => False) } +def impossibleAdoptionPosition : ValuePosition Bool := + { switchPosition with selected := fun _ => false } +/- The common-world witness rejects both contradiction and an impossible commitment instead of proving them vacuously. -/ +theorem inadmissibleValuePositionsRejected : + ¬ ValueProcedure contradictoryStartingPosition ∧ ¬ ValueProcedure impossibleAdoptionPosition := by + constructor + · intro h; obtain ⟨w,hw,_,_,_⟩ := h.2.1 + exact (modelsSingleton _ _).1 hw + · intro h; obtain ⟨w,_,_,hw,_⟩ := h.2.1 + cases hw +/- Removing the reasons leaves only a position and assertion, which fails this value procedure. -/ +def unsupportedPosition : ValuePosition Bool := { switchPosition with reasons := [] } +def switchEmpirical : Facet Bool := + .empirical [switchRecord] (fun _ => True) (fun w => w = true) (fun _ => True) +theorem switchEmpiricalDischarged : FacetDischarged switchEmpirical := by + refine ⟨⟨true, (switchCompatible true).2 rfl, trivial⟩, ?_, ?_⟩ + · intro w hw _; exact switchSupported w hw + · intro w _; trivial +/- A mixed empirical/value position has actual empirical evidence but still lacks its value-reason duty. -/ +/-- organon-map CoreReader.Evidence.mixedMissingResponsibility +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem mixedMissingResponsibility : + FacetDischarged switchEmpirical ∧ + ¬ LabeledDuties [] (fun f : Facet Bool => f = switchEmpirical ∨ f = .value unsupportedPosition) := by + refine ⟨switchEmpiricalDischarged, ?_⟩ + intro h + have bad := (h (.value unsupportedPosition) (Or.inr rfl)).1 + exact bad rfl +/- A fully identified argument may still fail to entail the stated conclusion. -/ +def uninformativeArgument : Articulation Bool := + ⟨["switch state"], emptyTheory, [fun _ => True], fun _ => True⟩ +/-- organon-map CoreReader.Evidence.articulationNotSupport +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem articulationNotSupport : Articulated uninformativeArgument ∧ + ¬ Entails uninformativeArgument.assumptions (fun w : Bool => w = true) := by + exact ⟨⟨by simp [uninformativeArgument], by simp [uninformativeArgument]⟩, + consistentIncomplete.2.1⟩ +/- Identifiable but unrelated argument fields cannot replace the actual observation grounds under the connected adapter. -/ +theorem unrelatedArticulationRejected : + Articulated uninformativeArgument ∧ FacetDischarged switchEmpirical ∧ + ¬ FacetArticulated uninformativeArgument switchEmpirical := by + refine ⟨articulationNotSupport.1, switchEmpiricalDischarged, ?_⟩ + intro h + have relation := congrFun h.1 (Compatible [switchRecord]) + have bad : False := relation.mpr rfl + exact bad +/- Repetition of the same unrelated temperature observation leaves the switch state undetermined. -/ +def temperatureRecord : Record (Bool × Bool) := ⟨Prod.fst, true⟩ +theorem temperatureCompatible (b : Bool) : + Compatible [temperatureRecord, temperatureRecord] (true,b) := by + intro r hr + simp at hr + cases hr + rfl +/- The world identifies a selected action and its budget; the action costs three units. -/ +abbrev BudgetWorld := Bool × Nat +/- A real issued announcement asserts the selected action, but says nothing about affordability. -/ +def announcement : String := "activate" +def announcementPosition : ValuePosition BudgetWorld where + Position := Bool + Outcome := Nat × Nat + adopted := true + selected := Prod.fst + outcome := fun _ option => (optionBenefit option, optionCost option) + objective := fun result => result.2 < result.1 + constraints := fun w option => optionCost option ≤ w.2 + starting := singleton (fun w => w.1 = true) + reasons := [fun _ option => announcement = (if option then "activate" else "disable")] + limits := fun _ => True + relevantCriticism := fun w => w.2 < 3 + response := fun _ => some "reconsider the action when its cost exceeds budget" +/- The zero-budget counterworld satisfies the stated starts, adoption and all announced reasons jointly. -/ +theorem announcementHasJointAdoption : JointAdoption announcementPosition := by + refine ⟨(true,0), (modelsSingleton _ _).2 rfl, trivial, rfl, ?_⟩ + intro reason hr + have hr' : reason = (fun (_ : BudgetWorld) (option : Bool) => announcement = (if option then "activate" else "disable")) := + List.mem_singleton.mp hr + subst reason + rfl +/- A nonempty announcement remains true in a jointly admissible zero-budget world but cannot support the action's affordability. -/ +theorem announcementNotBudgetReason : + announcementPosition.reasons ≠ [] ∧ announcementPosition.commitment (true,0) ∧ + (∀ reason, reason ∈ announcementPosition.reasons → reason (true,0) announcementPosition.adopted) ∧ + ¬ announcementPosition.consequence (true,0) ∧ ¬ ValueProcedure announcementPosition := by + refine ⟨by simp [announcementPosition], rfl, ?_, (by intro h; cases h.2), ?_⟩ + · intro reason hr + have hr' : reason = (fun (_ : BudgetWorld) (option : Bool) => announcement = (if option then "activate" else "disable")) := List.mem_singleton.mp hr + subst reason + rfl + · intro h + have allReasons : ∀ reason, reason ∈ announcementPosition.reasons → reason (true,0) announcementPosition.adopted := by + intro reason hr + have hr' : reason = (fun (_ : BudgetWorld) (option : Bool) => announcement = (if option then "activate" else "disable")) := List.mem_singleton.mp hr + subst reason + rfl + have bad := h.2.2.1 (true,0) ((modelsSingleton _ _).2 rfl) trivial allReasons + cases bad.2 +/- A repeated actual selection observation contains no budget information. -/ +def actionRecord : Record BudgetWorld := ⟨Prod.fst, true⟩ +theorem actionCompatible (budget : Nat) : Compatible [actionRecord, actionRecord] (true,budget) := by + intro r hr; simp at hr; cases hr; rfl +/- Single and repeated irrelevant observations cannot establish the other outcome or the same action's budget adequacy. -/ +/-- organon-map CoreReader.Evidence.measurementRepeatNotSupport +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem measurementRepeatNotSupport : + temperatureRecord.test (true,false) = true ∧ + Compatible [temperatureRecord,temperatureRecord] (true,false) ∧ + Compatible [temperatureRecord,temperatureRecord] (true,true) ∧ + ¬ Supports [temperatureRecord] (fun w : Bool × Bool => w.2 = true) ∧ + ¬ Supports [temperatureRecord,temperatureRecord] (fun w : Bool × Bool => w.2 = true) ∧ + Compatible [actionRecord,actionRecord] (true,0) ∧ + Compatible [actionRecord,actionRecord] (true,3) ∧ + ¬ Supports [actionRecord] announcementPosition.consequence ∧ + ¬ Supports [actionRecord,actionRecord] announcementPosition.consequence ∧ + ¬ ValueProcedure announcementPosition := by + refine ⟨rfl, temperatureCompatible false, temperatureCompatible true, ?_, ?_, + actionCompatible 0, actionCompatible 3, ?_, ?_, announcementNotBudgetReason.2.2.2.2⟩ + · intro h + have bad := h (true,false) (by intro r hr; simp only [List.mem_singleton] at hr; cases hr; rfl) + cases bad + · intro h; have bad := h (true,false) (temperatureCompatible false); cases bad + · intro h + have bad := h (true,0) (by intro r hr; simp only [List.mem_singleton] at hr; cases hr; rfl) + cases bad.2 + · intro h; have bad := h (true,0) (actionCompatible 0); cases bad.2 +/- Missing reason records fail a procedure; independently, a present announcement fails the explicit budget-support criterion. -/ +/-- organon-map CoreReader.Evidence.selfAssertionNotReason +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem selfAssertionNotReason : + (unsupportedPosition.commitment true ∧ ¬ ValueProcedure unsupportedPosition) ∧ + (announcementPosition.reasons ≠ [] ∧ announcementPosition.commitment (true,0) ∧ + ¬ announcementPosition.consequence (true,0) ∧ ¬ ValueProcedure announcementPosition) ∧ + JointAdoption announcementPosition := + ⟨⟨rfl, fun h => h.1 rfl⟩, + ⟨announcementNotBudgetReason.1, announcementNotBudgetReason.2.1, + announcementNotBudgetReason.2.2.2.1, announcementNotBudgetReason.2.2.2.2⟩, + announcementHasJointAdoption⟩ +/- The value procedure is satisfiable although the adopted starting commitment is not entailed by empty facts. -/ +/-- organon-map CoreReader.Evidence.valueWithoutSelfProof +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem valueWithoutSelfProof : ValueProcedure switchPosition ∧ + Satisfiable switchPosition.starting ∧ + ¬ Entails (emptyTheory : Theory Bool) switchPosition.commitment ∧ + (JointAdoption oppositePosition ∧ ¬ ValueProcedure oppositePosition) ∧ + (¬ ValueProcedure contradictoryStartingPosition ∧ ¬ ValueProcedure impossibleAdoptionPosition) := + ⟨switchValueProcedure, ⟨true, (modelsSingleton _ _).2 rfl⟩, consistentIncomplete.2.1, + oppositePositionRejected, inadmissibleValuePositionsRejected⟩ +/- The world records the selected option and its actual benefit/cost outcomes. -/ +abbrev BenefitCostWorld := Bool × (Nat × Nat) +def measuredOutcome (world : BenefitCostWorld) (option : Bool) : Nat × Nat := + if option then world.2 else (0,0) +def benefitReason (world : BenefitCostWorld) (option : Bool) : Prop := + (measuredOutcome world option).1 = 4 +def costReason (world : BenefitCostWorld) (option : Bool) : Prop := + (measuredOutcome world option).2 ≤ 3 +/- Neither recorded benefit nor recorded cost alone establishes the selected option's joint consequence. -/ +def jointReasonPosition : ValuePosition BenefitCostWorld where + Position := Bool + Outcome := Nat × Nat + adopted := true + selected := Prod.fst + outcome := measuredOutcome + objective := fun result => result.2 < result.1 + constraints := fun world option => (measuredOutcome world option).2 ≤ 3 + starting := singleton (fun world => world.1 = true) + reasons := [benefitReason, costReason] + limits := fun _ => True + relevantCriticism := fun world => 3 < world.2.2 + response := fun _ => some "reassess the option when its cost exceeds the budget" +/- These two content constraints jointly establish the consequence in a nonempty adopted world. -/ +theorem jointReasonProcedure : ValueProcedure jointReasonPosition := by + refine ⟨by simp [jointReasonPosition], ?_, ?_, ?_⟩ + · refine ⟨(true,(4,3)), (modelsSingleton _ _).2 rfl, trivial, rfl, ?_⟩ + intro reason hr + change reason ∈ [benefitReason,costReason] at hr + rcases List.mem_cons.mp hr with hr | hr + · subst reason; rfl + · have hr' := List.mem_singleton.mp hr + subst reason + change 3 ≤ 3; exact Nat.le_refl 3 + · intro world _ _ reasons + have benefit := reasons benefitReason (by change benefitReason ∈ [benefitReason,costReason]; simp) + have cost := reasons costReason (by change costReason ∈ [benefitReason,costReason]; simp) + change (measuredOutcome world true).1 = 4 at benefit + change (measuredOutcome world true).2 ≤ 3 at cost + refine ⟨?_, cost⟩ + have bigger : 3 < (measuredOutcome world true).1 := by rw [benefit]; decide + exact Nat.lt_of_le_of_lt cost bigger + · intro world _ _ + exact ⟨"reassess the option when its cost exceeds the budget", rfl, by decide⟩ +/- Each separate reason has a concrete same-start/limit/adoption counterworld; their conjunction is sufficient. -/ +def JointReasonsExample : Prop := + ValueProcedure jointReasonPosition ∧ + (Models jointReasonPosition.starting (true,(4,5)) ∧ jointReasonPosition.limits (true,(4,5)) ∧ + jointReasonPosition.commitment (true,(4,5)) ∧ benefitReason (true,(4,5)) true ∧ + ¬ jointReasonPosition.consequence (true,(4,5))) ∧ + (Models jointReasonPosition.starting (true,(0,3)) ∧ jointReasonPosition.limits (true,(0,3)) ∧ + jointReasonPosition.commitment (true,(0,3)) ∧ costReason (true,(0,3)) true ∧ + ¬ jointReasonPosition.consequence (true,(0,3))) +theorem jointReasonsExample : JointReasonsExample := by + refine ⟨jointReasonProcedure, + ⟨(modelsSingleton _ _).2 rfl, trivial, rfl, rfl, ?_⟩, + ⟨(modelsSingleton _ _).2 rfl, trivial, rfl, Nat.le_refl 3, ?_⟩⟩ + · intro h; have bad : 5 ≤ 3 := h.2; omega + · intro h; have bad : 3 < 0 := h.1; omega +/- Empirical observations, semantic inference and criticism-responsive reasons coexist without a scalar score. -/ +/-- organon-map CoreReader.Evidence.heterogeneousReasons +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem heterogeneousReasons : + FacetDischarged switchEmpirical ∧ + FacetDischarged (Facet.inferential (singleton (fun w : Bool => w = true)) (fun w => w = true)) ∧ + FacetDischarged (Facet.value switchPosition) ∧ JointReasonsExample := by + refine ⟨switchEmpiricalDischarged, ⟨⟨true, (modelsSingleton _ _).2 rfl⟩, ?_⟩, switchValueProcedure, jointReasonsExample⟩ + intro w hw; exact (modelsSingleton (fun x : Bool => x = true) w).1 hw + +/- This local observation checks the actual output on input zero. -/ +def zeroRecord : Record (Nat → Bool) := ⟨fun f => f 0, true⟩ +def localGenerator (seed : Nat) : Nat → Bool := fun n => n == seed +/- All outputs being true is a stronger, explicitly quantified capability claim. -/ +def allTrue : Claim (Nat → Bool) := fun f => ∀ n, f n = true +theorem zeroCompatible (f : Nat → Bool) : Compatible [zeroRecord] f ↔ f 0 = true := by + constructor + · intro h; exact h zeroRecord (by simp) + · intro hf r hr; simp only [List.mem_singleton] at hr; cases hr; exact hf +/- A generating subject owns an earlier predicate and a seed used to revise that actual predicate. -/ +structure GeneratingProcess where + owner : Nat + prior : Nat → Bool + generateSeed : Nat +/- The revision preserves prior successes and adds the seed-selected case through the actual generator. -/ +def GeneratingProcess.outputRevision (process : GeneratingProcess) : Nat → Bool := + fun input => process.prior input || localGenerator process.generateSeed input +/- A produced revision retains its producer and exact old/new objects. -/ +structure ProducedRevision where + producer : Nat + before : Nat → Bool + after : Nat → Bool +/- The subject itself constructs the owned before/after revision object. -/ +def GeneratingProcess.produce (process : GeneratingProcess) : ProducedRevision := + ⟨process.owner, process.prior, process.outputRevision⟩ +def sampleGeneratingProcess : GeneratingProcess := ⟨17, fun _ => false, 0⟩ +/- This same-owner revision actually changes input zero, while its produced predicate still fails at input one. -/ +def OwnedRevisionExample : Prop := + sampleGeneratingProcess.produce.producer = sampleGeneratingProcess.owner ∧ + sampleGeneratingProcess.produce.before = sampleGeneratingProcess.prior ∧ + sampleGeneratingProcess.produce.after = sampleGeneratingProcess.outputRevision ∧ + sampleGeneratingProcess.produce.before 0 = false ∧ sampleGeneratingProcess.produce.after 0 = true ∧ + sampleGeneratingProcess.produce.after 1 = false ∧ + Compatible [zeroRecord] sampleGeneratingProcess.produce.after ∧ + ¬ Supports [zeroRecord] allTrue +/- Actual producer/old/new links and the compatible failing revision witness the insufficiency of self-origin. -/ +theorem ownedRevisionExample : OwnedRevisionExample := by + refine ⟨rfl,rfl,rfl,rfl,rfl,rfl,(zeroCompatible _).2 rfl, ?_⟩ + intro h + have bad := h sampleGeneratingProcess.produce.after ((zeroCompatible _).2 rfl) 1 + cases bad +/- The generator's own sample succeeds, but its generated revision has a concrete unsupported global claim. -/ +/-- organon-map CoreReader.Evidence.selfOriginDoesNotSupport +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +theorem selfOriginDoesNotSupport : + localGenerator 0 0 = true ∧ localGenerator 0 1 = false ∧ + Compatible [zeroRecord] (localGenerator 0) ∧ + ¬ Supports [zeroRecord] allTrue ∧ OwnedRevisionExample := by + refine ⟨rfl, rfl, (zeroCompatible _).2 rfl, ?_, ownedRevisionExample⟩ + intro h + have bad := h (localGenerator 0) ((zeroCompatible _).2 rfl) 1 + cases bad +/- A proper local observation allows both a universally successful and a failing extension. -/ +/-- organon-map CoreReader.Evidence.localNotUniversal +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem localNotUniversal : + (∃ outside : Nat, outside ≠ 0) ∧ + Compatible [zeroRecord] (fun _ => true) ∧ + Compatible [zeroRecord] (localGenerator 0) ∧ + allTrue (fun _ => true) ∧ ¬ allTrue (localGenerator 0) ∧ + ¬ Supports [zeroRecord] allTrue := by + refine ⟨⟨1, by decide⟩, (zeroCompatible _).2 rfl, (zeroCompatible _).2 rfl, + (fun _ => rfl), ?_, selfOriginDoesNotSupport.2.2.2.1⟩ + intro h; have bad := h 1; cases bad +/- Two implementations agree on the actual observed input and differ on a specified relevant omitted input. -/ +/-- organon-map CoreReader.Evidence.hiddenDifference +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem hiddenDifference : + (∀ n : Nat, n = 0 → (fun _ : Nat => true) n = localGenerator 0 n) ∧ + (fun _ : Nat => true) 1 ≠ localGenerator 0 1 := by + refine ⟨?_, by decide⟩ + intro n hn; cases hn; rfl +/- One observation supplies only its actual input-specific consequence, without repetition. -/ +/-- organon-map CoreReader.Evidence.singleObservation +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem singleObservation : [zeroRecord].length = 1 ∧ + (∃ f, Compatible [zeroRecord] f) ∧ + Supports [zeroRecord] (fun f => f 0 = true) ∧ + ¬ Supports [zeroRecord] allTrue := + ⟨rfl, ⟨localGenerator 0, (zeroCompatible _).2 rfl⟩, + (fun f hf => (zeroCompatible f).1 hf), selfOriginDoesNotSupport.2.2.2.1⟩ +/- This inferential assessment derives a successor value from its explicit numeric premise without observation. -/ +def arithmeticFacet : Facet Nat := .inferential (singleton (fun n => n = 2)) (fun n => n + 1 = 3) +def usesObservation {W : Type} : Facet W → Bool + | .empirical _ _ _ _ => true + | _ => false +/- An actual valid inferential assessment refutes a mandatory measurement/repetition/framework chain. -/ +/-- organon-map CoreReader.Evidence.noUniversalChain +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem noUniversalChain : FacetDischarged arithmeticFacet ∧ usesObservation arithmeticFacet = false := by + refine ⟨⟨⟨2, (modelsSingleton _ _).2 rfl⟩, ?_⟩, rfl⟩ + intro n hn + have premise := (modelsSingleton (fun x : Nat => x = 2) n).1 hn + change n + 1 = 3 + rw [premise] +/- A trial has a reproducible setting, an actual outcome and a separately recorded outcome. -/ +structure Trial where + setting : Nat + actualOutcome : Nat + recordedOutcome : Nat +/- Verifying a record, reproducing settings and retaining a conclusion are separate predicates. -/ +def Verified (t : Trial) : Prop := t.recordedOutcome = t.actualOutcome +def Reproduced (a b : Trial) : Prop := a.setting = b.setting +def Bounded (t : Trial) : Prop := t.actualOutcome ≤ 2 +/- Same-setting possible trials can differ while preserving the chosen bound; no probability semantics is claimed. -/ +/-- organon-map CoreReader.Evidence.variableOutcomesStableBound +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem variableOutcomesStableBound : + let a : Trial := ⟨0,1,1⟩ + let b : Trial := ⟨0,2,2⟩ + Reproduced a b ∧ a.actualOutcome ≠ b.actualOutcome ∧ Bounded a ∧ Bounded b := by + simp [Reproduced, Bounded] +/- Concrete records distinguish record accuracy, condition reproduction and conclusion stability. -/ +/-- organon-map CoreReader.Evidence.verificationReproductionStability +organon.grounds.scope#p1 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p2 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +organon.grounds.scope#p3 sha256 4a0e93c7834e4ef62f129ee4621cf7bf1c93b64d86f9f145d1592adcf9fb6693 +-/ +theorem verificationReproductionStability : + (Verified ⟨0,1,1⟩ ∧ Verified ⟨1,1,1⟩ ∧ ¬ Reproduced ⟨0,1,1⟩ ⟨1,1,1⟩) ∧ + (Reproduced ⟨0,1,1⟩ ⟨0,3,2⟩ ∧ ¬ Verified ⟨0,3,2⟩ ∧ ¬ Bounded ⟨0,3,2⟩) ∧ + (Bounded ⟨0,1,1⟩ ∧ Bounded ⟨0,2,0⟩ ∧ ¬ Verified ⟨0,2,0⟩) := by + simp [Verified, Reproduced, Bounded] +/- Explanation certificates are executable syntax for this same arithmetic process. -/ +inductive Program where + | doubleInput + | constant (value : Nat) +def Program.eval : Program → Nat → Nat + | .doubleInput, n => n + n + | .constant value, _ => value +/- A process exposes outputs and an explanation response, whose certificate can be checked against those outputs. -/ +structure Process where + output : Nat → Nat + explanation : Option Program +/- The output-only application contract checks every relevant input. -/ +def OutputContract (p : Process) : Prop := ∀ n, p.output n = n + n +/- The explanation application contract requires a provided certificate faithful to this very process. -/ +def ExplanationContract (p : Process) : Prop := + ∃ program, p.explanation = some program ∧ ∀ n, program.eval n = p.output n +/- This process produces doubled values but returns no explanatory certificate. -/ +def outputOnlyProcess : Process := ⟨fun n => n + n, none⟩ +def explainedProcess : Process := ⟨fun n => n + n, some .doubleInput⟩ +/- Object scope fixes the very process whose contract is assessed; contract inputs themselves still range over all naturals. -/ +def processScope (assessed : Process) : Theory Process := + singleton (fun candidate => candidate = assessed) +/- This inferential facet checks an explicit contract under exact process-identity assumptions. -/ +def processContractFacet (assessed : Process) (contract : Claim Process) : Facet Process := + .inferential (processScope assessed) contract +/- The scope's compatible interpretations are exactly this assessed process, not an unrelated substitute. -/ +theorem processScopeModels (assessed candidate : Process) : + Models (processScope assessed) candidate ↔ candidate = assessed := + modelsSingleton (fun process => process = assessed) candidate +/- A concrete contract proof supplies the facet's consequence for its scoped object. -/ +theorem processContractDischarged (assessed : Process) (contract : Claim Process) (proof : contract assessed) : + FacetDischarged (processContractFacet assessed contract) := by + refine ⟨⟨assessed,(processScopeModels _ _).2 rfl⟩, ?_⟩ + intro candidate hc + have same := (processScopeModels _ _).1 hc + subst candidate + exact proof +/- Scoped capability grounds include exact claim, object-specific assumptions, canonical articulation and actual assessment. -/ +def ProcessGrounds (assessed : Process) (contract : Claim Process) : Prop := + Grounds contract canonicalArticulation (fun facet => facet = processContractFacet assessed contract) + [processContractFacet assessed contract] +theorem processGrounds (assessed : Process) (contract : Claim Process) (proof : contract assessed) : + ProcessGrounds assessed contract := by + have discharged := processContractDischarged assessed contract proof + refine ⟨by simp, ?_, ?_⟩ + · intro facet hf; subst facet; exact List.mem_singleton.mpr rfl + · intro facet hf; have hf' := List.mem_singleton.mp hf; subst facet + exact ⟨rfl,canonicalArticulated _ discharged,canonicalFacetArticulated _,discharged⟩ +/- Universal output correctness here comes from the concrete program definition, not from an assumed capability label. -/ +theorem outputCorrectByEvaluation : OutputContract outputOnlyProcess := fun _ => rfl +/- This same process actually returns no explanation certificate. -/ +theorem outputOnlyNoExplanation : ¬ ExplanationContract outputOnlyProcess := by + rintro ⟨program,h,_⟩; cases h +/- The full application contract requires outputs and an explanation of that same process. -/ +def FullProcessContract (assessed : Process) : Prop := OutputContract assessed ∧ ExplanationContract assessed +/- Output-only grounds have the assessed process itself as a counterworld to the stronger contract. -/ +def OutputContractEvidence : Prop := + ProcessGrounds outputOnlyProcess OutputContract ∧ + Models (processScope outputOnlyProcess) outputOnlyProcess ∧ + ¬ Entails (processScope outputOnlyProcess) FullProcessContract +/- Existing output evidence does not supply the absent explanation for the same object and scope. -/ +theorem outputContractEvidence : OutputContractEvidence := by + refine ⟨processGrounds _ _ outputCorrectByEvaluation, (processScopeModels _ _).2 rfl, ?_⟩ + intro stronger + exact outputOnlyNoExplanation (stronger outputOnlyProcess ((processScopeModels _ _).2 rfl)).2 +/- Both actual application contracts have grounds and explicit object scopes; neither scope is empty. -/ +def ScopedApplicationEvidence : Prop := + ProcessGrounds outputOnlyProcess OutputContract ∧ + ProcessGrounds explainedProcess FullProcessContract ∧ + (∀ candidate, Models (processScope outputOnlyProcess) candidate ↔ candidate = outputOnlyProcess) ∧ + (∀ candidate, Models (processScope explainedProcess) candidate ↔ candidate = explainedProcess) ∧ + Satisfiable (processScope outputOnlyProcess) ∧ Satisfiable (processScope explainedProcess) +/- Concrete evaluation and a faithful double-input certificate establish the two differently scoped contracts. -/ +theorem scopedApplicationEvidence : ScopedApplicationEvidence := by + refine ⟨processGrounds _ _ outputCorrectByEvaluation, processGrounds _ _ ?_, + processScopeModels _,processScopeModels _,⟨_,(processScopeModels _ _).2 rfl⟩, + ⟨_,(processScopeModels _ _).2 rfl⟩⟩ + exact ⟨fun _ => rfl,⟨.doubleInput,rfl,fun _ => rfl⟩⟩ +/- Universal output correctness does not entail the explanation-requiring contract for the same process. -/ +/-- organon-map CoreReader.Evidence.outputNotExplanation +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem outputNotExplanation : OutputContract outputOnlyProcess ∧ + ¬ ExplanationContract outputOnlyProcess ∧ OutputContractEvidence := + ⟨outputCorrectByEvaluation, outputOnlyNoExplanation, outputContractEvidence⟩ +/- Applications may use distinct contracts, and a faithful certificate can satisfy the stronger one. -/ +/-- organon-map CoreReader.Evidence.applicationContractsDiffer +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem applicationContractsDiffer : + (OutputContract outputOnlyProcess ∧ ¬ (OutputContract outputOnlyProcess ∧ ExplanationContract outputOnlyProcess)) ∧ + (OutputContract explainedProcess ∧ ExplanationContract explainedProcess) ∧ + ScopedApplicationEvidence := + ⟨⟨outputCorrectByEvaluation, fun h => outputOnlyNoExplanation h.2⟩, + ⟨(fun _ => rfl), ⟨.doubleInput, rfl, fun _ => rfl⟩⟩, scopedApplicationEvidence⟩ +/- The assessor supplies a mathematical certificate; the process's own explanation response is unnecessary. -/ +structure ExternalCertificate (p : Process) where + assessorId : Nat + assessedId : Nat + distinctParticipants : assessorId ≠ assessedId + outputCorrect : ∀ n, p.output n = n + n +/- The external assessor 42 evaluates the specified process 7; the full output proof is constructed by evaluation. -/ +def externalOutputCertificate : ExternalCertificate outputOnlyProcess := + ⟨42,7,by decide,fun _ => rfl⟩ +/- An external certificate establishes the output contract without producing an internal explanation. -/ +/-- organon-map CoreReader.Evidence.externalAssessment +organon.grounds.capabilities#p1 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +organon.grounds.capabilities#p2 sha256 7249f6f2ef327baaa72349cae53b9245f23a34436356dd05f3c6005cab35e8f0 +-/ +theorem externalAssessment : + (∃ certificate : ExternalCertificate outputOnlyProcess, + certificate.assessorId = 42 ∧ certificate.assessedId = 7 ∧ + certificate.assessorId ≠ certificate.assessedId ∧ OutputContract outputOnlyProcess) ∧ + ProcessGrounds outputOnlyProcess OutputContract ∧ + ¬ ExplanationContract outputOnlyProcess := + ⟨⟨externalOutputCertificate,rfl,rfl,externalOutputCertificate.distinctParticipants, + externalOutputCertificate.outputCorrect⟩, + processGrounds outputOnlyProcess OutputContract externalOutputCertificate.outputCorrect, + outputOnlyNoExplanation⟩ +/- This argument records concepts and actual premises for a semantic inference, separately from executable tests. -/ +def arithmeticArticulation : Articulation Nat := canonicalArticulation arithmeticFacet +/- A reasoned inferential assessment needs no observation method, while applicable empirical assessment retains observations. -/ +/-- organon-map CoreReader.Evidence.nonExecutableAssessment +organon.relationships.terms#p1 sha256 0d22f818e4466a5ab4272607ac0ab26997270cf05c64ce9ac547e866068907d1 +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem nonExecutableAssessment : + Grounds (fun n : Nat => n + 1 = 3) canonicalArticulation (fun f => f = arithmeticFacet) [arithmeticFacet] ∧ + usesObservation arithmeticFacet = false ∧ + FacetDischarged switchEmpirical ∧ usesObservation switchEmpirical = true := by + refine ⟨⟨by simp, (by intro f hf; cases hf; simp), ?_⟩, rfl, switchEmpiricalDischarged, rfl⟩ + intro f hf; simp only [List.mem_singleton] at hf; cases hf + exact ⟨rfl, canonicalArticulated _ noUniversalChain.1, canonicalFacetArticulated _, noUniversalChain.1⟩ + +end CoreReader.Evidence diff --git a/lean/philosophy/leanified/CoreReader/Integration.lean b/lean/philosophy/leanified/CoreReader/Integration.lean new file mode 100644 index 0000000..24ceca7 --- /dev/null +++ b/lean/philosophy/leanified/CoreReader/Integration.lean @@ -0,0 +1,607 @@ +import CoreReader.Agency +import CoreReader.Choice + +namespace CoreReader.Integration +open CoreReader.Logic CoreReader.Evidence CoreReader.Agency CoreReader.Choice + +/- Canonical articulation preserves the actual assessment contents of each facet. -/ +theorem canonicalGrounds {W : Type} (claim : Claim W) (facets : List (Facet W)) + (hne : facets ≠ []) (checked : ∀ f ∈ facets, f.claim = claim ∧ FacetDischarged f) : + Grounds claim canonicalArticulation (fun f => f ∈ facets) facets := by + exact ⟨hne, fun _ h => h, fun f hf => + ⟨(checked f hf).1, canonicalArticulated f (checked f hf).2, + canonicalFacetArticulated f, (checked f hf).2⟩⟩ + +theorem canonicalGroundsForSingleton {W : Type} (f : Facet W) (checked : FacetDischarged f) : + Grounds f.claim canonicalArticulation (fun g => g = f) [f] := by + refine ⟨by simp, (by intro g hg; cases hg; simp), ?_⟩ + intro g hg + simp only [List.mem_singleton] at hg + subst g + exact ⟨rfl, canonicalArticulated f checked, canonicalFacetArticulated f, checked⟩ + +/- A mode selects whether a system applies or waives the modeled governance rule. -/ +inductive Mode | apply | waive + deriving DecidableEq, Repr + +/- The four hypotheses vary algorithm and governance independently for the same assessed system. -/ +abbrev World := Candidate × Mode + +def actual : World := (.identity, .apply) + +/- A method's form and its possible executable realizations belong to one object. -/ +structure Method where + form : Form + realize : World → Implementation + +/- System fields identify the owner, its method, its current principle form, policy and work. -/ +structure System where + owner : Nat + method : Method + principleForm : Form + governance : World → Mode + requirements : Requirements + +def policyFor : Mode → Policy + | .apply => openPolicy + | .waive => neutralPolicy + +def workFor (owner : Nat) : Mode → List WorkRecord + | .apply => completeOwnWork owner + | .waive => [] + +def System.policy (s : System) (w : World) : Policy := policyFor (s.governance w) +def System.rules (s : System) (_w : World) : List Principle := ownRules s.owner +def System.work (s : System) (w : World) : List WorkRecord := workFor s.owner (s.governance w) + +def actualSystem : System where + owner := 0 + method := ⟨⟨.method, 0⟩, fun w => implementation w.1⟩ + principleForm := ⟨.principle, 0⟩ + governance := Prod.snd + requirements := identityRequirements + +def systemCapability (s : System) : Claim World := + fun w => ∀ n, s.requirements.inputs n → (s.method.realize w).run n = s.requirements.expected n + +def systemBudget (s : System) : Claim World := + fun w => (s.method.realize w).cost ≤ s.requirements.budget + +def systemObservation (s : System) : Record World := + ⟨fun w => decide ((s.method.realize w).run 0 = s.requirements.expected 0), true⟩ + +def systemHeld (s : System) : Theory World := + union (singleton (systemCapability s)) (singleton (systemBudget s)) + +inductive Question | correctOutput | affordable + deriving DecidableEq, Repr + +def systemContext (s : System) : Context World Question := + ⟨singleton (Compatible [systemObservation s]), + (fun q => match q with | .correctOutput => systemCapability s | .affordable => systemBudget s), + fun w => (s.method.realize w).domain 0 ∧ w.2 = .apply⟩ + +abbrev capability := systemCapability actualSystem +abbrev observation := systemObservation actualSystem +abbrev held := systemHeld actualSystem +abbrev context := systemContext actualSystem + +/- The output observation identifies the algorithm, without identifying its independently varied governance mode. -/ +theorem observationIdentifies (w : World) : Compatible [observation] w ↔ w.1 = .identity := by + rcases w with ⟨candidate, mode⟩ + cases candidate <;> simp [Compatible, observation, systemObservation, actualSystem, + implementation, identityRequirements, identityImpl, successorImpl] + +theorem capabilityActual : capability actual := fun _ _ => rfl + +theorem observedCapability : Supports [observation] capability := by + intro w hw + have hid := (observationIdentifies w).1 hw + rcases w with ⟨candidate, mode⟩ + change candidate = .identity at hid + subst candidate + exact fun _ _ => rfl + +def capabilityFacet : Facet World := .empirical [observation] (fun _ => True) capability (fun _ => True) + +theorem capabilityFacetChecked : FacetDischarged capabilityFacet := by + exact ⟨⟨actual, (observationIdentifies actual).2 rfl, trivial⟩, + (fun w hw _ => observedCapability w hw), fun _ _ => trivial⟩ + +theorem capabilityGrounds : Grounds capability canonicalArticulation + (fun f => f = capabilityFacet) [capabilityFacet] := + canonicalGroundsForSingleton capabilityFacet capabilityFacetChecked + +theorem actualAdmissible : Admissible held context actual := by + refine ⟨(modelsUnion _ _ _).2 ⟨(modelsSingleton _ _).2 capabilityActual, + (modelsSingleton _ _).2 (by change 1 ≤ 1; decide)⟩, + (modelsSingleton _ _).2 ((observationIdentifies actual).2 rfl), trivial, rfl⟩ + +theorem jointConsistent : Consistent held context := + consequenceConsistency held context ⟨actual, actualAdmissible⟩ + +/- The current method/principle forms, judgments, rules and own work are read from this very system and world. -/ +def Charter (s : System) (w : World) : Prop := + Generative (s.policy w) ∧ Consistent (systemHeld s) (systemContext s) ∧ + Reflexive s.owner (s.rules w) (s.work w) ∧ + (s.policy w).current s.method.form ∧ (s.policy w).current s.principleForm + +theorem charterChecked : Charter actualSystem actual := + ⟨⟨Or.inl rfl, fun _ _ => trivial⟩, jointConsistent, completeOwnWork_reflexive 0, rfl, rfl⟩ + +/- Revision adds a supported input-specific assertion about the same system's realized method. -/ +def revisedHeld : Theory World := union held + (singleton (fun w => (actualSystem.method.realize w).run 0 = actualSystem.requirements.expected 0)) + +def initialSnapshot : Snapshot World Question := ⟨held, context, 0⟩ +def revisedSnapshot : Snapshot World Question := ⟨revisedHeld, context, 1⟩ + +/-- organon-map CoreReader.Integration.revisionKeepsConsistency +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem revisionKeepsConsistency : + Charter actualSystem actual ∧ Consistent revisedHeld context ∧ + TruthfulReport initialSnapshot revisedSnapshot true ∧ + ¬ TruthfulReport initialSnapshot revisedSnapshot false := by + refine ⟨charterChecked, consequenceConsistency revisedHeld context ⟨actual, + (modelsUnion _ _ _).2 ⟨actualAdmissible.1, (modelsSingleton _ _).2 rfl⟩, + actualAdmissible.2⟩, (fun _ => rfl), ?_⟩ + intro h + have bad := h (Or.inr (by decide)) + cases bad + +/- A claim about this system's method is assessed as its owner's system claim. -/ +def OwnCapabilityDuty (s : System) (w : World) (facets : List (Facet World)) : Prop := + Performed (s.work w) (.system s.owner) .assessment ∧ + Grounds (systemCapability s) canonicalArticulation (fun f => f ∈ facets) facets + +/-- organon-map CoreReader.Integration.ownCapabilityGrounded +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem ownCapabilityGrounded : + OwnCapabilityDuty actualSystem actual [capabilityFacet] ∧ capability actual := by + refine ⟨⟨?_, ?_⟩, capabilityActual⟩ + · exact ownAssessmentPerformed 0 (.system 0) (by simp [ownSubjects]) + · exact canonicalGrounds capability [capabilityFacet] (by simp) + (by intro f hf; simp only [List.mem_singleton] at hf; cases hf; exact ⟨rfl, capabilityFacetChecked⟩) + +/- This cost observation is true of both algorithms but does not discriminate their output behavior. -/ +def costAllowanceRecord : Record World := + ⟨fun w => decide ((actualSystem.method.realize w).cost ≤ 2), true⟩ + +def unsupportedCapabilityFacet : Facet World := + .empirical [costAllowanceRecord] (fun _ => True) capability (fun _ => True) + +theorem costCompatibleWithFailure : Compatible [costAllowanceRecord] (.successor, .apply) := by + intro r hr + simp only [List.mem_singleton] at hr + subst r + rfl + +theorem costDoesNotSupportOutput : ¬ Supports [costAllowanceRecord] capability := by + intro h + have bad := h (.successor, .apply) costCompatibleWithFailure 0 trivial + cases bad + +theorem unsupportedGrounds : ¬ Grounds capability canonicalArticulation + (fun f => f = unsupportedCapabilityFacet) [unsupportedCapabilityFacet] := by + intro h + have discharged := (h.2.2 unsupportedCapabilityFacet (by simp)).2.2.2 + exact costDoesNotSupportOutput (fun w hw => discharged.2.1 w hw trivial) + +/- Five separately adopted requirements govern distinct operations; the mode does not give them priority over one another. -/ +inductive Commitment | generation | consistency | reflexivity | grounds | choice + deriving DecidableEq, Repr + +/- A Grounds policy governs arbitrary claims, articulations and applicable facets, rather than only one capability claim. -/ +def groundsPermission (mode : Mode) (claim : Claim World) (a : Facet World → Articulation World) + (applicable : Facet World → Prop) (facets : List (Facet World)) : Prop := + match mode with + | .apply => Grounds claim a applicable facets + | .waive => True + +def GroundsProvision (mode : Mode) : Prop := + ∀ claim a applicable facets, groundsPermission mode claim a applicable facets → + Grounds claim a applicable facets + +theorem groundsProvisionMeaning (mode : Mode) : GroundsProvision mode ↔ mode = .apply := by + cases mode with + | apply => exact ⟨fun _ => rfl, fun _ _ _ _ _ h => h⟩ + | waive => + constructor + · intro h + exact False.elim (unsupportedGrounds (h capability canonicalArticulation + (fun f => f = unsupportedCapabilityFacet) [unsupportedCapabilityFacet] trivial)) + · intro h; cases h + +/- The consistency policy checks a whole same-context theory, not isolated judgments. -/ +def consistencyPermission (mode : Mode) (t : Theory World) (c : Context World Question) : Prop := + match mode with | .apply => Consistent t c | .waive => True + +def conflictingHeld : Theory World := union (singleton capability) (singleton (fun w => ¬ capability w)) + +theorem conflictConsequences : + Consequence conflictingHeld context .correctOutput true ∧ + Consequence conflictingHeld context .correctOutput false := by + exact ⟨fun w hw => hw.1 capability (Or.inl rfl), + fun w hw => hw.1 (fun w => ¬ capability w) (Or.inr rfl)⟩ + +theorem conflictingHeldInconsistent : ¬ Consistent conflictingHeld context := + conflictRequiresChange conflictingHeld context .correctOutput conflictConsequences.1 conflictConsequences.2 + +/- The selection policy applies the actual output/budget and relevant-reason conditions to every implementation. -/ +def choicePermission (mode : Mode) (req : Requirements) (i : Implementation) (reasons : List Reason) : Prop := + match mode with | .apply => JustifiedChoice req i reasons | .waive => True + +/- The following consequences are computed from distinct rule applications; they are not interchangeable support flags. -/ +def proposedOperation : Mode → Operation + | .apply => .successor + | .waive => .copy + +def selfSamples : Mode → List Nat + | .apply => [0, 1] + | .waive => [1] + +noncomputable def conflictDecision (mode : Mode) : Bool := + @decide (consistencyPermission mode conflictingHeld context) (Classical.propDecidable _) + +noncomputable def groundsDecision (mode : Mode) (facet : Facet World) : Bool := + @decide (groundsPermission mode facet.claim canonicalArticulation (fun f => f = facet) [facet]) + (Classical.propDecidable _) + +noncomputable def choiceDecision (mode : Mode) (i : Implementation) (reasons : List Reason) : Bool := + @decide (choicePermission mode identityRequirements i reasons) (Classical.propDecidable _) + +theorem decisionsApply : conflictDecision .apply = false ∧ + groundsDecision .apply unsupportedCapabilityFacet = false ∧ + groundsDecision .apply capabilityFacet = true ∧ + choiceDecision .apply cheapSuccessor [.method .simplicity] = false ∧ + choiceDecision .apply identityImpl objectiveReason = true := by + classical + simp only [conflictDecision, groundsDecision, choiceDecision, consistencyPermission, + groundsPermission, choicePermission] + exact ⟨decide_eq_false conflictingHeldInconsistent, + decide_eq_false unsupportedGrounds, decide_eq_true capabilityGrounds, + decide_eq_false eligibleInternalReasonNotSufficient.2, decide_eq_true identityJustified⟩ + +theorem decisionsWaive : conflictDecision .waive = true ∧ + groundsDecision .waive unsupportedCapabilityFacet = true ∧ + choiceDecision .waive cheapSuccessor [.method .simplicity] = true := by + exact ⟨@decide_eq_true (consistencyPermission .waive conflictingHeld context) + (Classical.propDecidable _) trivial, + @decide_eq_true (groundsPermission .waive unsupportedCapabilityFacet.claim canonicalArticulation + (fun f => f = unsupportedCapabilityFacet) [unsupportedCapabilityFacet]) (Classical.propDecidable _) trivial, + @decide_eq_true (choicePermission .waive identityRequirements cheapSuccessor [.method .simplicity]) + (Classical.propDecidable _) trivial⟩ + +/- Each application supplies its own outcome type, adopted objective, constraints and actual option-indexed reasons. -/ +noncomputable def commitmentPositionFor (c : Commitment) (chosenMode : Mode) : ValuePosition World := + match c with + | .generation => { + Position := Mode, Outcome := Operation, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => proposedOperation mode, + objective := fun op => op.run 0 ≠ Operation.copy.run 0, + constraints := fun _ mode => Generative (policyFor mode), + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ mode => (proposedOperation mode).run 0 = 1 ∧ Operation.copy.run 0 = 0], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => ¬ Expanded baseState inflatedState, + response := fun _ => some "Pursuing expansion does not guarantee it; assess the actual before and after capabilities separately" } + | .consistency => { + Position := Mode, Outcome := Bool, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => conflictDecision mode, + objective := fun accepted => accepted = false, + constraints := fun _ mode => consistencyPermission mode held context, + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ _ => Consequence conflictingHeld context .correctOutput true ∧ + Consequence conflictingHeld context .correctOutput false], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => ¬ Entails (emptyTheory : Theory Bool) (fun w => w = true), + response := fun _ => some "Consistency alone does not establish sufficient support; assess the claim with its grounds as well" } + | .reflexivity => { + Position := Mode, Outcome := List Nat, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => selfSamples mode, + objective := fun samples => ∃ n ∈ samples, ownArithmeticPrinciple n = false, + constraints := fun _ mode => Reflexive 0 (ownRules 0) (workFor 0 mode), + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ _ => ownArithmeticPrinciple 0 = false ∧ ownArithmeticPrinciple 1 = true], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => selfTest [1] = true ∧ ownArithmeticPrinciple 0 = false, + response := fun _ => some "A passing self-test does not certify the principle; retain the relevant counterexample and its scope" } + | .grounds => { + Position := Mode, Outcome := Bool, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => groundsDecision mode unsupportedCapabilityFacet, + objective := fun accepted => accepted = false, + constraints := fun _ mode => groundsPermission mode capability canonicalArticulation + (fun f => f = capabilityFacet) [capabilityFacet], + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ _ => Compatible [costAllowanceRecord] (.successor, .apply) ∧ + ¬ capability (.successor, .apply)], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => OutputContract outputOnlyProcess ∧ ¬ ExplanationContract outputOnlyProcess, + response := fun _ => some "Grounds allows an external output assessment without requiring this process to provide an internal explanation" } + | .choice => { + Position := Mode, Outcome := Bool, adopted := chosenMode, selected := actualSystem.governance, + outcome := fun _ mode => choiceDecision mode cheapSuccessor [.method .simplicity], + objective := fun accepted => accepted = false, + constraints := fun _ mode => choicePermission mode identityRequirements identityImpl objectiveReason, + starting := singleton (fun w => actualSystem.governance w = chosenMode), + reasons := [fun _ _ => cheapSuccessor.run 0 = 1 ∧ identityRequirements.expected 0 = 0 ∧ + cheapSuccessor.cost ≤ identityRequirements.budget], + limits := fun w => w.1 = .identity, + relevantCriticism := fun _ => identityImpl.conventional = true ∧ identityImpl.established = true, + response := fun _ => some "An existing conventional method remains eligible when actual output and budget reasons justify it" } + +noncomputable def commitmentPosition (c : Commitment) : ValuePosition World := commitmentPositionFor c .apply + +/- The fact used as a reason has content before evaluating the adopted rule's consequence. -/ +theorem positionReasons (c : Commitment) : + ∀ r ∈ (commitmentPosition c).reasons, r actual (commitmentPosition c).adopted := by + cases c <;> intro r hr <;> dsimp [commitmentPosition, commitmentPositionFor] at hr ⊢ <;> + rcases List.mem_singleton.mp hr with rfl + · exact ⟨rfl, rfl⟩ + · exact conflictConsequences + · exact ⟨rfl, rfl⟩ + · refine ⟨costCompatibleWithFailure, ?_⟩ + intro h + have bad := h 0 trivial + cases bad + · exact ⟨rfl, rfl, by decide⟩ + +/- Each adopted rule has its stated consequence in this explicitly defined application; this is not ultimate value justification. -/ +theorem positionConsequence (c : Commitment) (w : World) : (commitmentPosition c).consequence w := by + cases c <;> dsimp [commitmentPosition, commitmentPositionFor, ValuePosition.consequence] + · exact ⟨by decide, ⟨Or.inl rfl, fun _ _ => trivial⟩⟩ + · exact ⟨decisionsApply.1, jointConsistent⟩ + · exact ⟨⟨0, by simp [selfSamples], rfl⟩, completeOwnWork_reflexive 0⟩ + · exact ⟨decisionsApply.2.1, capabilityGrounds⟩ + · exact ⟨decisionsApply.2.2.2.1, identityJustified⟩ + +theorem positionProcedure (c : Commitment) : ValueProcedure (commitmentPosition c) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · cases c <;> simp [commitmentPosition, commitmentPositionFor] + · refine ⟨actual, ?_, ?_, ?_, positionReasons c⟩ + · cases c <;> exact (modelsSingleton _ _).2 rfl + · cases c <;> rfl + · cases c <;> rfl + · intro w _ _ _ + exact positionConsequence c w + · intro w _ _ + cases c <;> exact ⟨_, rfl, by decide⟩ + +/- Criticism is instantiated within the adopted position's actual limit rather than made vacuous. -/ +theorem criticismWithinScope (c : Commitment) : + (commitmentPosition c).limits actual ∧ (commitmentPosition c).relevantCriticism actual := by + constructor + · cases c <;> rfl + · cases c + · simp [commitmentPosition, commitmentPositionFor, Expanded, baseState, inflatedState] + · exact consistentIncomplete.2.1 + · exact ⟨rfl, rfl⟩ + · exact ⟨outputNotExplanation.1, outputNotExplanation.2.1⟩ + · exact ⟨rfl, rfl⟩ + +/- Waiving the rule changes the actual computed outcome or an explicit adopted constraint; old reasons cannot certify it unchanged. -/ +theorem oppositeConsequenceFails (c : Commitment) (w : World) : + ¬ (commitmentPositionFor c .waive).consequence w := by + cases c <;> intro h + · exact permissionNotValuation.2.2 h.2 + · have bad : conflictDecision .waive = false := h.1 + rw [decisionsWaive.1] at bad + cases bad + · obtain ⟨n, hn, hf⟩ := h.1 + change n ∈ [1] at hn + have he : n = 1 := List.mem_singleton.mp hn + subst n + cases hf + · have bad : groundsDecision .waive unsupportedCapabilityFacet = false := h.1 + rw [decisionsWaive.2.1] at bad + cases bad + · have bad : choiceDecision .waive cheapSuccessor [.method .simplicity] = false := h.1 + rw [decisionsWaive.2.2] at bad + cases bad + +theorem oppositeProcedureRejected (c : Commitment) : ¬ ValueProcedure (commitmentPositionFor c .waive) := by + intro h + obtain ⟨w, hs, hl, _, hr⟩ := h.2.1 + exact oppositeConsequenceFails c w (h.2.2.1 w hs hl hr) + +/- Each statement names adoption of a particular rule; its defined policy gives that option its meaning. -/ +noncomputable def commitmentClaim (c : Commitment) : Claim World := (commitmentPosition c).commitment + +noncomputable def commitmentFacet (c : Commitment) : Facet World := .value (commitmentPosition c) + +/-- organon-map CoreReader.Integration.reasonsBelongToCommitments +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem reasonsBelongToCommitments (c : Commitment) : + Grounds (commitmentClaim c) canonicalArticulation + (fun f => f = commitmentFacet c) [commitmentFacet c] ∧ + JointAdoption (commitmentPosition c) ∧ + (commitmentPosition c).relevantCriticism actual ∧ + ¬ ValueProcedure (commitmentPositionFor c .waive) := by + exact ⟨canonicalGroundsForSingleton (commitmentFacet c) (positionProcedure c), + (positionProcedure c).2.1, (criticismWithinScope c).2, oppositeProcedureRejected c⟩ + +/- This claim concerns the Grounds rule for arbitrary claim/facet packages, not a single capability duty. -/ +theorem groundsCommitmentIsProvision : commitmentClaim .grounds = (fun w => GroundsProvision w.2) := by + funext w + apply propext + exact (groundsProvisionMeaning w.2).symm + +/-- organon-map CoreReader.Integration.groundsSelfAssessment +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem groundsSelfAssessment : + Grounds (fun w => GroundsProvision w.2) canonicalArticulation + (fun f => f = commitmentFacet .grounds) [commitmentFacet .grounds] ∧ + (commitmentPosition .grounds).limits actual ∧ + (commitmentPosition .grounds).relevantCriticism actual ∧ + ¬ ValueProcedure (commitmentPositionFor .grounds .waive) := by + rw [← groundsCommitmentIsProvision] + exact ⟨(reasonsBelongToCommitments .grounds).1, + (criticismWithinScope .grounds).1, (criticismWithinScope .grounds).2, + oppositeProcedureRejected .grounds⟩ + +/- This existing principle form implements the same system's choice rule on two actual proposals. +Input 0 names the identity proposal; input 1 names the cheap successor proposal. -/ +structure PhilosophyMethod where + form : Form + mode : Mode + +def currentPhilosophy (s : System) (w : World) : PhilosophyMethod := + ⟨s.principleForm, s.governance w⟩ + +noncomputable def PhilosophyMethod.review (p : PhilosophyMethod) (input : Nat) : Nat := + if input = 0 then + if choiceDecision p.mode identityImpl objectiveReason then 1 else 0 + else if choiceDecision p.mode cheapSuccessor [.method .simplicity] then 1 else 0 + +noncomputable def PhilosophyMethod.implementation (p : PhilosophyMethod) : Implementation where + name := "Current philosophy's proposal review" + conventional := true + established := true + run := p.review + cost := 1 + domain n := n = 0 ∨ n = 1 + explanation := p.review + trace n := [n, p.review n] + +def proposalRequirements : Requirements where + inputs n := n = 0 ∨ n = 1 + expected n := if n = 0 then 1 else 0 + budget := 1 + values _ := True + +theorem currentReviewCorrect : ∀ n, proposalRequirements.inputs n → + (currentPhilosophy actualSystem actual).review n = proposalRequirements.expected n := by + intro n hn + rcases hn with rfl | rfl <;> + simp [PhilosophyMethod.review, currentPhilosophy, actualSystem, actual, + proposalRequirements, decisionsApply.2.2.2.1, decisionsApply.2.2.2.2] + +/- Status alone fails for this actual principle method; its demonstrated proposal decisions give a relevant reason. -/ +/-- organon-map CoreReader.Integration.existingPhilosophyNotPrivileged +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem existingPhilosophyNotPrivileged : + (currentPhilosophy actualSystem actual).form = actualSystem.principleForm ∧ + (currentPhilosophy actualSystem actual).mode = actualSystem.governance actual ∧ + ¬ JustifiedChoice proposalRequirements + (currentPhilosophy actualSystem actual).implementation [.status .standing] ∧ + JustifiedChoice proposalRequirements + (currentPhilosophy actualSystem actual).implementation [.method .output] ∧ + (currentPhilosophy actualSystem actual).review 0 = 1 ∧ + (currentPhilosophy actualSystem actual).review 1 = 0 := by + refine ⟨rfl, rfl, statusOnlyFails _ _ _, ?_, currentReviewCorrect 0 (Or.inl rfl), + currentReviewCorrect 1 (Or.inr rfl)⟩ + exact ⟨⟨currentReviewCorrect, by change 1 ≤ 1; decide⟩, + .method .output, by simp, trivial, currentReviewCorrect⟩ + +/- Applications choose their contract and requirements; the resulting claim is about this system's actual method. -/ +def applicationClaim (s : System) (req : Requirements) + (contract : Requirements → Implementation → Prop) : Claim World := + fun w => contract req (s.method.realize w) + +def ApplicationDuties (s : System) (w : World) (req : Requirements) + (contract : Requirements → Implementation → Prop) + (articulations : Facet World → Articulation World) + (applicable : Facet World → Prop) (facets : List (Facet World)) : Prop := + Reflexive s.owner (s.rules w) (s.work w) ∧ + Grounds (applicationClaim s req contract) articulations applicable facets + +/- These are consequences of an explicitly adopted duty, not a proof that arbitrary applications fulfill it. -/ +/-- organon-map CoreReader.Integration.applicationRetainsDuties +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem applicationRetainsDuties (s : System) (w : World) (req : Requirements) + (contract : Requirements → Implementation → Prop) + (articulations : Facet World → Articulation World) + (applicable : Facet World → Prop) (facets : List (Facet World)) + (h : ApplicationDuties s w req contract articulations applicable facets) : + Reflexive s.owner (s.rules w) (s.work w) ∧ + (∀ f, applicable f → f ∈ facets) ∧ + (∀ f ∈ facets, f.claim = applicationClaim s req contract ∧ + Articulated (articulations f) ∧ FacetArticulated (articulations f) f ∧ FacetDischarged f) := + ⟨h.1, h.2.2.1, h.2.2.2⟩ + +def outputContract (req : Requirements) (i : Implementation) : Prop := + ∀ n, req.inputs n → i.run n = req.expected n + +def successorRequirements : Requirements := + { identityRequirements with expected := fun n => n + 1 } + +/- Holding the system and observation fixed while changing the actual objective changes the capability claim. -/ +def changedObjectiveFacet : Facet World := + .empirical [observation] (fun _ => True) + (applicationClaim actualSystem successorRequirements outputContract) (fun _ => True) + +/-- organon-map CoreReader.Integration.applicationVariation +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem applicationVariation : + ApplicationDuties actualSystem actual identityRequirements outputContract + canonicalArticulation (fun f => f = capabilityFacet) [capabilityFacet] ∧ + ¬ applicationClaim actualSystem successorRequirements outputContract actual ∧ + ¬ Grounds (applicationClaim actualSystem successorRequirements outputContract) + canonicalArticulation (fun f => f = changedObjectiveFacet) [changedObjectiveFacet] := by + refine ⟨⟨completeOwnWork_reflexive 0, capabilityGrounds⟩, ?_, ?_⟩ + · intro h + have bad := h 0 trivial + cases bad + · intro h + have discharged := (h.2.2 changedObjectiveFacet (by simp)).2.2.2 + have bad := discharged.2.1 actual ((observationIdentifies actual).2 rfl) trivial 0 trivial + cases bad + +/- The very system satisfies the charter while its true cost evidence fails to establish its output capability. -/ +/-- organon-map CoreReader.Integration.charterNotGrounds +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem charterNotGrounds : + Charter actualSystem actual ∧ + Compatible [costAllowanceRecord] actual ∧ + ¬ Grounds capability canonicalArticulation + (fun f => f = unsupportedCapabilityFacet) [unsupportedCapabilityFacet] := by + exact ⟨charterChecked, (by intro r hr; cases List.mem_singleton.mp hr; rfl), unsupportedGrounds⟩ + +/- A single inhabited system/context carries the charter, its own actual claim and support, +contentful principle work, and separately reasoned governance commitments. -/ +/-- organon-map CoreReader.Integration.jointWitness +organon.preamble#p1 sha256 2ff45595af647eddc9fc095b3f3854f284bf3740ae7af1bacdb98773ffa44097 +organon.preamble#p2 sha256 2ff45595af647eddc9fc095b3f3854f284bf3740ae7af1bacdb98773ffa44097 +organon.charter.overview#p2 sha256 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c +organon.charter.overview#p3 sha256 75d7d941d3c07ea748c4a9261d36a75fbd5664ff9c817c4034a9a36a3a12664c +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem jointWitness : + ∃ s : System, ∃ w : World, + Admissible (systemHeld s) (systemContext s) w ∧ Charter s w ∧ + OwnCapabilityDuty s w [capabilityFacet] ∧ systemCapability s w ∧ + JustifiedChoice s.requirements (s.method.realize w) objectiveReason ∧ + (∀ c : Commitment, Grounds (commitmentClaim c) canonicalArticulation + (fun f => f = commitmentFacet c) [commitmentFacet c]) ∧ + s = actualSystem ∧ w = actual := by + exact ⟨actualSystem, actual, actualAdmissible, charterChecked, + ownCapabilityGrounded.1, capabilityActual, identityJustified, + fun c => (reasonsBelongToCommitments c).1, rfl, rfl⟩ + +end CoreReader.Integration diff --git a/lean/philosophy/leanified/CoreReader/Logic.lean b/lean/philosophy/leanified/CoreReader/Logic.lean new file mode 100644 index 0000000..c7c98b0 --- /dev/null +++ b/lean/philosophy/leanified/CoreReader/Logic.lean @@ -0,0 +1,236 @@ +namespace CoreReader.Logic + +/- A claim denotes the worlds in which its content holds. -/ +abbrev Claim (W : Type) := W → Prop +/- A theory is a collection of simultaneously held claims. -/ +abbrev Theory (W : Type) := Claim W → Prop +/- A model satisfies every member of the whole theory. -/ +def Models {W : Type} (t : Theory W) (w : W) : Prop := ∀ p, t p → p w +/- Semantic entailment quantifies over all models. -/ +def Entails {W : Type} (t : Theory W) (p : Claim W) : Prop := ∀ w, Models t w → p w +/- Satisfiability requires an actual witness. -/ +def Satisfiable {W : Type} (t : Theory W) : Prop := ∃ w, Models t w +/- Assumptions, meanings and scope are distinct components; questions remain explicit. -/ +structure Context (W Q : Type) where + assumptions : Theory W + meaning : Q → Claim W + scope : Claim W +/- Admissible worlds satisfy held claims, assumptions and scope jointly. -/ +def Admissible {W Q : Type} (t : Theory W) (c : Context W Q) (w : W) : Prop := + Models t w ∧ Models c.assumptions w ∧ c.scope w +/- A negative judgment denies the very same question under the same meaning. -/ +def Consequence {W Q : Type} (t : Theory W) (c : Context W Q) (q : Q) (positive : Bool) : Prop := + ∀ w, Admissible t c w → if positive then c.meaning q w else ¬ c.meaning q w +/- The consistency obligation prohibits both consequences at one comparison basis. -/ +def Consistent {W Q : Type} (t : Theory W) (c : Context W Q) : Prop := + ∀ q, ¬ (Consequence t c q true ∧ Consequence t c q false) +/- An inhabited joint interpretation prevents opposite semantic consequences. -/ +/-- organon-map CoreReader.Logic.consequenceConsistency +organon.charter.consistency#p1 sha256 c6960c590c096d33250599cf418e3c6a1dc26bfc7d7800c82b8efde656950f42 +-/ +theorem consequenceConsistency {W Q : Type} (t : Theory W) (c : Context W Q) + (inhabited : ∃ w, Admissible t c w) : Consistent t c := by + intro q h + obtain ⟨w, hw⟩ := inhabited + exact (h.2 w hw) (h.1 w hw) +/- Empty and singleton theories provide concrete semantic contexts. -/ +def emptyTheory {W : Type} : Theory W := fun _ => False +def singleton {W : Type} (p : Claim W) : Theory W := fun q => q = p +def union {W : Type} (a b : Theory W) : Theory W := fun p => a p ∨ b p +theorem modelsSingleton {W : Type} (p : Claim W) (w : W) : Models (singleton p) w ↔ p w := by + constructor + · intro h; exact h p rfl + · intro h q hq; cases hq; exact h +theorem modelsUnion {W : Type} (a b : Theory W) (w : W) : + Models (union a b) w ↔ Models a w ∧ Models b w := by + constructor + · intro h; exact ⟨fun p hp => h p (Or.inl hp), fun p hp => h p (Or.inr hp)⟩ + · rintro ⟨ha,hb⟩ p (hp|hp); exact ha p hp; exact hb p hp +/- The paired world records independent truth values for two questions. -/ +def premiseP : Claim (Bool × Bool) := fun w => w.1 = true +def premiseRule : Claim (Bool × Bool) := fun w => w.1 = true → w.2 = true +def premiseNotQ : Claim (Bool × Bool) := fun w => w.2 ≠ true +def jointTheory : Theory (Bool × Bool) := + union (singleton premiseP) (union (singleton premiseRule) (singleton premiseNotQ)) +/- Each premise has a model, but their joint implication makes the union unsatisfiable. -/ +/-- organon-map CoreReader.Logic.jointConflict +organon.charter.consistency#p1 sha256 c6960c590c096d33250599cf418e3c6a1dc26bfc7d7800c82b8efde656950f42 +-/ +theorem jointConflict : + Satisfiable (singleton premiseP) ∧ Satisfiable (singleton premiseRule) ∧ + Satisfiable (singleton premiseNotQ) ∧ ¬ Satisfiable jointTheory := by + refine ⟨⟨(true,true), (modelsSingleton _ _).2 rfl⟩, + ⟨(false,false), (modelsSingleton _ _).2 (by intro h; cases h)⟩, + ⟨(false,false), (modelsSingleton _ _).2 (by intro h; cases h)⟩, ?_⟩ + rintro ⟨w, hw⟩ + have hp := hw premiseP (Or.inl rfl) + have hr := hw premiseRule (Or.inr (Or.inl rfl)) + have hn := hw premiseNotQ (Or.inr (Or.inr rfl)) + exact hn (hr hp) +/- A retraction replaces the old singleton, rather than retaining both at the same time. -/ +def revisionSlice (time : Nat) : Theory Bool := + singleton (fun w => w = (time == 0)) +/- The initial and revised slices have models; keeping both would create a conflict. -/ +/-- organon-map CoreReader.Logic.revisionCanReverse +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem revisionCanReverse : + Satisfiable (revisionSlice 0) ∧ Satisfiable (revisionSlice 1) ∧ + ¬ Satisfiable (union (revisionSlice 0) (revisionSlice 1)) := by + refine ⟨⟨true, (modelsSingleton _ _).2 rfl⟩, + ⟨false, (modelsSingleton _ _).2 rfl⟩, ?_⟩ + rintro ⟨w, hw⟩ + have hs := (modelsUnion _ _ _).1 hw + have hp := (modelsSingleton _ _).1 hs.1 + have hn := (modelsSingleton _ _).1 hs.2 + have bad : true = false := hp.symm.trans hn + cases bad +/- This basic question asks whether the represented switch is on. -/ +def onQuestion : Unit → Claim Bool := fun _ w => w = true +def assumptionContext (b : Bool) : Context Bool Unit := + ⟨singleton (fun w => w = b), onQuestion, fun _ => True⟩ +def meaningContext (b : Bool) : Context Bool Unit := + ⟨singleton (fun w => w = true), (fun _ w => w = b), fun _ => True⟩ +def scopeContext (b : Bool) : Context Bool Unit := + ⟨emptyTheory, onQuestion, fun w => w = b⟩ +/- Distinct assumptions, meanings and scopes each admit opposite judgments without same-context conflict. -/ +/-- organon-map CoreReader.Logic.contextDifferences +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem contextDifferences : + (Consequence emptyTheory (assumptionContext true) () true ∧ + Consequence emptyTheory (assumptionContext false) () false) ∧ + (Consequence emptyTheory (meaningContext true) () true ∧ + Consequence emptyTheory (meaningContext false) () false) ∧ + (Consequence emptyTheory (scopeContext true) () true ∧ + Consequence emptyTheory (scopeContext false) () false) ∧ + (∀ b, ∃ w, Admissible emptyTheory (assumptionContext b) w) ∧ + (∀ b, ∃ w, Admissible emptyTheory (meaningContext b) w) ∧ + (∀ b, ∃ w, Admissible emptyTheory (scopeContext b) w) := by + have empty : ∀ w : Bool, Models emptyTheory w := by intro w p hp; cases hp + refine ⟨⟨?_, ?_⟩, ⟨?_, ?_⟩, ⟨?_, ?_⟩, ?_, ?_, ?_⟩ + · intro w h; change w = true; exact (modelsSingleton (fun x : Bool => x = true) w).1 h.2.1 + · intro w h hp; have hn := (modelsSingleton _ _).1 h.2.1; cases hp.symm.trans hn + · intro w h; change w = true; exact (modelsSingleton (fun x : Bool => x = true) w).1 h.2.1 + · intro w h hn; have hp := (modelsSingleton _ _).1 h.2.1; cases hp.symm.trans hn + · intro w h; exact h.2.2 + · intro w h hp; cases hp.symm.trans h.2.2 + · intro b; exact ⟨b, empty b, (modelsSingleton _ _).2 rfl, trivial⟩ + · intro b; exact ⟨true, empty true, (modelsSingleton _ _).2 rfl, trivial⟩ + · intro b; exact ⟨b, empty b, empty b, rfl⟩ +/- Snapshots preserve identifiable adopted-form revisions even when semantic content agrees. -/ +structure Snapshot (W Q : Type) where + held : Theory W + context : Context W Q + revisionIdentity : Nat +/- Semantic equivalence compares represented content, not its list ordering. -/ +def SameContent {W Q : Type} (a b : Snapshot W Q) : Prop := + (∀ p, a.held p ↔ b.held p) ∧ + (∀ p, a.context.assumptions p ↔ b.context.assumptions p) ∧ + (∀ q w, a.context.meaning q w ↔ b.context.meaning q w) ∧ + (∀ w, a.context.scope w ↔ b.context.scope w) +/- The reporting norm covers both semantic change and independently identified revisions. -/ +def TruthfulReport {W Q : Type} (a b : Snapshot W Q) (reported : Bool) : Prop := + (¬ SameContent a b ∨ a.revisionIdentity ≠ b.revisionIdentity) → reported = true +/- A real represented change and compliance entail an acknowledged change. -/ +/-- organon-map CoreReader.Logic.semanticChangeMustBeReported +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem semanticChangeMustBeReported {W Q : Type} (a b : Snapshot W Q) (reported : Bool) + (changed : ¬ SameContent a b ∨ a.revisionIdentity ≠ b.revisionIdentity) + (h : TruthfulReport a b reported) : reported = true := h changed +/- Reordering a two-claim presentation preserves the held theory extension. -/ +/-- organon-map CoreReader.Logic.representationOrderIrrelevant +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem representationOrderIrrelevant {W : Type} (p q : Claim W) : + ∀ r, union (singleton p) (singleton q) r ↔ union (singleton q) (singleton p) r := by + intro r; exact or_comm +def contextSnapshot (c : Context Bool Unit) (revision : Nat := 0) : Snapshot Bool Unit := + ⟨emptyTheory, c, revision⟩ +/- Hiding each kind of contextual change violates the reporting interface; reporting alone supplies no truth guarantee. -/ +/-- organon-map CoreReader.Logic.hiddenContextChangeRejected +organon.charter.consistency.meaning#p1 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +organon.charter.consistency.meaning#p2 sha256 81c09e38a3349499f95401d1c08f6069666c13547a43bc4e4395330743055faa +-/ +theorem hiddenContextChangeRejected : + ¬ TruthfulReport (contextSnapshot (assumptionContext true)) (contextSnapshot (assumptionContext false)) false ∧ + ¬ TruthfulReport (contextSnapshot (meaningContext true)) (contextSnapshot (meaningContext false)) false ∧ + ¬ TruthfulReport (contextSnapshot (scopeContext true)) (contextSnapshot (scopeContext false)) false ∧ + ¬ TruthfulReport (contextSnapshot (scopeContext true) 0) (contextSnapshot (scopeContext true) 1) false ∧ + (TruthfulReport (contextSnapshot (assumptionContext true)) (contextSnapshot (assumptionContext false)) true ∧ + ¬ Models (assumptionContext false).assumptions true) := by + have neq : (fun w : Bool => w = true) ≠ (fun w : Bool => w = false) := by + intro h; have k := congrFun h true; have z : true = false := k.mp rfl; cases z + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + have bad := h (Or.inl (by intro s; exact neq ((s.2.1 _).mp rfl))) + cases bad + · intro h + have bad := h (Or.inl (by intro s; have z := (s.2.2.1 () true).mp rfl; cases z)) + cases bad + · intro h + have bad := h (Or.inl (by intro s; have z := (s.2.2.2 true).mp rfl; cases z)) + cases bad + · intro h; have bad := h (Or.inr (by decide)); cases bad + · refine ⟨fun _ => rfl, ?_⟩ + intro h; have z := (modelsSingleton _ _).1 h; cases z +/- Two nonidentical resource objectives can share a feasible allocation. -/ +/-- organon-map CoreReader.Logic.tensionWithoutContradiction +organon.charter.consistency.limits#p1 sha256 4fa1c29bf95ad6ef04c6d27671a832c0af8ba31b9c0d8018a8d09c4f33c38e75 +-/ +theorem tensionWithoutContradiction : + (∃ budget : Nat, 4 ≤ budget ∧ budget ≤ 6) ∧ + ¬ ((fun n : Nat => 4 ≤ n) = (fun n : Nat => n ≤ 6)) := by + refine ⟨⟨5, by decide, by decide⟩, ?_⟩ + intro h; have k := congrFun h 0; have bad : 4 ≤ 0 := k.mpr (by decide); cases bad +/- Conflicting conclusions cannot be retained under the same consistency obligation. -/ +/-- organon-map CoreReader.Logic.conflictRequiresChange +organon.charter.consistency.limits#p1 sha256 4fa1c29bf95ad6ef04c6d27671a832c0af8ba31b9c0d8018a8d09c4f33c38e75 +-/ +theorem conflictRequiresChange {W Q : Type} (t : Theory W) (c : Context W Q) (q : Q) + (positive : Consequence t c q true) (negative : Consequence t c q false) : + ¬ Consistent t c := fun h => h q ⟨positive,negative⟩ +/- A satisfiable theory can have a false assumption at a specified actual world. -/ +/-- organon-map CoreReader.Logic.consistentFalse +organon.charter.consistency.limits#p1 sha256 4fa1c29bf95ad6ef04c6d27671a832c0af8ba31b9c0d8018a8d09c4f33c38e75 +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem consistentFalse : Satisfiable (singleton (fun w : Bool => w = true)) ∧ + ¬ Models (singleton (fun w : Bool => w = true)) false := by + refine ⟨⟨true, (modelsSingleton _ _).2 rfl⟩, ?_⟩ + intro h; have bad := (modelsSingleton _ _).1 h; cases bad +/- The explicitly asked on/off question is undecided by the empty but inhabited theory. -/ +/-- organon-map CoreReader.Logic.consistentIncomplete +organon.charter.consistency.limits#p1 sha256 4fa1c29bf95ad6ef04c6d27671a832c0af8ba31b9c0d8018a8d09c4f33c38e75 +organon.relationships.roles#p1 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p2 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +organon.relationships.roles#p3 sha256 24b533c77fe93d0570da65ee361893f2c445842f48ee6f315f99f8abc06a0e5e +-/ +theorem consistentIncomplete : Satisfiable (emptyTheory : Theory Bool) ∧ + ¬ Entails emptyTheory (fun w : Bool => w = true) ∧ + ¬ Entails emptyTheory (fun w : Bool => w ≠ true) := by + have empty : ∀ w : Bool, Models emptyTheory w := by intro w p hp; cases hp + refine ⟨⟨true, empty true⟩, ?_, ?_⟩ + · intro h; have bad := h false (empty false); cases bad + · intro h; exact h true (empty true) rfl +/- A claim can share a model with a theory without following in every model. -/ +/-- organon-map CoreReader.Logic.compatibilityNotEntailment +organon.grounds.assessment#p1 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p2 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +organon.grounds.assessment#p3 sha256 2e7cbca320eec1f25a6e82391c6d44d29bfafd4a27f2fe8241db0453381d0fe2 +-/ +theorem compatibilityNotEntailment : + Satisfiable (union emptyTheory (singleton (fun w : Bool => w = true))) ∧ + ¬ Entails emptyTheory (fun w : Bool => w = true) := by + refine ⟨⟨true, (modelsUnion _ _ _).2 ⟨?_, (modelsSingleton _ _).2 rfl⟩⟩, + consistentIncomplete.2.1⟩ + intro p hp; cases hp + +end CoreReader.Logic diff --git a/lean/philosophy/leanified/CoreReader/Reflexivity.lean b/lean/philosophy/leanified/CoreReader/Reflexivity.lean new file mode 100644 index 0000000..549155e --- /dev/null +++ b/lean/philosophy/leanified/CoreReader/Reflexivity.lean @@ -0,0 +1,427 @@ +import Std + +namespace CoreReader.Agency + +inductive Phase | formation | application | revision + deriving DecidableEq, Repr + +structure PrincipleKey where + owner : Nat + localId : Nat + deriving DecidableEq, Repr + +inductive Subject + | system (owner : Nat) + | principle (owner id : Nat) + | process (owner id : Nat) (phase : Phase) + deriving DecidableEq, Repr + +def Subject.owner : Subject → Nat + | .system n => n + | .principle n _ => n + | .process n _ _ => n + +inductive Activity | generation | assessment + deriving DecidableEq, Repr + +inductive QuestionKind | conformity | formationBasis | applicability | revisionGrounds + deriving DecidableEq, Repr + +inductive SampleProgram | alwaysTrue | onlyAtZero + deriving DecidableEq, Repr + +def SampleProgram.run : SampleProgram → Nat → Bool + | .alwaysTrue, _ => true + | .onlyAtZero, n => n == 0 + +/- A generated candidate specifies both the inputs it tests and the scope it proposes to license. -/ +structure MethodDraft where + testedInputs : List Nat + claimedScope : List Nat + deriving DecidableEq, Repr + +def MethodDraft.accepts (draft : MethodDraft) (program : SampleProgram) : Bool := + draft.testedInputs.all program.run + +/- This finite application asks whether a proposed rule's observed inputs support its claimed input scope. -/ +structure Inquiry where + target : Subject + kind : QuestionKind + requestedScope : List Nat + currentMethod : MethodDraft + deriving DecidableEq, Repr + +inductive ReasonContent + | purpose (inputs : List Nat) + | declaredScope (inputs : List Nat) + | observation (input : Nat) (output : Bool) + | counterexample (program : SampleProgram) (input : Nat) + deriving DecidableEq, Repr + +def ReasonContent.identifier : ReasonContent → Nat + | .purpose _ => 0 + | .declaredScope _ => 1 + | .observation _ _ => 2 + | .counterexample _ _ => 3 + +/- Reasons have independently supplied contents, a stable local reference and the actual target they concern. -/ +structure ReasonObject where + reference : Nat + target : Subject + content : ReasonContent + deriving DecidableEq, Repr + +inductive AssessmentResult | supportedWithinScope | insufficient | notApplicable | undetermined + deriving DecidableEq, Repr + +inductive WorkOutcome + | assessment (result : AssessmentResult) + | generated (draft : MethodDraft) + deriving DecidableEq, Repr + +/- A method's question, source reasons and limits are determined before looking at its activity records. +The meaning relation describes application of that method, not its universal adequacy. -/ +structure Principle where + key : PrincipleKey + activity : Activity + declaredMethod : MethodDraft + applicable : Subject → Prop + inquiry : Subject → Inquiry + reasons : Subject → List ReasonObject + limits : Subject → List Nat + meaning : Inquiry → List ReasonObject → List Nat → WorkOutcome → Prop + +structure WorkRecord where + usedPrinciple : PrincipleKey + target : Subject + activity : Activity + inquiry : Inquiry + reasons : List ReasonObject + limits : List Nat + outcome : WorkOutcome + deriving DecidableEq, Repr + +def RegistryCoherent (rules : List Principle) : Prop := + ∀ p ∈ rules, ∀ q ∈ rules, p.key = q.key → p = q + +def TargetResolved (rules : List Principle) : Subject → Prop + | .system owner => ∃ p ∈ rules, p.key.owner = owner + | .principle owner id | .process owner id _ => ∃ p ∈ rules, p.key = ⟨owner,id⟩ + +/- The inquiry names the registered target's declared method contract, not an unrelated candidate. +For a system inquiry this finite model uses the registered generation contract as its assessed artifact. -/ +def TargetContentResolved (rules : List Principle) (question : Inquiry) : Prop := + match question.target with + | .system owner => ∃ p ∈ rules, p.key = ⟨owner,0⟩ ∧ question.currentMethod = p.declaredMethod + | .principle owner id | .process owner id _ => + ∃ p ∈ rules, p.key = ⟨owner,id⟩ ∧ question.currentMethod = p.declaredMethod + +def Performed (records : List WorkRecord) (s : Subject) (a : Activity) : Prop := + ∃ record ∈ records, record.target = s ∧ record.activity = a + +/- The old scope condition remains available without conflating scope with content completion. -/ +def ReflexiveScope (owner : Nat) (rules : List Principle) (records : List WorkRecord) : Prop := + ∀ rule ∈ rules, ∀ s, s.owner = owner → rule.applicable s → Performed records s rule.activity + +/- A record uses a registered principle on the same resolvable target, question, reasons and limits, +and its result must actually follow that principle's method. A negative result can satisfy this relation. -/ +structure ValidApplication (rules : List Principle) (rule : Principle) (s : Subject) + (record : WorkRecord) : Prop where + registered : rule ∈ rules + applicable : rule.applicable s + usedIdentity : record.usedPrinciple = rule.key + targetIdentity : record.target = s + targetResolved : TargetResolved rules s + activityIdentity : record.activity = rule.activity + inquiryIdentity : record.inquiry = rule.inquiry s + inquiryTarget : record.inquiry.target = s + targetContent : TargetContentResolved rules record.inquiry + reasonsIdentity : record.reasons = rule.reasons s + reasonsNonempty : record.reasons ≠ [] + reasonTargets : ∀ reason ∈ record.reasons, reason.target = s + limitsIdentity : record.limits = rule.limits s + followsMeaning : rule.meaning record.inquiry record.reasons record.limits record.outcome + +/- The registered normative interface requires contentful application, not just activity labels. -/ +/-- organon-map CoreReader.Agency.Reflexive +organon.charter.reflexivity#p1 sha256 13293b45c2fa89068c68ae7ef3c5df38f0efadb3ef3873d78a5ba67d9691a757 +organon.charter.reflexivity.meaning#p1 sha256 8a2caede01a43d8b6c60b54c78ac089c51868e9956f316948077ccee2e45c9cc +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +def Reflexive (owner : Nat) (rules : List Principle) (records : List WorkRecord) : Prop := + RegistryCoherent rules ∧ + ∀ rule ∈ rules, ∀ s, s.owner = owner → rule.applicable s → + ∃ record ∈ records, ValidApplication rules rule s record + +theorem Reflexive.toScope {owner : Nat} {rules : List Principle} {records : List WorkRecord} + (h : Reflexive owner rules records) : ReflexiveScope owner rules records := by + intro rule hr s hs ha + obtain ⟨record, hm, hv⟩ := h.2 rule hr s hs ha + exact ⟨record, hm, hv.targetIdentity, hv.activityIdentity⟩ + +/-- organon-map CoreReader.Agency.noSelfExemption +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +theorem noSelfExemption (owner : Nat) (rules : List Principle) (records : List WorkRecord) + (h : Reflexive owner rules records) (rule : Principle) (hr : rule ∈ rules) + (s : Subject) (hs : s.owner = owner) (ha : rule.applicable s) : + Performed records s rule.activity := h.toScope rule hr s hs ha + +def localMethod : MethodDraft := ⟨[0],[0]⟩ + +def inquiryFor (s : Subject) : Inquiry := + match s with + | .process _ _ .formation => ⟨s, .formationBasis, [0], localMethod⟩ + | .process _ _ .application => ⟨s, .applicability, [0], localMethod⟩ + | .process _ _ .revision => ⟨s, .revisionGrounds, [0,1], localMethod⟩ + | _ => ⟨s, .conformity, [0], localMethod⟩ + +/- These original inquiry inputs do not depend on which work records happen to be present. -/ +def sourceReasonContents : QuestionKind → List ReasonContent + | .formationBasis => [.purpose [0], .declaredScope [0], .observation 0 true] + | .applicability | .conformity => [.declaredScope [0], .observation 0 true] + | .revisionGrounds => [.purpose [0,1], .declaredScope [0], .observation 0 true, + .counterexample .onlyAtZero 1] + +def reasonsFor (s : Subject) : List ReasonObject := + (sourceReasonContents (inquiryFor s).kind).map fun content => ⟨content.identifier,s,content⟩ + +/- The application-specific evaluator examines actual scope and sample/counterexample contents. +It is a finite inferential method, not a universal standard for empirical or value claims. -/ +def assessInquiry (question : Inquiry) (reasons : List ReasonObject) (limits : List Nat) : AssessmentResult := + let contents := reasons.map ReasonObject.content + if limits ≠ question.currentMethod.claimedScope then .undetermined else + match question.kind with + | .formationBasis => + if ReasonContent.purpose question.requestedScope ∈ contents ∧ + ReasonContent.declaredScope limits ∈ contents ∧ question.requestedScope = limits + then .supportedWithinScope else .undetermined + | .applicability | .conformity => + if question.requestedScope.all (fun n => limits.contains n) then + if ReasonContent.declaredScope limits ∈ contents ∧ + ReasonContent.observation 0 true ∈ contents ∧ question.requestedScope = [0] + then .supportedWithinScope else .undetermined + else .notApplicable + | .revisionGrounds => + if ReasonContent.purpose question.requestedScope ∈ contents ∧ + ReasonContent.declaredScope limits ∈ contents ∧ + ReasonContent.observation 0 true ∈ contents ∧ + contents.any (fun reason => match reason with + | .counterexample program input => question.requestedScope.contains input && + question.currentMethod.accepts program && + !(program.run input) + | _ => false) + then .insufficient else .undetermined + +def finiteMethodResult (activity : Activity) (question : Inquiry) + (reasons : List ReasonObject) (limits : List Nat) : WorkOutcome := + match activity with + | .generation => .generated ⟨question.currentMethod.testedInputs,question.requestedScope⟩ + | .assessment => .assessment (assessInquiry question reasons limits) + +def finiteMethodMeaning (activity : Activity) (question : Inquiry) + (reasons : List ReasonObject) (limits : List Nat) (outcome : WorkOutcome) : Prop := + outcome = finiteMethodResult activity question reasons limits + +def ownSubjects (owner : Nat) : List Subject := + [.system owner, .principle owner 0, .principle owner 1, + .process owner 0 .formation, .process owner 0 .application, .process owner 0 .revision, + .process owner 1 .formation, .process owner 1 .application, .process owner 1 .revision] + +/- Applying an existing rule is not a generation event in this application. -/ +def generationEligible : Subject → Bool + | .process _ _ .application => false + | _ => true + +def generatingRule (owner : Nat) : Principle where + key := ⟨owner,0⟩ + activity := .generation + declaredMethod := localMethod + applicable s := s ∈ ownSubjects owner ∧ generationEligible s = true + inquiry := inquiryFor + reasons := reasonsFor + limits _ := [0] + meaning := finiteMethodMeaning .generation + +def assessingRule (owner : Nat) : Principle where + key := ⟨owner,1⟩ + activity := .assessment + declaredMethod := localMethod + applicable s := s ∈ ownSubjects owner + inquiry := inquiryFor + reasons := reasonsFor + limits _ := [0] + meaning := finiteMethodMeaning .assessment + +def ownRules (owner : Nat) : List Principle := [generatingRule owner, assessingRule owner] + +/- Recorded verdicts are stated separately from the evaluator, so agreement has to be proved. -/ +def statedOutcome (activity : Activity) (s : Subject) : WorkOutcome := + match activity with + | .generation => .generated ⟨(inquiryFor s).currentMethod.testedInputs,(inquiryFor s).requestedScope⟩ + | .assessment => .assessment (match (inquiryFor s).kind with + | .revisionGrounds => .insufficient + | _ => .supportedWithinScope) + +def recordFor (rule : Principle) (s : Subject) : WorkRecord := + ⟨rule.key,s,rule.activity,rule.inquiry s,rule.reasons s,rule.limits s,statedOutcome rule.activity s⟩ + +theorem reasonsFor_nonempty (s : Subject) : reasonsFor s ≠ [] := by + cases s with + | system owner => simp [reasonsFor, inquiryFor, sourceReasonContents] + | principle owner id => simp [reasonsFor, inquiryFor, sourceReasonContents] + | process owner id phase => cases phase <;> simp [reasonsFor, inquiryFor, sourceReasonContents] + +theorem reasonsFor_target (s : Subject) : ∀ reason ∈ reasonsFor s, reason.target = s := by + intro reason h + obtain ⟨content, _, rfl⟩ := List.mem_map.mp h + rfl + +theorem inquiryFor_target (s : Subject) : (inquiryFor s).target = s := by + cases s with + | system owner => rfl + | principle owner id => rfl + | process owner id phase => cases phase <;> rfl + +/- This proof includes the actual negative revision evaluation for both principle identities. -/ +theorem ownContentEvaluates (activity : Activity) (s : Subject) : + statedOutcome activity s = finiteMethodResult activity (inquiryFor s) (reasonsFor s) [0] := by + cases activity with + | generation => rfl + | assessment => + cases s with + | system owner => rfl + | principle owner id => rfl + | process owner id phase => cases phase <;> rfl + +theorem ownRegistryCoherent (owner : Nat) : RegistryCoherent (ownRules owner) := by + intro p hp q hq hkey + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hp hq + rcases hp with rfl | rfl <;> rcases hq with rfl | rfl + · rfl + · have bad := congrArg PrincipleKey.localId hkey; contradiction + · have bad := congrArg PrincipleKey.localId hkey; contradiction + · rfl + +theorem ownTargetResolved (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) : + TargetResolved (ownRules owner) s := by + simp only [ownSubjects, List.mem_cons, List.not_mem_nil, or_false] at hs + rcases hs with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + simp [TargetResolved, ownRules, generatingRule, assessingRule] + +theorem ownTargetContent (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) : + TargetContentResolved (ownRules owner) (inquiryFor s) := by + simp only [ownSubjects, List.mem_cons, List.not_mem_nil, or_false] at hs + rcases hs with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + simp [TargetContentResolved, inquiryFor, ownRules, generatingRule, assessingRule] + +theorem ownRecordValid (owner : Nat) (rule : Principle) (hr : rule ∈ ownRules owner) + (s : Subject) (ha : rule.applicable s) : + ValidApplication (ownRules owner) rule s (recordFor rule s) := by + have hs : s ∈ ownSubjects owner := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl + · exact ha.1 + · exact ha + have hq : rule.inquiry = inquiryFor := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl <;> rfl + have hg : rule.reasons = reasonsFor := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl <;> rfl + have hl : rule.limits s = [0] := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl <;> rfl + have hm : rule.meaning = finiteMethodMeaning rule.activity := by + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl <;> rfl + refine ⟨hr, ha, rfl, rfl, ownTargetResolved owner s hs, rfl, rfl, ?_, ?_, rfl, ?_, ?_, rfl, ?_⟩ + · change (rule.inquiry s).target = s + rw [hq]; exact inquiryFor_target s + · change TargetContentResolved (ownRules owner) (rule.inquiry s) + rw [hq]; exact ownTargetContent owner s hs + · change rule.reasons s ≠ [] + rw [hg]; exact reasonsFor_nonempty s + · change ∀ reason ∈ rule.reasons s, reason.target = s + rw [hg]; exact reasonsFor_target s + · change rule.meaning (rule.inquiry s) (rule.reasons s) (rule.limits s) (statedOutcome rule.activity s) + rw [hm, hq, hg, hl] + exact ownContentEvaluates rule.activity s + +def completeOwnWork (owner : Nat) : List WorkRecord := + (ownSubjects owner).flatMap fun s => + if generationEligible s then [recordFor (generatingRule owner) s, recordFor (assessingRule owner) s] + else [recordFor (assessingRule owner) s] + +theorem assessingRecord_member (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) : + recordFor (assessingRule owner) s ∈ completeOwnWork owner := by + apply List.mem_flatMap.mpr + refine ⟨s,hs,?_⟩ + cases generationEligible s <;> simp + +theorem generatingRecord_member (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) + (hg : generationEligible s = true) : recordFor (generatingRule owner) s ∈ completeOwnWork owner := by + exact List.mem_flatMap.mpr ⟨s,hs,by simp [hg]⟩ + +theorem completeOwnWork_reflexive (owner : Nat) : + Reflexive owner (ownRules owner) (completeOwnWork owner) := by + refine ⟨ownRegistryCoherent owner, ?_⟩ + intro rule hr s _ ha + refine ⟨recordFor rule s, ?_, ownRecordValid owner rule hr s ha⟩ + simp only [ownRules, List.mem_cons, List.not_mem_nil, or_false] at hr + rcases hr with rfl | rfl + · exact generatingRecord_member owner s ha.1 ha.2 + · exact assessingRecord_member owner s ha + +theorem ownAssessmentPerformed (owner : Nat) (s : Subject) (hs : s ∈ ownSubjects owner) : + Performed (completeOwnWork owner) s .assessment := + ⟨recordFor (assessingRule owner) s, assessingRecord_member owner s hs, rfl, rfl⟩ + +def applicationRule : Principle := + { assessingRule 0 with key := ⟨0,0⟩, applicable := fun s => s = .process 0 0 .application } + +def applicationWork : List WorkRecord := [recordFor applicationRule (.process 0 0 .application)] + +theorem applicationWork_reflexive : Reflexive 0 [applicationRule] applicationWork := by + constructor + · intro p hp q hq _ + simp only [List.mem_singleton] at hp hq + rw [hp,hq] + · intro rule hr s _ ha + simp only [List.mem_singleton] at hr + subst rule + change s = .process 0 0 .application at ha + subst s + refine ⟨recordFor applicationRule (.process 0 0 .application), by simp [applicationWork], ?_⟩ + refine ⟨by simp, rfl, rfl, rfl, ?_, rfl, rfl, rfl, ?_, rfl, ?_, ?_, rfl, ?_⟩ + · exact ⟨applicationRule, by simp, rfl⟩ + · exact ⟨applicationRule, by simp, rfl, rfl⟩ + · exact reasonsFor_nonempty _ + · exact reasonsFor_target _ + · change statedOutcome .assessment (.process 0 0 .application) = finiteMethodResult .assessment (inquiryFor (.process 0 0 .application)) (reasonsFor (.process 0 0 .application)) [0] + exact ownContentEvaluates .assessment _ + +/-- organon-map CoreReader.Agency.applicabilityRetained +organon.charter.reflexivity.limits#p1 sha256 ac0baae0d86e69f84c1ca4dee837de2759e2d29c295ffc257d988962158d4bbc +-/ +theorem applicabilityRetained (owner : Nat) (rules : List Principle) (records : List WorkRecord) : + (Reflexive owner rules records → ReflexiveScope owner rules records) ∧ + (ReflexiveScope owner rules records ↔ + ∀ rule ∈ rules, ∀ s, s.owner = owner → (¬ rule.applicable s ∨ Performed records s rule.activity)) ∧ + (Reflexive 0 [applicationRule] applicationWork ∧ + ¬ Performed applicationWork (.system 0) .assessment) := by + classical + refine ⟨Reflexive.toScope, ?_, applicationWork_reflexive, ?_⟩ + · constructor + · intro h rule hr s hs + by_cases ha : rule.applicable s + · exact Or.inr (h rule hr s hs ha) + · exact Or.inl ha + · intro h rule hr s hs ha + exact (h rule hr s hs).resolve_left (not_not_intro ha) + · rintro ⟨record, hm, ht, _⟩ + simp only [applicationWork, List.mem_singleton] at hm + subst record + cases ht + +end CoreReader.Agency diff --git a/lean/philosophy/leanified/lakefile.toml b/lean/philosophy/leanified/lakefile.toml new file mode 100644 index 0000000..a9f2c99 --- /dev/null +++ b/lean/philosophy/leanified/lakefile.toml @@ -0,0 +1,5 @@ +name = "core_reproof" +version = "0.0.1" +defaultTargets = ["CoreReader"] +[[lean_lib]] +name = "CoreReader" diff --git a/lean/philosophy/leanified/lean-toolchain b/lean/philosophy/leanified/lean-toolchain new file mode 100644 index 0000000..a8afa7d --- /dev/null +++ b/lean/philosophy/leanified/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.33.1 diff --git a/lean/philosophy/manuscript.json b/lean/philosophy/manuscript.json new file mode 100644 index 0000000..9c40cad --- /dev/null +++ b/lean/philosophy/manuscript.json @@ -0,0 +1,653 @@ +{ + "schema_version": 1, + "repository_root": "../..", + "source_current": { + "path": "../../PHILOSOPHY.md", + "sha256": "226fa3522943955d5a0f1f0b88e883c97b3505b3bcfd285329e432757912543f" + }, + "proof_targets": { + "path": "targets.json", + "sha256": "2400383120ab2d98454597a73cdcaaadf45b8e47b18a646118708dc5d81da2a4" + }, + "code_files": [ + { + "path": "leanified/CoreReader/Agency.lean", + "sha256": "b0dca4187a88a0a0f33c3dd6a11bb383907603ef514e80e9e3f09f95ce9633e2" + }, + { + "path": "leanified/CoreReader/Choice.lean", + "sha256": "07cf17f73802bdd34ae00ecba317ddc0283321cce00f15a84b69df421c3fe25f" + }, + { + "path": "leanified/CoreReader/Evidence.lean", + "sha256": "18beb2b94450fdab36229b645e2df129348f3e67306104e842e0dce6e72443e8" + }, + { + "path": "leanified/CoreReader/Integration.lean", + "sha256": "b5ba8617e06f03963c4284344fbe3c662188f1b88542c55cc15beb1cd5f99c03" + }, + { + "path": "leanified/CoreReader/Logic.lean", + "sha256": "6b70be8964763b6447a2603bde665ff58106678f2e1d421bebd8c6b29ae46e04" + }, + { + "path": "leanified/CoreReader/Reflexivity.lean", + "sha256": "25292faa71c5585a8f50cb07d72c2f44fa12dcfb125b2b92094f9306fecb4fd0" + }, + { + "path": "leanified/CoreReader.lean", + "sha256": "80eee78ec3453fefdb26d3dbce97f0447d4b9ffeb4683604dad0c03902a1bfdd" + } + ], + "review": { + "path": "reviews/fidelity.json", + "sha256": "d6c6c7414736e26558ddfe620f1b3db45743f45b967c36b348aecf991bc15779" + }, + "views": { + "overview_en": { + "path": "overview.md", + "sha256": "9fbeb16d59c36789b578cd3df1f5e88559c82b243801c83d84df0855997866d7" + }, + "details_en": { + "path": "details.md", + "sha256": "b84342748d5cc5df26db610d7ab53cf8e553922f1847091be9b49d9bbbfb004a" + }, + "overview_zh": { + "path": "../../zh/lean/philosophy/overview.md", + "sha256": "4ff68caa6bb800d5a7adfce0538bb01b3a4c95afa3be78ce25167c8739c6b26b" + }, + "details_zh": { + "path": "../../zh/lean/philosophy/details.md", + "sha256": "1810b4d6800f4dd98699bf17db168718f22a0e3146ad7ecc90810c65cb4f84fe" + } + }, + "entries": [ + { + "id": "organon.preamble.p1", + "unit": "organon.preamble", + "clause": "p1", + "excerpt": "This is the authoritative statement of Organon’s philosophy. It expresses adopted commitments, not factual assertions about every system or a proof of universal correctness.", + "declarations": [ + "CoreReader.Integration.jointWitness" + ], + "kernel": "passed", + "fidelity": "not_applicable", + "status": "not_applicable", + "reason": "This declares textual authority and adopted-commitment scope, not a mathematical proposition about all systems. The review retains this boundary without manufacturing a Lean theorem of authority.", + "context_only": true + }, + { + "id": "organon.preamble.p2", + "unit": "organon.preamble", + "clause": "p2", + "excerpt": "The quoted provisions, their meanings, and their conditions of application form the core. The charter and Grounds constrain one another; their grouping establishes neither a deductive hierarchy nor an order of priority. [Rationale](rationale/README.md) supplies arguments and cases without adding obligations to this core. Skills are revisable applications under the repository’s stated objectives and constraints, not part of the philosophical commitments themselves.", + "declarations": [ + "CoreReader.Integration.jointWitness" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "The shared model exhibits compatible constraints without a chapter-priority inference. Authority of meanings and limits, the role of Rationale and revisability of actual skills remain textual commitments outside this finite witness." + }, + { + "id": "organon.charter", + "unit": "organon.charter", + "clause": null, + "excerpt": "\n", + "declarations": [], + "kernel": "not_checked", + "fidelity": "not_applicable", + "status": "not_applicable", + "reason": "Structural heading without substantive direct-body content; no theorem is assigned." + }, + { + "id": "organon.charter.overview.p1", + "unit": "organon.charter.overview", + "clause": "p1", + "excerpt": "**Self-Transcendence · Internal Consistency · Reflexivity**", + "declarations": [], + "kernel": "not_checked", + "fidelity": "not_applicable", + "status": "not_applicable", + "reason": "This is a structural list of three headings. It organizes substantive provisions and requires no fabricated theorem." + }, + { + "id": "organon.charter.overview.p2", + "unit": "organon.charter.overview", + "clause": "p2", + "excerpt": "> A system is intrinsically oriented toward expanding what it can understand and construct. It brings itself and its principles within the scope of generation and assessment, with internal consistency constraining this process.", + "declarations": [ + "CoreReader.Integration.jointWitness", + "CoreReader.Agency.Generative" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "jointWitness combines valued expansion, revisability, contextual consistency and contentful owned principle work in one inhabited system. It proves model satisfiability, not actual compliance by arbitrary systems." + }, + { + "id": "organon.charter.overview.p3", + "unit": "organon.charter.overview", + "clause": "p3", + "excerpt": "The overview connects three distinct requirements: self-transcendence establishes a generative orientation and refuses to treat existing forms as final, internal consistency constrains judgments held simultaneously, and reflexivity brings the system and its principles within the scope of their own generation and assessment. The provisions below specify the conditions for each.", + "declarations": [ + "CoreReader.Integration.jointWitness", + "CoreReader.Agency.Generative" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "The three requirements remain distinct predicates with a shared example and specific nonentailments. Their interpretation as philosophical obligations and their full conditions in arbitrary applications are not derived from the example." + }, + { + "id": "organon.charter.self-transcendence.p1", + "unit": "organon.charter.self-transcendence", + "clause": "p1", + "excerpt": "> A system is intrinsically oriented toward expanding what it can understand and construct. It does not regard any existing form as the endpoint of generation.", + "declarations": [ + "CoreReader.Agency.Generative" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "incomplete", + "reason": "Generative specifies valuation and revisability of current forms. The finite tags and state examples do not characterize every form of understanding, construction or intrinsic orientation." + }, + { + "id": "organon.charter.self-transcendence.orientation.p1", + "unit": "organon.charter.self-transcendence.orientation", + "clause": "p1", + "excerpt": "A commitment to keeping generative possibilities open is distinct from valuing their expansion. A system has an intrinsic orientation when it regards that expansion as worth pursuing. Merely permitting change does not fully express this orientation.", + "declarations": [ + "CoreReader.Agency.Generative", + "CoreReader.Agency.permissionNotValuation" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "The neutral-policy counterexample separates permission for distinct versions from the adopted valuation predicate. It does not establish what every real system values or justify the adopted value universally." + }, + { + "id": "organon.charter.self-transcendence.non-finality.p1", + "unit": "organon.charter.self-transcendence.non-finality", + "clause": "p1", + "excerpt": "Refusing to regard an existing form as an endpoint keeps it open to being surpassed. “Existing form” includes a system’s current organization, methods, and principles, not only its appearance or artifacts. These remain within the scope of possible change; their revisability does not guarantee actual progress.", + "declarations": [ + "CoreReader.Agency.Generative", + "CoreReader.Agency.revisabilityCovers", + "CoreReader.Agency.revisionWithoutProgress" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "All five represented form kinds, including organization, method and principle, fall under conditional revisability; a constant trace shows no progress guarantee. The chosen representation is not an exhaustive ontology or an executed revision." + }, + { + "id": "organon.charter.self-transcendence.limits.p1", + "unit": "organon.charter.self-transcendence.limits", + "clause": "p1", + "excerpt": "Whether progress has actually occurred remains a separate judgment. Having the orientation does not guarantee progress. Progress cannot be established merely by an increase in the number of artifacts, levels of abstraction, or terms.", + "declarations": [ + "CoreReader.Agency.Generative", + "CoreReader.Agency.generationLimits", + "CoreReader.Evidence.AchievementAccountability", + "CoreReader.Evidence.achievementNeedsSupport" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "The same before/after states increase inventory, abstraction and vocabulary without adding represented capabilities. Actual performance records can distinguish a genuine extension in a two-case world; empirical reliability beyond that world is not proved." + }, + { + "id": "organon.charter.self-transcendence.limits.p2", + "unit": "organon.charter.self-transcendence.limits", + "clause": "p2", + "excerpt": "- “Intrinsic orientation” expresses Organon’s philosophical commitment; it does not assert that all systems in fact develop autonomously.\n- Self-transcendence does not imply independence from external experience, knowledge, or collaboration, nor does it guarantee autonomous execution or self-improvement.\n- Refusing to regard an existing form as an endpoint does not require every action to produce change. Justified stability can coexist with a generative orientation.\n- Whether transcendence expands what can be understood and constructed requires discernible grounds; a system’s own claim of generation does not establish actual achievement.", + "declarations": [ + "CoreReader.Agency.Generative", + "CoreReader.Agency.generationLimits", + "CoreReader.Evidence.AchievementAccountability", + "CoreReader.Evidence.achievementNeedsSupport" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Bound execution exhibits separate external dependencies, grounded stability, a nonimproving trace and a refuted owned announcement. These are finite compatibility and failure examples; philosophical adoption and real autonomous development remain outside their conclusions." + }, + { + "id": "organon.charter.consistency.p1", + "unit": "organon.charter.consistency", + "clause": "p1", + "excerpt": "> The principles and judgments a system holds simultaneously, together with their implications, must not yield contradictory judgments on the same question under the same assumptions, meanings of terms, and scope of application.", + "declarations": [ + "CoreReader.Logic.consequenceConsistency", + "CoreReader.Logic.jointConflict" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "The general semantic theorem prevents opposite consequences under one theory/context when an admissible world exists. Existence of such a world, choice of questions and interpretation of held judgments are explicit modeling conditions, not guaranteed for reality." + }, + { + "id": "organon.charter.consistency.meaning.p1", + "unit": "organon.charter.consistency.meaning", + "clause": "p1", + "excerpt": "“Held simultaneously” specifies which principles, judgments, and implications must hold together. Revision may withdraw an earlier judgment; old and new principles need not remain compatible forever. When a change has occurred, that change cannot be represented as though it had not occurred.", + "declarations": [ + "CoreReader.Logic.revisionCanReverse", + "CoreReader.Logic.contextDifferences", + "CoreReader.Logic.semanticChangeMustBeReported", + "CoreReader.Logic.representationOrderIrrelevant", + "CoreReader.Logic.hiddenContextChangeRejected" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Concrete retraction slices can reverse judgments, and a conditional reporting specification disallows concealing recognized change. No automatic detector, adequate report generator or real revision history is established." + }, + { + "id": "organon.charter.consistency.meaning.p2", + "unit": "organon.charter.consistency.meaning", + "clause": "p2", + "excerpt": "“The same assumptions, meanings of terms, and scope of application” specifies the basis for comparing judgments. Divergent judgments under different conditions do not automatically constitute contradictions. Nor can unacknowledged changes in assumptions, meanings, or scope be used to conceal an existing contradiction.", + "declarations": [ + "CoreReader.Logic.revisionCanReverse", + "CoreReader.Logic.contextDifferences", + "CoreReader.Logic.semanticChangeMustBeReported", + "CoreReader.Logic.representationOrderIrrelevant", + "CoreReader.Logic.hiddenContextChangeRejected" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Separate assumption, meaning and scope changes admit different judgments; hidden changes fail the adopted report condition. This covers explicit semantic models, not every practical ambiguity or method of concealment." + }, + { + "id": "organon.charter.consistency.limits.p1", + "unit": "organon.charter.consistency.limits", + "clause": "p1", + "excerpt": "- Tension between different assessments or values does not directly constitute a contradiction. Revision or qualification is needed when they require incompatible conclusions under the same conditions.\n- Internal consistency is not correctness or sufficiency. A set of principles may be internally consistent while relying on false assumptions or neglecting important questions.", + "declarations": [ + "CoreReader.Logic.tensionWithoutContradiction", + "CoreReader.Logic.conflictRequiresChange", + "CoreReader.Logic.consistentFalse", + "CoreReader.Logic.consistentIncomplete" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Finite witnesses distinguish tension from contradiction and consistency from truth or completeness. Refusing to retain a demonstrated conflict is a conditional consequence of an adopted consistency requirement, not an implemented revision strategy." + }, + { + "id": "organon.charter.reflexivity.p1", + "unit": "organon.charter.reflexivity", + "clause": "p1", + "excerpt": "> A system’s principles of generation and assessment also apply to the system itself and to the formation, application, and revision of those principles.", + "declarations": [ + "CoreReader.Agency.Reflexive" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "incomplete", + "reason": "Reflexive quantifies applicable owned rules and subjects, with coherent keys and meaningful application records. The concrete rule set has generation and assessment work but does not cover every possible real principle." + }, + { + "id": "organon.charter.reflexivity.meaning.p1", + "unit": "organon.charter.reflexivity.meaning", + "clause": "p1", + "excerpt": "Reflexivity encompasses both the system itself and its principles. Assessment concerns not only whether the system conforms to its principles, but also how those principles are formed, where they apply, and why they may need revision. The formation and revision of principles thus also become objects of generation and assessment.", + "declarations": [ + "CoreReader.Agency.Reflexive" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "incomplete", + "reason": "The revised module models formation purposes, requested applicability scopes and revision counterexamples with actual evaluation and generation outcomes. These finite inquiry contracts do not establish the correctness or completeness of every assessment methodology." + }, + { + "id": "organon.charter.reflexivity.limits.p1", + "unit": "organon.charter.reflexivity.limits", + "clause": "p1", + "excerpt": "- Applying principles equally retains their conditions of application. When the relevant conditions hold, being the system itself is not a basis for exemption. Nor does the requirement of reflexivity establish that every principle can be applied to itself without examining its applicability.\n- Self-application does not constitute self-proof. Subjecting a principle to its own assessment does not thereby establish its correctness.\n- That a revision is produced by the system itself does not give it sufficient grounds.", + "declarations": [ + "CoreReader.Agency.Reflexive", + "CoreReader.Agency.noSelfExemption", + "CoreReader.Agency.applicabilityRetained", + "CoreReader.Agency.selfTestDoesNotProve", + "CoreReader.Evidence.selfOriginDoesNotSupport" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Applicability is retained, self-exemption fails where conditions hold, and finite self-tests plus a produced revision fail to establish universal support. The owned records and source identities are mathematical objects, not authenticated execution histories." + }, + { + "id": "organon.grounds.p1", + "unit": "organon.grounds", + "clause": "p1", + "excerpt": "> The grounds of principles and judgments must be articulable and subject to assessment appropriate to the nature of the claim. The strength and scope of a claim must be proportionate to the support provided by its grounds.", + "declarations": [ + "CoreReader.Evidence.AchievementAccountability", + "CoreReader.Evidence.achievementNeedsSupport", + "CoreReader.Evidence.Grounds", + "CoreReader.Evidence.supportWeakening", + "CoreReader.Evidence.scopeRestriction" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Grounds checks identified applicable facets of the same claim; support, entailment and an option-indexed value procedure carry distinct responsibilities. This is a chosen formal interface and finite fulfillment examples, not a universal sufficient criterion for all philosophical grounds." + }, + { + "id": "organon.grounds.assessment.p1", + "unit": "organon.grounds.assessment", + "clause": "p1", + "excerpt": "Articulation and assessment have distinct responsibilities. Articulability requires that concepts, assumptions, reasons, and limits can be identified. Assessment requires examining whether those grounds support the corresponding claim. Clearly expressed grounds are not thereby sufficiently established. When a claim has more than one applicable aspect, the corresponding assessment responsibilities apply to each aspect. Omitting a classification does not waive an applicable responsibility.", + "declarations": [ + "CoreReader.Evidence.Grounds", + "CoreReader.Evidence.supportWeakening", + "CoreReader.Evidence.scopeRestriction", + "CoreReader.Evidence.assessmentUnion", + "CoreReader.Evidence.labelsCannotWaive", + "CoreReader.Evidence.mixedMissingResponsibility", + "CoreReader.Evidence.articulationNotSupport", + "CoreReader.Evidence.measurementRepeatNotSupport", + "CoreReader.Logic.compatibilityNotEntailment", + "CoreReader.Evidence.selfAssertionNotReason", + "CoreReader.Evidence.valueWithoutSelfProof", + "CoreReader.Evidence.heterogeneousReasons", + "CoreReader.Evidence.nonExecutableAssessment" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Articulation content is linked to each facet and separated from its discharge; union and missing-aspect examples prevent labels from waiving represented duties. Identifying every actually relevant aspect remains an application responsibility not solved by the datatype." + }, + { + "id": "organon.grounds.assessment.p2", + "unit": "organon.grounds.assessment", + "clause": "p2", + "excerpt": "| Type of claim | Responsibility of assessment | What cannot substitute for that responsibility |\n| --- | --- | --- |\n| Empirical claim | Examine observations, evidence, and performance, together with the conditions, scope, and uncertainty of their support for the claim. | Treating measurability or repeatability itself as proof of relevance, correctness, or value. |\n| Inferential claim | Examine whether the conclusion is supported by the stated assumptions and inferential relations. | Treating the absence of conflict between a conclusion and its assumptions as sufficient to establish that the conclusion follows from them. |\n| Value commitment | State the position taken, its reasons, limits of application, and consequences, and remain open to relevant criticism. | Presenting a commitment as an empirical fact or a necessary inference, or substituting self-assertion for reasons. |", + "declarations": [ + "CoreReader.Evidence.Grounds", + "CoreReader.Evidence.supportWeakening", + "CoreReader.Evidence.scopeRestriction", + "CoreReader.Evidence.assessmentUnion", + "CoreReader.Evidence.labelsCannotWaive", + "CoreReader.Evidence.mixedMissingResponsibility", + "CoreReader.Evidence.articulationNotSupport", + "CoreReader.Evidence.measurementRepeatNotSupport", + "CoreReader.Logic.compatibilityNotEntailment", + "CoreReader.Evidence.selfAssertionNotReason", + "CoreReader.Evidence.valueWithoutSelfProof", + "CoreReader.Evidence.heterogeneousReasons", + "CoreReader.Evidence.nonExecutableAssessment" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "The three modeled adapters check observational compatibility/support, semantic entailment, and value reasons with limits/consequences/criticism. Actual relevance, empirical uncertainty and the adequacy of value criticism beyond the chosen cases are not exhaustively formalized." + }, + { + "id": "organon.grounds.assessment.p3", + "unit": "organon.grounds.assessment", + "clause": "p3", + "excerpt": "Initial value commitments may be stated explicitly as commitments; they need not prove all their own starting assumptions. The strength and scope of a claim do not require conversion to a common numerical scale. Different types of claims specify their support and limits in accordance with their nature.", + "declarations": [ + "CoreReader.Evidence.Grounds", + "CoreReader.Evidence.supportWeakening", + "CoreReader.Evidence.scopeRestriction", + "CoreReader.Evidence.assessmentUnion", + "CoreReader.Evidence.labelsCannotWaive", + "CoreReader.Evidence.mixedMissingResponsibility", + "CoreReader.Evidence.articulationNotSupport", + "CoreReader.Evidence.measurementRepeatNotSupport", + "CoreReader.Logic.compatibilityNotEntailment", + "CoreReader.Evidence.selfAssertionNotReason", + "CoreReader.Evidence.valueWithoutSelfProof", + "CoreReader.Evidence.heterogeneousReasons", + "CoreReader.Evidence.nonExecutableAssessment" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "JointAdoption requires consistent instantiated starting commitments without proving all starting assumptions. A two-reason example and heterogeneous facets avoid a universal numerical scale. They demonstrate procedural consistency, not ultimate value justification." + }, + { + "id": "organon.grounds.scope.p1", + "unit": "organon.grounds.scope", + "clause": "p1", + "excerpt": "Performance is discerned within particular relations, conditions, and scopes of observation. A boundary helps specify what a comparison concerns, but local examples do not automatically support unconditional universal conclusions. A judgment cannot establish that relevant differences do not exist merely because its chosen scope omits them.", + "declarations": [ + "CoreReader.Evidence.localNotUniversal", + "CoreReader.Evidence.hiddenDifference", + "CoreReader.Evidence.singleObservation", + "CoreReader.Evidence.noUniversalChain", + "CoreReader.Evidence.variableOutcomesStableBound", + "CoreReader.Evidence.verificationReproductionStability" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "A proper local observation scope supports a local function claim while admitting a counterexample outside it. This establishes the specified nonentailment; it neither identifies all relevant real differences nor rules out justified wider evidence." + }, + { + "id": "organon.grounds.scope.p2", + "unit": "organon.grounds.scope", + "clause": "p2", + "excerpt": "Measurement can make some differences comparable. Repeated assessment can help examine the stability of corresponding conclusions. Their roles, and the role of any assessment framework, must be explained relative to the claim and its context. Measurement, repeatability, and an assessment framework do not form a universally necessary chain on which all judgments must depend.", + "declarations": [ + "CoreReader.Evidence.localNotUniversal", + "CoreReader.Evidence.hiddenDifference", + "CoreReader.Evidence.singleObservation", + "CoreReader.Evidence.noUniversalChain", + "CoreReader.Evidence.variableOutcomesStableBound", + "CoreReader.Evidence.verificationReproductionStability" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Repeated irrelevant measurements fail support, while a valid inferential assessment needs no empirical chain. This refutes a universal mandatory chain within the represented responsibilities but does not characterize every framework or measurement practice." + }, + { + "id": "organon.grounds.scope.p3", + "unit": "organon.grounds.scope", + "clause": "p3", + "excerpt": "An observation that has not been reproduced may still offer limited support, and random outcomes need not be identical on every occasion. The verifiability of observations, reproducibility of conditions, and stability of conclusions must be distinguished.", + "declarations": [ + "CoreReader.Evidence.localNotUniversal", + "CoreReader.Evidence.hiddenDifference", + "CoreReader.Evidence.singleObservation", + "CoreReader.Evidence.noUniversalChain", + "CoreReader.Evidence.variableOutcomesStableBound", + "CoreReader.Evidence.verificationReproductionStability" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "A single observation has limited support and distinct trial outcomes preserve a fixed bound. Verification, reproducible conditions and conclusion stability use separate predicates; no probability distribution or general reproducibility law is proved." + }, + { + "id": "organon.grounds.capabilities.p1", + "unit": "organon.grounds.capabilities", + "clause": "p1", + "excerpt": "Capability claims are subject to Grounds: the capability claimed, its conditions, and the support for it must be identifiable. The core does not prescribe uniform definitions of method mastery, method generation, or capability levels. Applications specify the capabilities they assess and may require understanding, explanation, or performance under relevant variations.", + "declarations": [ + "CoreReader.Evidence.AchievementAccountability", + "CoreReader.Evidence.achievementNeedsSupport", + "CoreReader.Evidence.outputNotExplanation", + "CoreReader.Evidence.applicationContractsDiffer", + "CoreReader.Evidence.externalAssessment", + "CoreReader.Agency.inventoryNotCapability" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Output-only and explanation-bearing contracts concern the same process and each has its own checked Grounds; applicationVariation changes the actual objective and invalidates old evidence. No uniform real mastery or capability-level definition is derived." + }, + { + "id": "organon.grounds.capabilities.p2", + "unit": "organon.grounds.capabilities", + "clause": "p2", + "excerpt": "Grounds for a capability claim may be supplied by an external assessor. Their articulability does not by itself require the assessed system to understand or explain its internal generation process. Evidence of reliable output must be assessed against the capability actually claimed; it does not automatically establish understanding of that process. Nor can the number of method documents, terms, tools, or artifacts alone establish a capability beyond what that evidence supports.", + "declarations": [ + "CoreReader.Evidence.AchievementAccountability", + "CoreReader.Evidence.achievementNeedsSupport", + "CoreReader.Evidence.outputNotExplanation", + "CoreReader.Evidence.applicationContractsDiffer", + "CoreReader.Evidence.externalAssessment", + "CoreReader.Agency.inventoryNotCapability" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "A distinct assessor role supplies a proof about the exact output process while no explanation certificate is attached; duplicating four inventory kinds leaves represented capability unchanged. Role numbers and certificates do not prove external provenance or human-like understanding." + }, + { + "id": "organon.grounds.implementations.p1", + "unit": "organon.grounds.implementations", + "clause": "p1", + "excerpt": "> The choice of an implementation must be supported by reasons connected to the objectives and values pursued and to the relevant constraints. Its name, conventional use, or established status alone does not provide sufficient grounds for giving it priority.", + "declarations": [ + "CoreReader.Choice.statusOnlyFails", + "CoreReader.Choice.conventionWithReason", + "CoreReader.Choice.generalGroundsNotChoice" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "The adopted choice interface requires feasibility and an objective/value/constraint-linked reason and rejects status-only reasons. Its finite reason vocabulary and concrete feasibility checks do not supply a general theory of warranted real implementation choice." + }, + { + "id": "organon.grounds.implementations.p2", + "unit": "organon.grounds.implementations", + "clause": "p2", + "excerpt": "This choice provision adds an additional evaluative commitment: name, conventional use, or established status alone is insufficient to establish priority. Grouping it under Grounds does not mean that it follows from the general requirement to assess reasons, or merely from the discernibility of performance. Conventions and existing arrangements may have practical significance, but that significance must be connected to the objectives and values pursued and to the relevant constraints.", + "declarations": [ + "CoreReader.Choice.statusOnlyFails", + "CoreReader.Choice.conventionWithReason", + "CoreReader.Choice.generalGroundsNotChoice" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Two independent policies share a correct negative audit but differ on the added choice norm, establishing independence from the represented assessment procedure. This does not show an unsupported priority claim fully satisfies general Grounds, or derive a value commitment from neutral facts." + }, + { + "id": "organon.grounds.implementations.limits.p1", + "unit": "organon.grounds.implementations.limits", + "clause": "p1", + "excerpt": "- Openness does not make all implementations equivalent, nor does it guarantee multiple feasible implementations for the same objective.\n- A method’s explanatory power, limits of application, simplicity, and explicit process requirements may all provide grounded reasons for assessment. They cannot be excluded merely because they concern methods internal to the implementation.\n- Identical local performance does not establish overall equivalence. Relations, conditions, and the scope of comparison are constrained by the provisions of Grounds.\n- Openness does not reject an implementation merely because it already exists or is conventionally used. Relevant reasons may still give it priority.", + "declarations": [ + "CoreReader.Choice.singleFeasible", + "CoreReader.Choice.localNotGlobal", + "CoreReader.Choice.internalReasons", + "CoreReader.Choice.openNotEquivalent" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Concrete cases have one feasible candidate, unequal implementations, local agreement with wider difference and four eligible internal reasons. A cheap wrong-output method shows eligibility alone is insufficient. These results concern selected candidates and contracts, not all methods." + }, + { + "id": "organon.relationships", + "unit": "organon.relationships", + "clause": null, + "excerpt": "\n", + "declarations": [], + "kernel": "not_checked", + "fidelity": "not_applicable", + "status": "not_applicable", + "reason": "Structural heading without substantive direct-body content; no theorem is assigned." + }, + { + "id": "organon.relationships.roles.p1", + "unit": "organon.relationships.roles", + "clause": "p1", + "excerpt": "The charter states the generative orientation, the consistency constraint, and reflexive application. Grounds specifies support requirements for judgments and includes an additional commitment concerning implementation choices. Both parts belong to the core and constrain one another. Their placement neither makes Grounds a deduction from the charter nor gives the charter priority over it. Each commitment needs its own reasons.", + "declarations": [ + "CoreReader.Integration.jointWitness", + "CoreReader.Logic.consistentFalse", + "CoreReader.Logic.consistentIncomplete", + "CoreReader.Choice.generalGroundsNotChoice", + "CoreReader.Integration.revisionKeepsConsistency", + "CoreReader.Integration.ownCapabilityGrounded", + "CoreReader.Integration.groundsSelfAssessment", + "CoreReader.Integration.existingPhilosophyNotPrivileged", + "CoreReader.Agency.generationNotReflexivity", + "CoreReader.Integration.charterNotGrounds", + "CoreReader.Integration.applicationRetainsDuties", + "CoreReader.Integration.reasonsBelongToCommitments", + "CoreReader.Integration.applicationVariation" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "One shared model combines the charter and Grounds and assigns five commitments distinct operational reasons, limits and live criticism. Specified nonentailments prevent chapter order from doing logical work; neither the universal adoption nor ultimate justification of all commitments follows." + }, + { + "id": "organon.relationships.roles.p2", + "unit": "organon.relationships.roles", + "clause": "p2", + "excerpt": "Internal Consistency concerns whether simultaneously held judgments can hold together; Grounds concerns whether and how far a claim is supported. A conclusion may fail to conflict with its assumptions without being supported by them. Self-Transcendence specifies a generative orientation and non-finality; neither establishes actual capability. Applications may supply objectives, values, and capability definitions; claims made under those objectives, values, and definitions remain subject to the relevant core provisions.", + "declarations": [ + "CoreReader.Integration.jointWitness", + "CoreReader.Logic.consistentFalse", + "CoreReader.Logic.consistentIncomplete", + "CoreReader.Choice.generalGroundsNotChoice", + "CoreReader.Integration.revisionKeepsConsistency", + "CoreReader.Integration.ownCapabilityGrounded", + "CoreReader.Integration.groundsSelfAssessment", + "CoreReader.Integration.existingPhilosophyNotPrivileged", + "CoreReader.Agency.generationNotReflexivity", + "CoreReader.Integration.charterNotGrounds", + "CoreReader.Integration.applicationRetainsDuties", + "CoreReader.Integration.reasonsBelongToCommitments", + "CoreReader.Integration.applicationVariation" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Consistency/support and orientation/capability remain separate; changing an application objective changes its actual claim and can defeat retained evidence. Universal application compliance is only an assumed conditional interface, not an achieved fact." + }, + { + "id": "organon.relationships.roles.p3", + "unit": "organon.relationships.roles", + "clause": "p3", + "excerpt": "Self-Transcendence does not substitute for Reflexivity: keeping existing forms open to being surpassed differs from applying relevant principles to the system and to their own formation, application, and revision. Reflexivity extends these requirements to the system and to the formation, application, and revision of its principles. The grounds and limits of the Grounds provisions must themselves be articulable. The system’s own capability claims remain subject to assessment, and this philosophy’s existing form cannot gain priority merely from its established status. Such mutual application provides no self-proof and does not remove conditions of application.", + "declarations": [ + "CoreReader.Integration.jointWitness", + "CoreReader.Logic.consistentFalse", + "CoreReader.Logic.consistentIncomplete", + "CoreReader.Choice.generalGroundsNotChoice", + "CoreReader.Integration.revisionKeepsConsistency", + "CoreReader.Integration.ownCapabilityGrounded", + "CoreReader.Integration.groundsSelfAssessment", + "CoreReader.Integration.existingPhilosophyNotPrivileged", + "CoreReader.Agency.generationNotReflexivity", + "CoreReader.Integration.charterNotGrounds", + "CoreReader.Integration.applicationRetainsDuties", + "CoreReader.Integration.reasonsBelongToCommitments", + "CoreReader.Integration.applicationVariation" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "Contentful self-application, exact own-capability assessment, the general Grounds provision and the same current philosophy method are linked in the model. Their checked coexistence supplies no self-proof, real execution guarantee or unconditional applicability." + }, + { + "id": "organon.relationships.terms.p1", + "unit": "organon.relationships.terms", + "clause": "p1", + "excerpt": "| Term | Meaning in this philosophy |\n| --- | --- |\n| Existing form | The system’s current organization, methods, and principles, not only its appearance or artifacts. |\n| Assessment | Examination of reasons, applicability, and observed performance; not limited to executable tests. |", + "declarations": [ + "CoreReader.Agency.revisabilityCovers", + "CoreReader.Agency.revisionWithoutProgress", + "CoreReader.Evidence.nonExecutableAssessment" + ], + "kernel": "passed", + "fidelity": "partial", + "status": "limited", + "reason": "FormKind includes organization, methods and principles, and an inferential assessment has no executable-test requirement. These representations illustrate the terms without exhaustively defining every existing form or every non-test assessment." + } + ] +} diff --git a/lean/philosophy/overview.md b/lean/philosophy/overview.md new file mode 100644 index 0000000..a53a9d6 --- /dev/null +++ b/lean/philosophy/overview.md @@ -0,0 +1,1158 @@ +# Philosophy and Lean: claim overview + +This reader follows 28 frozen targets. Target acceptance, Lean checking and source fidelity are separate judgments. Defining a duty does not establish its fulfillment; a finite model does not establish universal real-world correctness. The tracing appendix retains all 33 source paragraphs and two empty headings. + +`accepted` records acceptance of a target within its stated scope; `limited` retains a bounded formal correspondence for a source paragraph; `incomplete` retains material without a complete source proof. Lean `passed` reports checking of registered declarations; checking a normative interface is not fulfillment of its duty. + +[Other granularity](details.md) · [Frozen targets](targets.json) · [Review and exposure record](reviews/README.md) · [Actual declaration types](evidence/declaration-types.json) + +| Target | Claim | Kind | Target review | +| --- | --- | --- | --- | +| [T01](#t01) | Authority and boundaries | boundary | accepted | +| [T02](#t02) | A shared nonempty model | satisfiability | accepted | +| [T03](#t03) | Generative commitment | specification | accepted | +| [T04](#t04) | Permission does not supply valuation | nonentailment | accepted | +| [T05](#t05) | Revisability and progress | theorem | accepted | +| [T06](#t06) | Generation has limits | nonentailment | accepted | +| [T07](#t07) | Achievement needs matching grounds | theorem | accepted | +| [T08](#t08) | Whole-theory consistency | theorem | accepted | +| [T09](#t09) | Revision and context changes | nonentailment | accepted | +| [T10](#t10) | Changes must be acknowledged | theorem | accepted | +| [T11](#t11) | Tension and contradiction | nonentailment | accepted | +| [T12](#t12) | Consistency is not truth or coverage | nonentailment | accepted | +| [T13](#t13) | Reflexive work with actual inquiry and reasons | specification | accepted | +| [T14](#t14) | Self-application is not self-proof | nonentailment | accepted | +| [T15](#t15) | Support, strength and scope | theorem | accepted | +| [T16](#t16) | All applicable aspects retain duties | theorem | accepted | +| [T17](#t17) | Articulation, repetition and assertion are insufficient | nonentailment | accepted | +| [T18](#t18) | Adopted value positions and joint reasons | satisfiability | accepted | +| [T19](#t19) | Local evidence and omitted differences | nonentailment | accepted | +| [T20](#t20) | Observation, reproduction and stability | satisfiability | accepted | +| [T21](#t21) | Capability contracts and external assessment | nonentailment | accepted | +| [T22](#t22) | Relevant implementation reasons | theorem | accepted | +| [T23](#t23) | An accurate assessment does not enforce the extra choice norm | nonentailment | accepted | +| [T24](#t24) | Openness does not imply equivalence or plurality | nonentailment | accepted | +| [T25](#t25) | Mutual application in one system | theorem | accepted | +| [T26](#t26) | Distinct commitments and their combination | nonentailment | accepted | +| [T27](#t27) | Application duties and individual reasons | theorem | accepted | +| [T28](#t28) | Assessment without observation tests | satisfiability | accepted | + + +## T01 · Authority and boundaries + +The adopted English source, including its meanings, applicability and limits, remains the authority against which this formalization is compared. + +**Premises and representation:** This entry records the selected source and documentary boundary; it has no required Lean declaration. + +**Proof or check:** The target catalog records the source units and their boundary status. There is no mathematical derivation of the authority or adoption of the philosophy. + +**Limits:** Source correspondence and acceptance of a philosophical position are separate from kernel checking. Neither the catalog nor the proofs establish universal philosophical correctness. + +**State:** accepted (boundary). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.preamble#p1](#source-organon-preamble-p1), [organon.preamble#p2](#source-organon-preamble-p2), [organon.charter.overview#p1](#source-organon-charter-overview-p1), [organon.charter.overview#p2](#source-organon-charter-overview-p2), [organon.charter.overview#p3](#source-organon-charter-overview-p3) + +[Declarations, proof and line explanations](details.md#t01) + + + +## T02 · A shared nonempty model + +One explicitly inhabited System and World jointly carry the charter, its own supported output capability, relevant implementation choice, and grounds for each of five represented commitments. + +**Premises and representation:** The witness is actualSystem at actual = (identity, apply). The world type independently varies two implementations and two governance modes. Its context includes the system theory, observation assumptions and application scope; the contracts and assessment adapters are explicit model choices. + +**Proof or check:** jointWitness supplies that same pair throughout, using actualAdmissible, charterChecked, ownCapabilityGrounded, identityJustified and reasonsBelongToCommitments. The existential conclusion also identifies the witnesses by equality. + +**Limits:** This proves coexistence in the disclosed application model, not correctness of every possible system or independent validation of the adopted normative criteria. + +**State:** accepted (satisfiability). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.preamble#p1](#source-organon-preamble-p1), [organon.preamble#p2](#source-organon-preamble-p2), [organon.charter.overview#p2](#source-organon-charter-overview-p2), [organon.charter.overview#p3](#source-organon-charter-overview-p3), [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +[Declarations, proof and line explanations](details.md#t02) + + + +## T03 · Generative commitment + +Generative is defined as valuing expanded understanding and construction, together with revisability of every form that the policy treats as current. + +**Premises and representation:** The parameter is a Policy with worthPursuing, current and revisable predicates. The revisability clause applies to forms satisfying current; permitsVersion is a separate field. + +**Proof or check:** The declaration is a conjunction defining an obligation. Later concrete policies instantiate it; the definition itself is not a theorem that any agent satisfies it. + +**Limits:** The representation does not establish that the valued aim is ultimately good, that every permitted edit advances it, or that a current form must be changed immediately. + +**State:** accepted (specification). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.overview#p2](#source-organon-charter-overview-p2), [organon.charter.overview#p3](#source-organon-charter-overview-p3), [organon.charter.self-transcendence#p1](#source-organon-charter-self-transcendence-p1), [organon.charter.self-transcendence.orientation#p1](#source-organon-charter-self-transcendence-orientation-p1), [organon.charter.self-transcendence.non-finality#p1](#source-organon-charter-self-transcendence-non-finality-p1), [organon.charter.self-transcendence.limits#p1](#source-organon-charter-self-transcendence-limits-p1), [organon.charter.self-transcendence.limits#p2](#source-organon-charter-self-transcendence-limits-p2) + +[Declarations, proof and line explanations](details.md#t03) + + + +## T04 · Permission does not supply valuation + +Permission to change a version can hold while the generative valuation is absent. + +**Premises and representation:** The concrete neutral policy permits versions but assigns no worth to the expansion aim; Generative retains its valuation conjunct. + +**Proof or check:** permissionNotValuation evaluates the permission and unfolds Generative to refute its missing valuation clause. + +**Limits:** This is a counterexample to an implication between represented predicates; it does not justify either policy or classify all real permissions. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.self-transcendence.orientation#p1](#source-organon-charter-self-transcendence-orientation-p1) + +[Declarations, proof and line explanations](details.md#t04) + + + +## T05 · Revisability and progress + +Generative policies leave current forms revisable, while the concrete open policy can remain generative through a trace with no capability expansion. + +**Premises and representation:** The general revisability result assumes Generative and that the selected form is current. The example covers organization, method, principle, appearance and artifact, and uses a constant base-state trace. + +**Proof or check:** revisabilityCovers projects the revisability obligation. revisionWithoutProgress instantiates the open policy and shows that adjacent identical states contain no newly understood or constructed operation. + +**Limits:** Revisability and permission are not evidence that revision occurred or improved capability. The result is not a universal claim that revision never yields progress. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.self-transcendence.non-finality#p1](#source-organon-charter-self-transcendence-non-finality-p1), [organon.relationships.terms#p1](#source-organon-relationships-terms-p1) + +[Declarations, proof and line explanations](details.md#t05) + + + +## T06 · Generation has limits + +One generating system illustrates non-progressing inflation, dependence on three external resources, a justified stable action within its application budget, and a false expansion report about its own actual transition. + +**Premises and representation:** The system combines openPolicy, baseState, assistedExecution, required copy capability and an inventory budget of 1. inflatedState duplicates artifacts, abstraction layers and vocabulary without adding understood or constructed operations. Its report names this owner, before/after states and successor at input 0 with expected output 1. + +**Proof or check:** generationLimits evaluates the same system interface: available resources yield 6, deleting any of experience/knowledge/collaborator or all three yields none; the stable action preserves the current state, required capability and budget. Inflation exceeds that budget, and the system-generated report fails because its claimed new operation is absent. + +**Limits:** The resource dependence and budget are declared application conditions. These content-bearing examples do not establish universal laws of learning, mandatory austerity, or the adequacy of any real expansion report. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.self-transcendence.limits#p1](#source-organon-charter-self-transcendence-limits-p1), [organon.charter.self-transcendence.limits#p2](#source-organon-charter-self-transcendence-limits-p2) + +[Declarations, proof and line explanations](details.md#t06) + + + +## T07 · Achievement needs matching grounds + +AchievementAccountability requires Grounds for the very achievement claim. Given support and an actual evidence-compatible world, that claim holds there; a concrete expansion case has matching grounds, while its positive self-report alone does not support it. + +**Premises and representation:** The general theorem takes a world type, achievement predicate, records, actual world, Compatible records actual and Supports records achievement. Separately, the concrete alternatives share baseState and input 0: extend adds successor, whereas inflate only duplicates content. + +**Proof or check:** achievementNeedsSupport applies support to the compatible actual world and includes ConcreteAchievementExample. Actual after-state performance distinguishes extend and supplies canonical matched grounds; the positive report is also compatible with inflate, where Expanded before after is false. + +**Limits:** The definition expresses normative accountability without making observation universally mandatory. The theorem assumes support in its general branch and does not infer it from an arbitrary assertion or prove real achievement from record labels. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.self-transcendence.limits#p1](#source-organon-charter-self-transcendence-limits-p1), [organon.charter.self-transcendence.limits#p2](#source-organon-charter-self-transcendence-limits-p2), [organon.grounds#p1](#source-organon-grounds-p1), [organon.grounds.capabilities#p1](#source-organon-grounds-capabilities-p1), [organon.grounds.capabilities#p2](#source-organon-grounds-capabilities-p2) + +[Declarations, proof and line explanations](details.md#t07) + + + +## T08 · Whole-theory consistency + +An inhabited common theory and context cannot semantically yield both answers to one question. Separately satisfiable assumptions may nevertheless become inconsistent when held together. + +**Premises and representation:** consequenceConsistency quantifies over world and question types, a held theory and one Context, and assumes an Admissible world satisfying the entire held theory, contextual assumptions and scope simultaneously. + +**Proof or check:** The general proof evaluates both consequences at the same witness to obtain a contradiction. jointConflict combines P, P implies Q, and not Q: each singleton has a model, but their union has none. + +**Limits:** The nonempty witness is essential to this semantic consistency argument. Pairwise or isolated checks do not establish joint satisfiability, and no empirical truth of the assumptions is inferred. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency#p1](#source-organon-charter-consistency-p1) + +[Declarations, proof and line explanations](details.md#t08) + + + +## T09 · Revision and context changes + +Different time-indexed theories can give opposite answers without either being unsatisfiable; changing assumptions, question meaning or scope can likewise change the answer. + +**Premises and representation:** The examples fix explicit Boolean interpretations and separately inhabited contexts. The positive and negative answers belong to different theory slices or contexts, not one unchanged conjunction. + +**Proof or check:** revisionCanReverse constructs the two slices and shows their simultaneous union fails. contextDifferences separately changes the assumptions, meaning and scope components while evaluating the corresponding consequences. + +**Limits:** These examples distinguish revision and contextual difference from simultaneous contradiction. They do not establish that a particular revision is warranted, truthful or progressive. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency.meaning#p1](#source-organon-charter-consistency-meaning-p1), [organon.charter.consistency.meaning#p2](#source-organon-charter-consistency-meaning-p2) + +[Declarations, proof and line explanations](details.md#t09) + + + +## T10 · Changes must be acknowledged + +Under TruthfulReport, a semantic change or a different revision identity requires a positive change report. Reordering the same held content does not change that content, and honest reporting does not make revised assumptions true. + +**Premises and representation:** The general result assumes two snapshots, a report flag, the TruthfulReport obligation and an actual semantic-or-identity change. SameContent compares held claims, contextual assumptions, meaning and scope extensionally. + +**Proof or check:** semanticChangeMustBeReported applies the assumed reporting obligation; representationOrderIrrelevant proves union commutativity. hiddenContextChangeRejected evaluates separate hidden assumption, meaning, scope and identity changes, and an acknowledged revision false at the designated actual world. + +**Limits:** The reporting rule is adopted, not derived from logic alone. The cases do not decide every possible form of revision or certify the quality of an acknowledged change. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency.meaning#p1](#source-organon-charter-consistency-meaning-p1), [organon.charter.consistency.meaning#p2](#source-organon-charter-consistency-meaning-p2) + +[Declarations, proof and line explanations](details.md#t10) + + + +## T11 · Tension and contradiction + +Distinct resource objectives can be jointly satisfiable. In contrast, positive and negative consequences for the same question in the same theory and context violate Consistent. + +**Premises and representation:** The tension example uses the predicates 4 ≤ budget and budget ≤ 6. conflictRequiresChange takes an arbitrary theory, context and question together with both opposed consequences. + +**Proof or check:** tensionWithoutContradiction supplies budget 5 and proves the predicates are different. conflictRequiresChange applies the definition of Consistent to the given pair of consequences. + +**Limits:** The latter theorem proves inconsistency; it neither constructs a repair nor determines which commitment should change. The resource example does not classify every practical tension. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency.limits#p1](#source-organon-charter-consistency-limits-p1) + +[Declarations, proof and line explanations](details.md#t11) + + + +## T12 · Consistency is not truth or coverage + +Satisfiability does not establish truth at a designated actual world, and a satisfiable theory can leave an explicit question undecided. + +**Premises and representation:** The examples use Boolean worlds: the singleton assumption that the world is true, and the empty theory with the question whether the world is true. + +**Proof or check:** consistentFalse supplies the true model and refutes the singleton assumption at false. consistentIncomplete supplies models of the empty theory and uses opposite worlds to refute entailment of each answer. + +**Limits:** These are explicit satisfiability and non-entailment results, not an empirical classification of actual beliefs or a general incompleteness theorem for formal arithmetic. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.consistency.limits#p1](#source-organon-charter-consistency-limits-p1), [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +[Declarations, proof and line explanations](details.md#t12) + + + +## T13 · Reflexive work with actual inquiry and reasons + +Reflexive requires coherent principle registration and valid applications to every owned subject where each registered principle actually applies. A valid application carries the principle’s inquiry, reasons, limits and a result satisfying its independently specified meaning. + +**Premises and representation:** The parameters are an owner, registered principles and work records. ValidApplication binds principle identity, subject, generation/assessment activity, resolved target method, exact inquiry, nonempty target-matched reasons, limits and semantic result; applicability and ownership are explicit conditions. + +**Proof or check:** This declaration defines the obligation. The shared model’s completeOwnWork_reflexive supplies content-checked work for the system, two principles and their formation/application/revision processes; the evaluator uses actual samples, declared scope and counterexamples, and accepts an insufficient verdict for revision. + +**Limits:** Generation is required only for generationEligible subjects; application-phase processes receive assessment in this model. Valid work, including a negative verdict, does not prove the assessed principles correct or exhaust real reflexive inquiry. + +**State:** accepted (specification). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.reflexivity#p1](#source-organon-charter-reflexivity-p1), [organon.charter.reflexivity.meaning#p1](#source-organon-charter-reflexivity-meaning-p1), [organon.charter.reflexivity.limits#p1](#source-organon-charter-reflexivity-limits-p1) + +[Declarations, proof and line explanations](details.md#t13) + + + +## T14 · Self-application is not self-proof + +An applicable owned subject cannot be omitted from a Reflexive work set, while inapplicable subjects need not receive work. Passing a selected self-test and generating a revision oneself do not establish universal correctness. + +**Premises and representation:** noSelfExemption assumes Reflexive, principle membership, matching owner and applicability. applicabilityRetained preserves those conditions. The counterexamples use the same arithmetic principle across test and claim, and a GeneratingProcess with owner 17, a false prior, seed 0 and its actual output revision. + +**Proof or check:** The general proofs extract valid work and its scope. The arithmetic principle passes at 1 but fails at 0. selfOriginDoesNotSupport includes the actual producer/prior/output relationship: its revision passes the input-0 observation but fails at 1, giving an evidence-compatible counterworld to allTrue. + +**Limits:** Scope coverage is weaker than full valid Reflexive work. The examples reject self-certification implications; they do not show all self-tests or self-generated revisions are worthless. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.charter.reflexivity.limits#p1](#source-organon-charter-reflexivity-limits-p1) + +[Declarations, proof and line explanations](details.md#t14) + + + +## T15 · Support, strength and scope + +Grounds binds the same claim to all actually applicable represented facets and their actual articulations. With evidence fixed, support is preserved when the conclusion is weakened or its quantified scope is restricted. + +**Premises and representation:** Grounds takes a claim, facet-indexed articulations, an actualApplicable predicate and a nonempty list covering that predicate. Each listed facet must have that claim, be articulated, match its actual premises/reasons/limits, and pass its disclosed assessment adapter. supportWeakening assumes Supports records p and pointwise p implies q; scopeRestriction assumes a supported broad-domain conclusion and inclusion of the narrower domain. + +**Proof or check:** The obligation is defined, not universally proved. Both preservation proofs apply the original support at the same compatible world and then the implication or scope inclusion. The empirical, inferential and value articulation adapters expose the corresponding real record compatibility, theory or option-indexed reasons. + +**Limits:** These theorems weaken conclusions, not evidence. FacetDischarged and the canonical articulation are application-specific semantic adapters, not a complete definition or proof of all source-level empirical or value adequacy. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds#p1](#source-organon-grounds-p1), [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +[Declarations, proof and line explanations](details.md#t15) + + + +## T16 · All applicable aspects retain duties + +Duties for two sets of applicable aspects combine exactly as their union, and an added label cannot waive them. A claim with empirical and value aspects can pass the represented empirical check while failing its value procedure. + +**Premises and representation:** assessmentUnion uses two actual facet predicates; labelsCannotWaive uses a label that does not alter those predicates or FacetDischarged. The mixed switch example concerns the same selected-on claim: an actual observation assesses the selection fact, while adoption also invokes the value procedure. + +**Proof or check:** The general proofs distribute universal obligations over disjunction and unfold the label wrapper. mixedMissingResponsibility combines discharged switch evidence with an unsupportedPosition whose empty reason list fails ValueProcedure. + +**Limits:** The empty-list failure establishes missing recorded procedural responsibility, not that no adequate value reason could exist. Which aspects actually apply remains an explicit input requiring source-faithful judgment. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +[Declarations, proof and line explanations](details.md#t16) + + + +## T17 · Articulation, repetition and assertion are insufficient + +Articulation, repeated irrelevant observations, compatibility with a theory and self-assertion each fail to establish the stronger claim in explicit counterexamples. A nonempty announcement can coexist with a real budget violation. + +**Premises and representation:** The examples distinguish observable temperature from another output and observed selection from available budget. The budget model evaluates the same adopted option with cost 3; starting assumptions fix selection without guaranteeing budget. A true activation announcement is compatible with budget 0. + +**Proof or check:** articulationNotSupport supplies a nonempty but uninformative articulation. measurementRepeatNotSupport retains counterworlds after repeating the same actual tests. compatibilityNotEntailment contrasts an existing joint model with a failed universal consequence. selfAssertionNotReason includes both missing reasons and the nonempty announcement case whose joint adoption is possible but whose actual cost exceeds its budget. + +**Limits:** These are failures for specified claims and grounds, not a dismissal of articulation, repetition or compatibility. The missing-reasons branch is procedural; the budget branch additionally gives a substantive counterexample within its chosen objective/constraint adapter. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +[Declarations, proof and line explanations](details.md#t17) + + + +## T18 · Adopted value positions and joint reasons + +A value-assessment procedure can be fulfilled from a satisfiable adopted starting position that is not entailed by the empty theory. Joint reasons can support the adopted option’s actual consequence even when neither reason alone suffices. + +**Premises and representation:** ValueProcedure requires nonempty option-indexed reasons; one world satisfying starting assumptions, limits, adoption and all reasons together; joint reason support for that option’s objective and constraints within starting/limits; and a nonempty response to relevant criticism. These are the declared option–outcome assessment conditions. + +**Proof or check:** valueWithoutSelfProof constructs the beneficial on option, shows its starting theory satisfiable and its commitment not entailed by emptyTheory, and rejects opposite, contradictory and impossible adoption variants. heterogeneousReasons includes actual empirical/inferential/value cases and a benefit-4/cost-at-most-3 example: the reasons together pass, but worlds (4,5) and (0,3) defeat each reason separately. + +**Limits:** The procedure checks a disclosed application adapter, not ultimate value justification or a mandatory deductive form for every value reason. A response string is recorded engagement, not proof of a satisfactory reply; non-self-derived starting points are distinguished from inconsistent starts. + +**State:** accepted (satisfiability). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +[Declarations, proof and line explanations](details.md#t18) + + + +## T19 · Local evidence and omitted differences + +Agreement on the observed input can conceal disagreement elsewhere, so input-specific evidence does not support a universal claim. + +**Premises and representation:** Worlds are Boolean-valued functions on natural-number inputs. zeroRecord observes only that input 0 returns true; the compared functions are constant true and localGenerator 0. + +**Proof or check:** localNotUniversal retains localGenerator 0 as a record-compatible counterworld to allTrue. hiddenDifference proves agreement wherever n = 0 and evaluates the differing outputs at n = 1. + +**Limits:** The conclusion concerns the stated observation scope. It does not rule out justified generalization from additional premises or establish a general statistical inference rule. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.scope#p1](#source-organon-grounds-scope-p1), [organon.grounds.scope#p2](#source-organon-grounds-scope-p2), [organon.grounds.scope#p3](#source-organon-grounds-scope-p3) + +[Declarations, proof and line explanations](details.md#t19) + + + +## T20 · Observation, reproduction and stability + +One observation can support a bounded claim without repetition; a valid inferential assessment need not use observation at all. Record accuracy, reproduced conditions and stability of a conclusion are distinct, and different outcomes can preserve the same bound. + +**Premises and representation:** The observation concerns input 0 only. The non-observational facet assumes n = 2 and concludes n + 1 = 3. Trial explicitly separates setting, actualOutcome and recordedOutcome; Verified compares actual and recorded values, Reproduced compares settings, and Bounded means actualOutcome ≤ 2. + +**Proof or check:** singleObservation proves local support and refutes allTrue. noUniversalChain supplies a discharged arithmetic facet without observation. variableOutcomesStableBound uses actual outcomes 1 and 2 under setting 0; verificationReproductionStability supplies separate cases with changed settings, inaccurate records and an outcome above the bound. + +**Limits:** This is a finite possible-trial model, not a probability theorem, empirical reproducibility study or guarantee about future runs. It refutes a universally mandatory observation chain only within the represented assessment interfaces. + +**State:** accepted (satisfiability). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.scope#p1](#source-organon-grounds-scope-p1), [organon.grounds.scope#p2](#source-organon-grounds-scope-p2), [organon.grounds.scope#p3](#source-organon-grounds-scope-p3) + +[Declarations, proof and line explanations](details.md#t20) + + + +## T21 · Capability contracts and external assessment + +Correct outputs and an explanation contract are distinct for the same Process. Output-only and explanation-requiring applications have actual, scoped grounds; an external assessor can certify the former without the process providing an internal explanation. Duplicating inventory does not add represented operations. + +**Premises and representation:** OutputContract requires n + n for every natural input. ExplanationContract requires a provided Program whose evaluation equals that very process’s output at every input. processScope fixes the assessed process by equality; its canonical articulation and facet use that same scope and contract. ExternalCertificate is indexed by the actual process and distinguishes assessor 42 from assessed participant 7. + +**Proof or check:** Concrete evaluation proves both processes double their inputs; outputOnlyProcess has none, while explainedProcess supplies doubleInput. The same output-only process refutes the stronger full contract under its inhabited object scope. externalAssessment constructs the full output proof rather than assuming its truth; inventoryNotCapability proves available-operation membership unchanged by duplication. + +**Limits:** These arithmetic contracts are application choices, not a universal definition of capability or understanding. The explanation contract concerns an explicit certificate, not unobserved mental understanding; external participant identifiers do not establish real-world provenance. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.capabilities#p1](#source-organon-grounds-capabilities-p1), [organon.grounds.capabilities#p2](#source-organon-grounds-capabilities-p2) + +[Declarations, proof and line explanations](details.md#t21) + + + +## T22 · Relevant implementation reasons + +Status alone cannot satisfy the represented implementation-choice norm. An existing conventional implementation can satisfy it when its actual behavior supplies a relevant reason and it meets the requirements. + +**Premises and representation:** JustifiedChoice requires feasibility plus a listed Relevant reason. The adopted Relevant definition excludes status reasons and checks actual method content against requirements. The concrete identity application requires identity outputs, budget 1 and admits the output reason. + +**Proof or check:** statusOnlyFails unfolds the status branch for any requirements, implementation and status reason. conventionWithReason evaluates the conventional/established identity implementation and constructs its output-based justification. + +**Limits:** The exclusion is an explicitly adopted choice norm, not a value-neutral theorem. This case neither rejects all existing implementations nor proves the chosen requirements universally adequate. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.implementations#p1](#source-organon-grounds-implementations-p1), [organon.grounds.implementations#p2](#source-organon-grounds-implementations-p2) + +[Declarations, proof and line explanations](details.md#t22) + + + +## T23 · An accurate assessment does not enforce the extra choice norm + +Two independently specified choice policies complete the same accurate negative status-priority audit yet differ on the additional choice norm: the status-only policy fails and the output-reason policy passes. + +**Premises and representation:** Both policies select identity and share the true conventional/established facts, the exact question whether those facts entail identity priority, and report false. Only priorityReasons changes. GeneralAssessmentFulfilled records articulation and accurate completion of this audit; AdditionalChoiceNorm separately checks JustifiedChoice. + +**Proof or check:** generalGroundsNotChoice retains the status non-entailment countermodel and includes PolicyIndependenceExample. The successor interpretation satisfies the same status facts but refutes priority; statusOnlyFails and identityJustified then establish the opposed policy results without changing that audit. + +**Limits:** The result concerns fulfillment of the specified assessment procedure, not full philosophical Grounds. Continuing to prioritize unsupported status can also violate general support proportionality; this theorem does not claim otherwise or prove the choice norm independent of every core obligation. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.implementations#p1](#source-organon-grounds-implementations-p1), [organon.grounds.implementations#p2](#source-organon-grounds-implementations-p2), [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +[Declarations, proof and line explanations](details.md#t23) + + + +## T24 · Openness does not imply equivalence or plurality + +An open choice setting may have only one feasible represented candidate. Local agreement does not make implementations equivalent, and eligible internal-method reasons need not suffice for selection when a required output is wrong. + +**Premises and representation:** The candidate type contains identity and successor, evaluated against identity outputs and budget 1. Relevant internal reasons are selected by Requirements.values and checked for faithful explanation, applicability, cost or procedure. A separate cheap successor costs 1 but still returns n + 1. + +**Proof or check:** singleFeasible identifies the unique feasible candidate. localNotGlobal contrasts agreement at 0 with disagreement at 1. internalReasons validates four real reasons for identity and includes a cheap-but-wrong counterexample. openNotEquivalent retains justified identity choice while proving its output differs from successor. + +**Limits:** Uniqueness is relative to these two candidates and stated requirements. Relevance is not sufficient feasibility, and openness does not entail equal merit, mandatory plurality or rejection of the existing option. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.grounds.implementations.limits#p1](#source-organon-grounds-implementations-limits-p1) + +[Declarations, proof and line explanations](details.md#t24) + + + +## T25 · Mutual application in one system + +The shared system maintains consistency through an acknowledged revision, carries owned assessment work and grounds for its own capability, assesses its general grounds provision, and evaluates its current philosophical method using relevant proposal decisions rather than status. + +**Premises and representation:** The examples use actualSystem and actual. The revised theory adds the same method’s input-0 fact and changes revision identity. GroundsProvision quantifies over arbitrary represented claims and facet packages under apply/waive permissions. The current philosophy method shares the system’s principle form and governance mode and is assessed on two specified proposal inputs. + +**Proof or check:** revisionKeepsConsistency reuses the same admissible witness and rejects a false change report. ownCapabilityGrounded combines owned assessment work with matching output grounds. groundsSelfAssessment evaluates the general provision through the grounds commitment’s actual acceptance/rejection consequences and relevant criticism. existingPhilosophyNotPrivileged proves acceptance of the valid proposal, rejection of the cheap wrong one, status-only failure and output-based justification for this actual method. + +**Limits:** These are constructed results for one system. Owned assessment work and capability grounds are separately checked components, not a claim that one work record contains the entire capability proof. Classical decision definitions are mathematical devices; the value adapter does not establish ultimate justification of the philosophy. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +[Declarations, proof and line explanations](details.md#t25) + + + +## T26 · Distinct commitments and their combination + +Generative orientation alone does not ensure Reflexive work, and a charter-satisfying system can still present inadequate evidence for its own capability. A shared witness also shows the represented commitments can all be met together. + +**Premises and representation:** The first counterexample combines openPolicy with an empty work list despite an applicable system assessment. The second retains actualSystem, actual and its charter, but substitutes true cost-allowance evidence for the output-capability claim. jointWitness uses the matching capability evidence and complete owned work instead. + +**Proof or check:** generationNotReflexivity derives the missing applicable work from a supposed Reflexive proof. charterNotGrounds keeps a wrong-output world compatible with the cost record. jointWitness supplies one actual pair with admissibility, charter, capability duty, justified choice and each commitment’s grounds. + +**Limits:** These results establish the stated separations and coexistence, not complete pairwise logical independence of all commitments, a priority hierarchy, or automatic grounds for every charter-compliant claim. + +**State:** accepted (nonentailment). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +[Declarations, proof and line explanations](details.md#t26) + + + +## T27 · Application duties and individual reasons + +An application that satisfies the adopted ApplicationDuties retains Reflexive work and all actually applicable, correctly articulated grounds for its own contract claim. Each of the five shared commitments separately has matched value grounds, joint adoption and relevant criticism, while its waive variant fails the chosen procedure. In the registered variation, the same evidence still supports the identity contract but does not support the changed successor contract. + +**Premises and representation:** applicationRetainsDuties takes a System, World, Requirements, arbitrary contract, facet-indexed articulations, applicability predicate and facet list, and assumes ApplicationDuties for those exact parameters. reasonsBelongToCommitments takes one of generation, consistency, reflexivity, grounds or choice; each position shares the governance choice but has its own actual consequence, reasons, constraints and criticism. + +**Proof or check:** The application theorem projects the assumed obligation, including same-claim equality and FacetArticulated for every listed facet. The commitment theorem constructs canonical grounds and joint witnesses, checks nonvacuous criticism, and contrasts apply with waive using actual operation expansion, contradiction handling, self-test coverage, evidence acceptance and implementation decisions. The supplementary applicationVariation case holds the system and observation fixed: the identity contract has matching grounds, whereas the successor contract fails at actual input 0 and its attempted empirical facet is rejected. + +**Limits:** The general application result does not prove arbitrary applications comply. The five reasons belong to distinct commitment positions in one selected option/outcome adapter; their checks do not derive normative authority from facts or prove all possible value reasons deductively sufficient. + +**State:** accepted (theorem). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.relationships.roles#p1](#source-organon-relationships-roles-p1), [organon.relationships.roles#p2](#source-organon-relationships-roles-p2), [organon.relationships.roles#p3](#source-organon-relationships-roles-p3) + +[Declarations, proof and line explanations](details.md#t27) + + + +## T28 · Assessment without observation tests + +A matched inferential assessment can have Grounds without an observation test, while a separately applicable empirical facet still uses observations. + +**Premises and representation:** The inferential facet explicitly assumes n = 2 and concludes n + 1 = 3, with canonical articulation and a nonempty model. The empirical comparison is the actual switch observation facet; usesObservation classifies the facet form. + +**Proof or check:** nonExecutableAssessment builds Grounds for the arithmetic claim from its satisfiable premise and semantic entailment, proves usesObservation is false there, and includes the discharged empirical switch facet with usesObservation true. + +**Limits:** The theorem separates assessment from observational testing; it does not prove this arithmetic reasoning uncomputable, classify every non-executable method or waive applicable empirical responsibilities. + +**State:** accepted (satisfiability). This is the review of this frozen target, not an upgrade to a complete proof of its source paragraphs. + +**Sources:** [organon.relationships.terms#p1](#source-organon-relationships-terms-p1), [organon.grounds.assessment#p1](#source-organon-grounds-assessment-p1), [organon.grounds.assessment#p2](#source-organon-grounds-assessment-p2), [organon.grounds.assessment#p3](#source-organon-grounds-assessment-p3) + +[Declarations, proof and line explanations](details.md#t28) + + +## Source tracing appendix + + + + +### `organon.preamble#p1` + +```text +This is the authoritative statement of Organon’s philosophy. It expresses adopted commitments, not factual assertions about every system or a proof of universal correctness. +``` + +State: **not_applicable**; Lean: passed; fidelity: not_applicable. + + + +This paragraph is cited as authority and interpretive context. The linked declarations do not prove the meta-level statement; its conditions remain in force. + +This declares textual authority and adopted-commitment scope, not a mathematical proposition about all systems. The review retains this boundary without manufacturing a Lean theorem of authority. + +Related targets: [T01](#t01), [T02](#t02). + + + + + + +### `organon.preamble#p2` + +```text +The quoted provisions, their meanings, and their conditions of application form the core. The charter and Grounds constrain one another; their grouping establishes neither a deductive hierarchy nor an order of priority. [Rationale](rationale/README.md) supplies arguments and cases without adding obligations to this core. Skills are revisable applications under the repository’s stated objectives and constraints, not part of the philosophical commitments themselves. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The shared model exhibits compatible constraints without a chapter-priority inference. Authority of meanings and limits, the role of Rationale and revisability of actual skills remain textual commitments outside this finite witness. + +Related targets: [T01](#t01), [T02](#t02). + + + + + + +### `organon.charter` + +```text + + +``` + +State: **not_applicable**; Lean: not_checked; fidelity: not_applicable. + +Structural heading without substantive direct-body content; no theorem is assigned. + + + + + + +### `organon.charter.overview#p1` + +```text +**Self-Transcendence · Internal Consistency · Reflexivity** +``` + +State: **not_applicable**; Lean: not_checked; fidelity: not_applicable. + +This is a structural list of three headings. It organizes substantive provisions and requires no fabricated theorem. + +Related targets: [T01](#t01). + + + + + + +### `organon.charter.overview#p2` + +```text +> A system is intrinsically oriented toward expanding what it can understand and construct. It brings itself and its principles within the scope of generation and assessment, with internal consistency constraining this process. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +jointWitness combines valued expansion, revisability, contextual consistency and contentful owned principle work in one inhabited system. It proves model satisfiability, not actual compliance by arbitrary systems. + +Related targets: [T01](#t01), [T02](#t02), [T03](#t03). + + + + + + +### `organon.charter.overview#p3` + +```text +The overview connects three distinct requirements: self-transcendence establishes a generative orientation and refuses to treat existing forms as final, internal consistency constrains judgments held simultaneously, and reflexivity brings the system and its principles within the scope of their own generation and assessment. The provisions below specify the conditions for each. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The three requirements remain distinct predicates with a shared example and specific nonentailments. Their interpretation as philosophical obligations and their full conditions in arbitrary applications are not derived from the example. + +Related targets: [T01](#t01), [T02](#t02), [T03](#t03). + + + + + + +### `organon.charter.self-transcendence#p1` + +```text +> A system is intrinsically oriented toward expanding what it can understand and construct. It does not regard any existing form as the endpoint of generation. +``` + +State: **incomplete**; Lean: passed; fidelity: partial. + +Generative specifies valuation and revisability of current forms. The finite tags and state examples do not characterize every form of understanding, construction or intrinsic orientation. + +Related targets: [T03](#t03). + + + + + + +### `organon.charter.self-transcendence.orientation#p1` + +```text +A commitment to keeping generative possibilities open is distinct from valuing their expansion. A system has an intrinsic orientation when it regards that expansion as worth pursuing. Merely permitting change does not fully express this orientation. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The neutral-policy counterexample separates permission for distinct versions from the adopted valuation predicate. It does not establish what every real system values or justify the adopted value universally. + +Related targets: [T03](#t03), [T04](#t04). + + + + + + +### `organon.charter.self-transcendence.non-finality#p1` + +```text +Refusing to regard an existing form as an endpoint keeps it open to being surpassed. “Existing form” includes a system’s current organization, methods, and principles, not only its appearance or artifacts. These remain within the scope of possible change; their revisability does not guarantee actual progress. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +All five represented form kinds, including organization, method and principle, fall under conditional revisability; a constant trace shows no progress guarantee. The chosen representation is not an exhaustive ontology or an executed revision. + +Related targets: [T03](#t03), [T05](#t05). + + + + + + +### `organon.charter.self-transcendence.limits#p1` + +```text +Whether progress has actually occurred remains a separate judgment. Having the orientation does not guarantee progress. Progress cannot be established merely by an increase in the number of artifacts, levels of abstraction, or terms. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The same before/after states increase inventory, abstraction and vocabulary without adding represented capabilities. Actual performance records can distinguish a genuine extension in a two-case world; empirical reliability beyond that world is not proved. + +Related targets: [T03](#t03), [T06](#t06), [T07](#t07). + + + + + + +### `organon.charter.self-transcendence.limits#p2` + +```text +- “Intrinsic orientation” expresses Organon’s philosophical commitment; it does not assert that all systems in fact develop autonomously. +- Self-transcendence does not imply independence from external experience, knowledge, or collaboration, nor does it guarantee autonomous execution or self-improvement. +- Refusing to regard an existing form as an endpoint does not require every action to produce change. Justified stability can coexist with a generative orientation. +- Whether transcendence expands what can be understood and constructed requires discernible grounds; a system’s own claim of generation does not establish actual achievement. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Bound execution exhibits separate external dependencies, grounded stability, a nonimproving trace and a refuted owned announcement. These are finite compatibility and failure examples; philosophical adoption and real autonomous development remain outside their conclusions. + +Related targets: [T03](#t03), [T06](#t06), [T07](#t07). + + + + + + +### `organon.charter.consistency#p1` + +```text +> The principles and judgments a system holds simultaneously, together with their implications, must not yield contradictory judgments on the same question under the same assumptions, meanings of terms, and scope of application. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The general semantic theorem prevents opposite consequences under one theory/context when an admissible world exists. Existence of such a world, choice of questions and interpretation of held judgments are explicit modeling conditions, not guaranteed for reality. + +Related targets: [T08](#t08). + + + + + + +### `organon.charter.consistency.meaning#p1` + +```text +“Held simultaneously” specifies which principles, judgments, and implications must hold together. Revision may withdraw an earlier judgment; old and new principles need not remain compatible forever. When a change has occurred, that change cannot be represented as though it had not occurred. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Concrete retraction slices can reverse judgments, and a conditional reporting specification disallows concealing recognized change. No automatic detector, adequate report generator or real revision history is established. + +Related targets: [T09](#t09), [T10](#t10). + + + + + + +### `organon.charter.consistency.meaning#p2` + +```text +“The same assumptions, meanings of terms, and scope of application” specifies the basis for comparing judgments. Divergent judgments under different conditions do not automatically constitute contradictions. Nor can unacknowledged changes in assumptions, meanings, or scope be used to conceal an existing contradiction. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Separate assumption, meaning and scope changes admit different judgments; hidden changes fail the adopted report condition. This covers explicit semantic models, not every practical ambiguity or method of concealment. + +Related targets: [T09](#t09), [T10](#t10). + + + + + + +### `organon.charter.consistency.limits#p1` + +```text +- Tension between different assessments or values does not directly constitute a contradiction. Revision or qualification is needed when they require incompatible conclusions under the same conditions. +- Internal consistency is not correctness or sufficiency. A set of principles may be internally consistent while relying on false assumptions or neglecting important questions. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Finite witnesses distinguish tension from contradiction and consistency from truth or completeness. Refusing to retain a demonstrated conflict is a conditional consequence of an adopted consistency requirement, not an implemented revision strategy. + +Related targets: [T11](#t11), [T12](#t12). + + + + + + +### `organon.charter.reflexivity#p1` + +```text +> A system’s principles of generation and assessment also apply to the system itself and to the formation, application, and revision of those principles. +``` + +State: **incomplete**; Lean: passed; fidelity: partial. + +Reflexive quantifies applicable owned rules and subjects, with coherent keys and meaningful application records. The concrete rule set has generation and assessment work but does not cover every possible real principle. + +Related targets: [T13](#t13). + + + + + + +### `organon.charter.reflexivity.meaning#p1` + +```text +Reflexivity encompasses both the system itself and its principles. Assessment concerns not only whether the system conforms to its principles, but also how those principles are formed, where they apply, and why they may need revision. The formation and revision of principles thus also become objects of generation and assessment. +``` + +State: **incomplete**; Lean: passed; fidelity: partial. + +The revised module models formation purposes, requested applicability scopes and revision counterexamples with actual evaluation and generation outcomes. These finite inquiry contracts do not establish the correctness or completeness of every assessment methodology. + +Related targets: [T13](#t13). + + + + + + +### `organon.charter.reflexivity.limits#p1` + +```text +- Applying principles equally retains their conditions of application. When the relevant conditions hold, being the system itself is not a basis for exemption. Nor does the requirement of reflexivity establish that every principle can be applied to itself without examining its applicability. +- Self-application does not constitute self-proof. Subjecting a principle to its own assessment does not thereby establish its correctness. +- That a revision is produced by the system itself does not give it sufficient grounds. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Applicability is retained, self-exemption fails where conditions hold, and finite self-tests plus a produced revision fail to establish universal support. The owned records and source identities are mathematical objects, not authenticated execution histories. + +Related targets: [T13](#t13), [T14](#t14). + + + + + + +### `organon.grounds#p1` + +```text +> The grounds of principles and judgments must be articulable and subject to assessment appropriate to the nature of the claim. The strength and scope of a claim must be proportionate to the support provided by its grounds. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Grounds checks identified applicable facets of the same claim; support, entailment and an option-indexed value procedure carry distinct responsibilities. This is a chosen formal interface and finite fulfillment examples, not a universal sufficient criterion for all philosophical grounds. + +Related targets: [T07](#t07), [T15](#t15). + + + + + + +### `organon.grounds.assessment#p1` + +```text +Articulation and assessment have distinct responsibilities. Articulability requires that concepts, assumptions, reasons, and limits can be identified. Assessment requires examining whether those grounds support the corresponding claim. Clearly expressed grounds are not thereby sufficiently established. When a claim has more than one applicable aspect, the corresponding assessment responsibilities apply to each aspect. Omitting a classification does not waive an applicable responsibility. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Articulation content is linked to each facet and separated from its discharge; union and missing-aspect examples prevent labels from waiving represented duties. Identifying every actually relevant aspect remains an application responsibility not solved by the datatype. + +Related targets: [T15](#t15), [T16](#t16), [T17](#t17), [T18](#t18), [T28](#t28). + + + + + + +### `organon.grounds.assessment#p2` + +```text +| Type of claim | Responsibility of assessment | What cannot substitute for that responsibility | +| --- | --- | --- | +| Empirical claim | Examine observations, evidence, and performance, together with the conditions, scope, and uncertainty of their support for the claim. | Treating measurability or repeatability itself as proof of relevance, correctness, or value. | +| Inferential claim | Examine whether the conclusion is supported by the stated assumptions and inferential relations. | Treating the absence of conflict between a conclusion and its assumptions as sufficient to establish that the conclusion follows from them. | +| Value commitment | State the position taken, its reasons, limits of application, and consequences, and remain open to relevant criticism. | Presenting a commitment as an empirical fact or a necessary inference, or substituting self-assertion for reasons. | +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The three modeled adapters check observational compatibility/support, semantic entailment, and value reasons with limits/consequences/criticism. Actual relevance, empirical uncertainty and the adequacy of value criticism beyond the chosen cases are not exhaustively formalized. + +Related targets: [T15](#t15), [T16](#t16), [T17](#t17), [T18](#t18), [T28](#t28). + + + + + + +### `organon.grounds.assessment#p3` + +```text +Initial value commitments may be stated explicitly as commitments; they need not prove all their own starting assumptions. The strength and scope of a claim do not require conversion to a common numerical scale. Different types of claims specify their support and limits in accordance with their nature. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +JointAdoption requires consistent instantiated starting commitments without proving all starting assumptions. A two-reason example and heterogeneous facets avoid a universal numerical scale. They demonstrate procedural consistency, not ultimate value justification. + +Related targets: [T15](#t15), [T16](#t16), [T17](#t17), [T18](#t18), [T28](#t28). + + + + + + +### `organon.grounds.scope#p1` + +```text +Performance is discerned within particular relations, conditions, and scopes of observation. A boundary helps specify what a comparison concerns, but local examples do not automatically support unconditional universal conclusions. A judgment cannot establish that relevant differences do not exist merely because its chosen scope omits them. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +A proper local observation scope supports a local function claim while admitting a counterexample outside it. This establishes the specified nonentailment; it neither identifies all relevant real differences nor rules out justified wider evidence. + +Related targets: [T19](#t19), [T20](#t20). + + + + + + +### `organon.grounds.scope#p2` + +```text +Measurement can make some differences comparable. Repeated assessment can help examine the stability of corresponding conclusions. Their roles, and the role of any assessment framework, must be explained relative to the claim and its context. Measurement, repeatability, and an assessment framework do not form a universally necessary chain on which all judgments must depend. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Repeated irrelevant measurements fail support, while a valid inferential assessment needs no empirical chain. This refutes a universal mandatory chain within the represented responsibilities but does not characterize every framework or measurement practice. + +Related targets: [T19](#t19), [T20](#t20). + + + + + + +### `organon.grounds.scope#p3` + +```text +An observation that has not been reproduced may still offer limited support, and random outcomes need not be identical on every occasion. The verifiability of observations, reproducibility of conditions, and stability of conclusions must be distinguished. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +A single observation has limited support and distinct trial outcomes preserve a fixed bound. Verification, reproducible conditions and conclusion stability use separate predicates; no probability distribution or general reproducibility law is proved. + +Related targets: [T19](#t19), [T20](#t20). + + + + + + +### `organon.grounds.capabilities#p1` + +```text +Capability claims are subject to Grounds: the capability claimed, its conditions, and the support for it must be identifiable. The core does not prescribe uniform definitions of method mastery, method generation, or capability levels. Applications specify the capabilities they assess and may require understanding, explanation, or performance under relevant variations. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Output-only and explanation-bearing contracts concern the same process and each has its own checked Grounds; applicationVariation changes the actual objective and invalidates old evidence. No uniform real mastery or capability-level definition is derived. + +Related targets: [T07](#t07), [T21](#t21). + + + + + + +### `organon.grounds.capabilities#p2` + +```text +Grounds for a capability claim may be supplied by an external assessor. Their articulability does not by itself require the assessed system to understand or explain its internal generation process. Evidence of reliable output must be assessed against the capability actually claimed; it does not automatically establish understanding of that process. Nor can the number of method documents, terms, tools, or artifacts alone establish a capability beyond what that evidence supports. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +A distinct assessor role supplies a proof about the exact output process while no explanation certificate is attached; duplicating four inventory kinds leaves represented capability unchanged. Role numbers and certificates do not prove external provenance or human-like understanding. + +Related targets: [T07](#t07), [T21](#t21). + + + + + + +### `organon.grounds.implementations#p1` + +```text +> The choice of an implementation must be supported by reasons connected to the objectives and values pursued and to the relevant constraints. Its name, conventional use, or established status alone does not provide sufficient grounds for giving it priority. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +The adopted choice interface requires feasibility and an objective/value/constraint-linked reason and rejects status-only reasons. Its finite reason vocabulary and concrete feasibility checks do not supply a general theory of warranted real implementation choice. + +Related targets: [T22](#t22), [T23](#t23). + + + + + + +### `organon.grounds.implementations#p2` + +```text +This choice provision adds an additional evaluative commitment: name, conventional use, or established status alone is insufficient to establish priority. Grouping it under Grounds does not mean that it follows from the general requirement to assess reasons, or merely from the discernibility of performance. Conventions and existing arrangements may have practical significance, but that significance must be connected to the objectives and values pursued and to the relevant constraints. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Two independent policies share a correct negative audit but differ on the added choice norm, establishing independence from the represented assessment procedure. This does not show an unsupported priority claim fully satisfies general Grounds, or derive a value commitment from neutral facts. + +Related targets: [T22](#t22), [T23](#t23). + + + + + + +### `organon.grounds.implementations.limits#p1` + +```text +- Openness does not make all implementations equivalent, nor does it guarantee multiple feasible implementations for the same objective. +- A method’s explanatory power, limits of application, simplicity, and explicit process requirements may all provide grounded reasons for assessment. They cannot be excluded merely because they concern methods internal to the implementation. +- Identical local performance does not establish overall equivalence. Relations, conditions, and the scope of comparison are constrained by the provisions of Grounds. +- Openness does not reject an implementation merely because it already exists or is conventionally used. Relevant reasons may still give it priority. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Concrete cases have one feasible candidate, unequal implementations, local agreement with wider difference and four eligible internal reasons. A cheap wrong-output method shows eligibility alone is insufficient. These results concern selected candidates and contracts, not all methods. + +Related targets: [T24](#t24). + + + + + + +### `organon.relationships` + +```text + + +``` + +State: **not_applicable**; Lean: not_checked; fidelity: not_applicable. + +Structural heading without substantive direct-body content; no theorem is assigned. + + + + + + +### `organon.relationships.roles#p1` + +```text +The charter states the generative orientation, the consistency constraint, and reflexive application. Grounds specifies support requirements for judgments and includes an additional commitment concerning implementation choices. Both parts belong to the core and constrain one another. Their placement neither makes Grounds a deduction from the charter nor gives the charter priority over it. Each commitment needs its own reasons. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +One shared model combines the charter and Grounds and assigns five commitments distinct operational reasons, limits and live criticism. Specified nonentailments prevent chapter order from doing logical work; neither the universal adoption nor ultimate justification of all commitments follows. + +Related targets: [T02](#t02), [T12](#t12), [T23](#t23), [T25](#t25), [T26](#t26), [T27](#t27). + + + + + + +### `organon.relationships.roles#p2` + +```text +Internal Consistency concerns whether simultaneously held judgments can hold together; Grounds concerns whether and how far a claim is supported. A conclusion may fail to conflict with its assumptions without being supported by them. Self-Transcendence specifies a generative orientation and non-finality; neither establishes actual capability. Applications may supply objectives, values, and capability definitions; claims made under those objectives, values, and definitions remain subject to the relevant core provisions. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Consistency/support and orientation/capability remain separate; changing an application objective changes its actual claim and can defeat retained evidence. Universal application compliance is only an assumed conditional interface, not an achieved fact. + +Related targets: [T02](#t02), [T12](#t12), [T23](#t23), [T25](#t25), [T26](#t26), [T27](#t27). + + + + + + +### `organon.relationships.roles#p3` + +```text +Self-Transcendence does not substitute for Reflexivity: keeping existing forms open to being surpassed differs from applying relevant principles to the system and to their own formation, application, and revision. Reflexivity extends these requirements to the system and to the formation, application, and revision of its principles. The grounds and limits of the Grounds provisions must themselves be articulable. The system’s own capability claims remain subject to assessment, and this philosophy’s existing form cannot gain priority merely from its established status. Such mutual application provides no self-proof and does not remove conditions of application. +``` + +State: **limited**; Lean: passed; fidelity: partial. + +Contentful self-application, exact own-capability assessment, the general Grounds provision and the same current philosophy method are linked in the model. Their checked coexistence supplies no self-proof, real execution guarantee or unconditional applicability. + +Related targets: [T02](#t02), [T12](#t12), [T23](#t23), [T25](#t25), [T26](#t26), [T27](#t27). + + + + + + +### `organon.relationships.terms#p1` + +```text +| Term | Meaning in this philosophy | +| --- | --- | +| Existing form | The system’s current organization, methods, and principles, not only its appearance or artifacts. | +| Assessment | Examination of reasons, applicability, and observed performance; not limited to executable tests. | +``` + +State: **limited**; Lean: passed; fidelity: partial. + +FormKind includes organization, methods and principles, and an inferential assessment has no executable-test requirement. These representations illustrate the terms without exhaustively defining every existing form or every non-test assessment. + +Related targets: [T05](#t05), [T28](#t28). + + + diff --git a/lean/philosophy/reviews/README.md b/lean/philosophy/reviews/README.md new file mode 100644 index 0000000..c0959eb --- /dev/null +++ b/lean/philosophy/reviews/README.md @@ -0,0 +1,21 @@ +# Review objects and interpretation + +The final [target review](code-targets-final.json) accepts 28 frozen targets within their represented scope. The [source entries](code-source-entries-final.json) separately retain 31 partial correspondences and two nonformal paragraphs; two empty headings are additional structural entries in the manuscripts. No source paragraph is upgraded to full correspondence from target acceptance alone. Definition-only source entries remain without a proof of actual fulfillment; their normative specification targets are reviewed as specifications. + +The [source-first initial assessment](source-initial.md) preceded new encoding. A different reviewer received a comment-stripped Lean project with only technical context and preserved the [initial blind account](code-blind-initial.md) before source disclosure. Its [first source comparison](blind-source-comparison-initial.md) and [first target judgments](blind-targets-initial.json) rejected 11 targets. The separate [source-first code comparison](source-comparison-initial.md) also retained its own rejected branches. + +The [final code comparison](code-comparison-final.md) is an informed revision review, not a second blind review. It independently checked the revised model, complete actual declaration types and the dependencies of all 411 named source declarations. The [other final source comparison](source-comparison-final.md) retains T13 as pending independent approval because that reviewer implemented the reflexivity repair. The separate final code reviewer supplies that independent review. Its [identity record](code-review-identity.json) identifies exact inputs and outputs; agreement alone does not establish philosophical correctness. + +T23 is accepted for the represented finite duty to assess the same reasons and claim accurately. It does not establish the stronger proposition that complete general Grounds, excluding Choice, is satisfied while unsupported status priority remains justified. The [pre-code design](choice-scope-design-before-code.md) and [scope correction](choice-scope-reconciliation.md) preserve the initial wording ambiguity, its subsequent clarification and the stronger result not established. Non-entailment from the status facts is not by itself a proof of absence of all possible value grounds. + +The preamble's authority statement is a background citation for T02. Its `context_only` role retains `not_applicable` for mathematical proof; it does not waive the source's authority or conditions. The frozen source/declaration mappings remain intact. Each proof target still has substantive source correspondence and actually checked declarations. + +Final line explanations are informed translations. The independent code reviewer wrote Agency, Reflexivity, Integration and the root file; a model author wrote Logic, Evidence and Choice using the reviewer's symbol descriptions and actual source. The initial blind text remains distinct. Both languages explain the same 2,474 nonblank lines; coverage is not a semantic guarantee. A subsequent reader QA found a T27 overstatement and syntax-only explanations of substantive proof lines. The [reader revision record](translation-revision.json) identifies the corrected four views and separate revised translation inputs. The earlier frozen translation artifacts in the code-review identity remain unchanged; they are not presented as the current line explanations. + +These public records are presentations of unchanged local originals. Host directory prefixes are replaced with descriptive labels so the current package has no machine-path dependency. [Derivation hashes](presentation-derivations.json) retain original and presentation identities. `Core/` denotes the Core tree; private-check labels identify historical evidence rather than required paths. The original freeze called the catalog `targets-frozen.json`; its target bodies are retained in [targets.json](../targets.json); the current source binding is covered by the separate migration review. Current builds and manuscript checks need no private history. + +## Current source migration + +The [2026-09-15 comparison](source-migration-2026-09-15.md) reviews the new source version and rationale path. Earlier initial and final review files keep their original objects and wording. The current fidelity object reuses their unchanged code, assumptions and target judgments only within that separate comparison; it does not relabel them as new blind reviews. The original preregistration and its catalog hash identify the preceding source-bound catalog; current target bodies are identical and the source binding is new. Historical source/run/readers replayed in a separate complete copy before replacement. + +The [provenance follow-up](source-migration-provenance-2026-09-15.md) covers the two required unit-hash comment changes in Integration.lean after the first current gate rejected stale provenance. The new code-file identity is recorded; all executable text and target bodies remain unchanged. The earlier byte-identity statement describes the object before this correction. diff --git a/lean/philosophy/reviews/blind-source-comparison-initial.md b/lean/philosophy/reviews/blind-source-comparison-initial.md new file mode 100644 index 0000000..630c4e5 --- /dev/null +++ b/lean/philosophy/reviews/blind-source-comparison-initial.md @@ -0,0 +1,504 @@ +# 第一候选独立来源比较首案（冻结） + +日期：2026-09-14。评审代理：`/root/fresh_model_blind`。 + +## 结论及范围 + +28 个冻结目标：**accepted 17，rejected 11，pending 0**。第一候选的数学代码已编译成功；62 个冻结声明的实际完整类型与本代理先行盲读的代码逐项一致。拒绝结论是来源对应或冻结目标完成性判断，不是声称 Lean 已检查的定理为假、原文自相矛盾，或数学证明应证明所有价值立场为真。 + +本首案仅评估第一候选 `2026-09-14T02-57-54.555Z-9709-f08e31` 的固定 `project` 与 `declaration-types.json`，不得作为后续候选的批准。已完成盲读并冻结两份盲稿之后，才阅读指定权威来源、编码前独立清点、冻结目标与来源段落。没有读取作者判断、target-narratives、其他评审或正在变化的候选工程。没有改代码、哲学原文或既有盲稿，也没有再委派。 + +“accepted”表示这一冻结家族内要求的有限形式结果及解释边界得到满足，不是接受一切可能解释或证明整个哲学。明确规范接口的投影按规范后果接受；额外要求实质对应、内容性见证和非蕴涵分支时，不以接口字段存在或定理名称代替。不存在只因主题难于形式化便把已冻结 D/W 分支降为非定理的处理。 + +## 关键判断 + +1. **有限模型不是一般能力。** `Integration.World = Candidate` 只有 identity/successor。观察 input 0 能识别 identity，所以全输入能力随实现定义推出。这是有效的封闭模型推理，不是从单次测试归纳所有程序。T02 的这一共享能力/预算/观察/选择部分是真实交互，单独通过；拒绝该家族的原因是其他冻结分支未齐。 +2. **规范接口不是现实履行；但也不能丢掉规定的对象。** `Reflexive` 保留 owner/applicable 条件和两种活动；其 `Performed` 只是 pair 会员。作为明确规范覆盖投影可以接受，不能据此表示实际程序已运行。T13 另要求形成理由、适用域考察和修订理由，当前对象没有这些内容，故该分支未完成。 +3. **价值承诺不必被证明真，与理由必须对应立场是两回事。** 盲读已编译出恒 False commitment 的 ValueProcedure/Grounds；这本身不要求所有价值立场成为事实，更不是 Lean 推出 False。实质缺陷是 `ValueProcedure` 不读取 commitment/starting，替换任意不相关 commitment 不影响通过性。它只检验理由推出另一可任意指定的 consequence。T15/T25/T27 需要实际理由与当前立场的联系，不能由这一接口自动得到。修正应允许非演绎价值理由和未证起点，而不是强行要求理由逻辑证明承诺。 +4. **已有有限价值见证仍可通过。** T18 的 switchPosition 把所选 true 选项的成本/收益作为具体理由，起点另证可满足，批评世界有响应，并证明空理论不推出承诺。这一有限程序相容性目标成立，通用接口的较弱性不自动否定该具体存在见证。 +5. **事实优先命题与额外选择规范不可混同。** T23 当前证明“两个 status facts 不推出 selected=identity”；冻结问题是一般评估责任不推出额外的反 status-only 优先规范。现有反例没有独立可变 choice policy，也没有一般责任履行而该额外规范失败的同一模型，因而不能算规范独立性完成。 +6. **Grounds 条款自身不同于一次能力的 Grounds 满足。** `commitmentClaim .grounds` 是固定 `OwnCapabilityDuty capability [capabilityFacet]`。其观察理由支持该能力，却不是 Grounds 条款采纳/适用要求自身的理由。`existingPhilosophy` 也仅修改 identityImpl.name，没有连接到本模型的采纳政策或原则。因此 T25 的这些反身对象尚未对应来源。 +7. **不能用并列标签替代同一对象。** T06 中外部资源求和确实依赖三个 Option，但没有把该算法与 Generative 政策的系统执行/状态相连；稳定阈值没有连接到应用约束/动作；自述仅 `expanded=expanded`。T07 也尚未将通用 support 定理实例化为同一 before/after、基线、条件和成就主张。已有库存非扩展反例保留，其余分支须实际补齐。 +8. **不用额外提高已冻结有限例子的标准。** T08–T12、T16–T20、T22、T24、T28 的通过范围依各实际数学定义限定：例如 Q 可为空、解释力代理只是数值等同、procedure 只看末项、Trial 的复现只看 setting、非经验不等于不可计算。这些界限不能被宣传性名称扩大，但不自动推翻冻结的有限反例/接口后果。 + +## 28 项总表 + +| 目标 | 判定 | 理由 | +| --- | --- | --- | +| T01 | accepted | 来源、规范/事实及章节角色边界得到保留；本项通过仅表示边界和来源记录合格，不代表其余27项目全部实现。 | +| T02 | rejected | jointWitness确有非空数学见证，但其反身工作与各承诺理由未达到冻结的共享、内容对应模型；较弱接口的可满足性不能算所选Core规范已联合满足。 | +| T03 | accepted | Generative作为明确采纳的有限规范接口保留价值取向与当前形式可修订性，未内置必然变化或进步。 | +| T04 | accepted | 明确非空政策允许不同版本对，但完全不赋扩展价值，足以区分许可与价值取向。 | +| T05 | accepted | 通用kind/version覆盖和具体可修订却无扩展见证均成立；投影性质须如实标记。 | +| T06 | rejected | 数量与非进步分支有内容性见证；外部执行/稳定与同一系统状态的联系尚未建模，自称生成分支更只有构造器自等式，11分支未齐。 | +| T07 | rejected | 任意claim的support应用定理正确，但冻结要求的同一能力变化、基线和条件实例及取向/自述不提供其支持的反例没有完成。 | +| T08 | accepted | 通用语义与非空见证阻止同题正反结论；实际三前提冲突显示不能仅逐项检查。 | +| T09 | accepted | 时间切片撤回旧命题后保留相反命题的可满足性及联合冲突明确；三种上下文变化分别有非空见证。 | +| T10 | accepted | 单向报告规范、语义变化反例、表示顺序不变以及独立revisionIdentity触发均达到冻结的规范接口范围；并未实现自动检测。 | +| T11 | accepted | 两约束有共同可行值但非同一谓词；同条件正反后果明确违反一致性。修订责任是采纳规范的条件后果，未声称已实现修订算法。 | +| T12 | accepted | Bool模型具体区分可满足性与指定实际world真值，并给指定问题的双向非蕴涵；其现实重要性不由数学裁定。 | +| T13 | rejected | 系统/原则/三阶段和两类活动的条件覆盖已表达，但原则形成理由、适用域审查及修订理由仍只由活动标签代替，未完成冻结的完整规范对象。 | +| T14 | rejected | 适用性与有限检验反例通过；自产修订分支没有与同一主体/旧新对象关联的自我产生事实，仅演示任意局部生成函数的观察不足。 | +| T15 | rejected | 结论弱化与范围缩窄定理成立；完整Grounds规范中的价值理由对应当前claim仍无检查，不能以该较弱接口代表全部来源责任已保留。 | +| T16 | accepted | 面向义务的并集/标签不变和同一switch claim的经验＋价值缺责反例完整；规范接口局限另见T15。 | +| T17 | accepted | 所列不充分替代物有实际内容反模型；非蕴涵未被说成结论恒假。价值反例只证明所示理由/预算责任失败，不是价值真理。 | +| T18 | accepted | 具体switch价值立场有成本/收益理由、限度、非空批评响应及可满足起点，并未从空理论推出承诺；异类支持不用统一数值尺度。 | +| T19 | accepted | 实际观测域{0}是真子域，兼容函数在1表现不同，支持与非支持结论均由计算/反模型成立。 | +| T20 | accepted | 单次观察的有限支持、非经验推论及不同结果同范围结论、三概念分离都有实际有限实例；不声称概率或非计算性定理。 | +| T21 | rejected | 输出/附加解释合同的分离与四类库存复制正确；但冻结的两个应用均受Grounds、外部评估者供应可表达根据的同对象见证尚未构造。 | +| T22 | accepted | 在单独采纳的选择规范下，三类纯身份理由统一被排除；既有惯用identity仍以真实输出理由被接受。 | +| T23 | rejected | 现有定理证明status facts不蕴涵“选择identity”这一对象命题，而没有证明一般评估义务不蕴涵额外的反status优先规范；两种独立性目标不能混同。 | +| T24 | accepted | 冻结所需有限开放性例子均存在；选择接口的一般充分性仍很弱，不能从这些存在例子推导所有相关内部理由足以满足全部目标。 | +| T25 | rejected | 有真实模块交互的能力与一致性部分通过；Grounds条款自身、现有哲学同对象及原则过程的对应仍不足，不能以实例义务替代规范自身。 | +| T26 | rejected | 两个指定非替代方向有有效有限反例；完整联合正见证依赖T02仍缺失的对应关系，家族不能全部通过。 | +| T27 | rejected | labels不豁免固定例子的义务已证明；可变应用目标/能力及每项承诺自身理由的冻结范围尚未实现，字段等式不等于理由对应。 | +| T28 | accepted | 有实际n=2⇒n+1=3的结构化推论Grounds且无需经验测试，同时保留经验facet的观测责任。非经验不是不可计算。 | + +## 逐家族、逐分支依据 + +### T01 — accepted + +分类：N/E-V boundary。 + +实际前提与对象范围：权威文本为所指定PHILOSOPHY 0.1.3；其权威和采纳不是由Lean推出。source-paragraphs保留22源单元、全部段落/表格/限制；标题无伪造定理。 + +冻结声明：无（来源/规范边界项）。 + +来源：`organon.preamble/p1`, `organon.preamble/p2`, `organon.charter.overview/p1`, `organon.charter.overview/p2`, `organon.charter.overview/p3`。 + +- **authority — accepted**（`PHILOSOPHY.md:8; source-paragraphs.json`）：原文SHA与冻结目标一致。数学类型不包含“所有现实系统都遵守”或哲学普遍正确性结论。 +- **meanings-and-limits-record — accepted**（`source-paragraphs.json`）：22单元含义、条件、表格和bullet均作为来源保留；具体语义实现缺口在相应T项判定，不能由本项通过抹去。 +- **roles-and-headings — accepted**（`CoreReader.lean:1`）：Charter/Relationships标题未被制造为True定理；来源明确Rationale/Skills不增加核心义务，组合代码未赋章节顺序以演绎权威。 + +### T02 — rejected + +分类：W satisfiability plus N interpretation。 + +实际前提与对象范围：无外部实质参数；世界仅identity/successor；取actual=identity、固定openPolicy、固定held/context、预制十项work；value Grounds使用各自singleton适用面。 + +冻结声明：`CoreReader.Integration.jointWitness`。 + +来源：`organon.preamble/p1`, `organon.preamble/p2`, `organon.charter.overview/p2`, `organon.charter.overview/p3`, `organon.relationships.roles/p1`, `organon.relationships.roles/p2`, `organon.relationships.roles/p3`。 + +- **inhabited-world-and-judgments — accepted**（`Integration.lean:24-68,238-245`）：actual提供真实模型；held有能力和预算命题，观察在两个候选内识别identity，非空且非全真记录占位。 +- **shared-capability-and-choice — accepted**（`Integration.lean:101-116,238-245`）：相同implementation用于capability、budget、observation和output choice；这一部分确有模块交互，观察推广限于封闭候选类。 +- **principle-process-content — rejected**（`Agency.lean:192-207,253-269; Integration.lean:93-98`）：五个对象/两种活动确非空，但Performed仅pair会员关系，原则形成理由、适用域考察和修订理由没有可表达内容；预填记录不足以完成冻结的内容性对象分支。 最小修正条件：补充与这些subject相连的实际评估问题/理由/范围/结果对象，并用非空记录验证相应义务；不要求现实系统已经运行。 +- **individual-commitment-reasons — rejected**（`Integration.lean:130-180`）：generation理由是两函数在0输出不同，仅推出存在不同输入；Grounds承诺字段可任意重贴而ValueProcedure不变。因此联合对象尚未提供每项承诺自身理由。 最小修正条件：建立每项承诺与其理由、限度及批评响应的可审查联系，保留价值承诺不必被证明为事实的边界。 +- **no-priority-from-conjunction — accepted**（`Integration.lean:95,238-245`）：合取本身未推出章节优先级或普遍哲学正确性。 + +### T03 — accepted + +分类：N specification。 + +实际前提与对象范围：Policy四谓词独立；Aim为两标签，Form为五种类加Nat版本；规范后果是条件投影，不证明现实系统遵守。 + +冻结声明：`CoreReader.Agency.Generative`。 + +来源：`organon.charter.overview/p2`, `organon.charter.overview/p3`, `organon.charter.self-transcendence/p1`, `organon.charter.self-transcendence.orientation/p1`, `organon.charter.self-transcendence.non-finality/p1`, `organon.charter.self-transcendence.limits/p1`, `organon.charter.self-transcendence.limits/p2`。 + +- **orientation — accepted**（`Agency.lean:13-35`）：worthPursuing选择理解/构造扩展这一被采纳目标；与permitsVersion字段独立。 +- **nonfinal-current-forms — accepted**（`Agency.lean:5-21,33-35`）：∀current form→revisable覆盖组织/方法/原则及外观/产物；没有预装严格改善序列。 +- **no-actual-success-guarantee — accepted**（`Agency.lean:33-35,103-127`）：定义不含实际transition或Expanded证明；无进步trace提供边界。 + +### T04 — accepted + +分类：W nonentailment。 + +实际前提与对象范围：neutralPolicy继承全允许版本关系但worthPursuing恒False；版本0≠1由Nat计算。 + +冻结声明：`CoreReader.Agency.permissionNotValuation`。 + +来源：`organon.charter.self-transcendence.orientation/p1`。 + +- **permissible-nontrivial-change — accepted**（`Agency.lean:37-51`）：允许0→1且0≠1；证明许可，不声称此变化已执行。 +- **valuation-independent — accepted**（`Agency.lean:43-51`）：Generative因所需价值取向为False而失败；不是将两个概念写成同一布尔量。 + +### T05 — accepted + +分类：N/D projection and W witness。 + +实际前提与对象范围：revisabilityCovers前提为Generative p及p.current指定form；无进步见证用独立恒定trace。 + +冻结声明：`CoreReader.Agency.revisabilityCovers`, `CoreReader.Agency.revisionWithoutProgress`。 + +来源：`organon.charter.self-transcendence.non-finality/p1`, `organon.relationships.terms/p1`。 + +- **form-coverage — accepted**（`Agency.lean:5-11,58-59`）：任意五种form kind均受∀current→revisable规范约束，包含全部必要种类。 +- **projection-boundary — accepted**（`Agency.lean:58-59`）：只是将已采纳规范实例化，不是发明可修订性或执行修订；这正是冻结规范后果范围。 +- **revisable-without-progress — accepted**（`Agency.lean:116-127`）：openPolicy可修订与常值baseState trace并存，每步Expanded均假。 + +### T06 — rejected + +分类：W eleven branches。 + +实际前提与对象范围：generationLimits无参数，由具体常量计算；Generative policy、assistedExecution、State trace、Announcement彼此不通过系统/执行对象相连。 + +冻结声明：`CoreReader.Agency.generationLimits`。 + +来源：`organon.charter.self-transcendence.limits/p1`, `organon.charter.self-transcendence.limits/p2`。 + +- **a-orientation-without-progress — accepted**（`Agency.lean:123-127,157-171`）：有价值/非终局政策且base与inflated之间无理解/构造成员增加。 +- **b-more-artifacts — accepted**（`Agency.lean:107-114,160-161`）：同一before/after状态inventory复制，understood/constructed不变。 +- **c-more-abstraction-layers — accepted**（`Agency.lean:113,160-162`）：层级列表增加而同一状态的能力成员不增加。 +- **d-more-terms — accepted**（`Agency.lean:114,160-163`）：词汇列表增加而理解/构造成员不变。 +- **e-external-experience — rejected**（`Agency.lean:129-142,164-165`）：Option计算确实读取experience，缺失即none；但没有标明该计算是这项Generative系统的执行，结果也不进入其状态。合取任意外部函数仅证明相容，未满足冻结同一内容系统要求。 最小修正条件：将政策、被执行算法、资源和before/after或执行结果纳入同一对象，再展示experience缺失的实际失败。 +- **f-external-knowledge — rejected**（`Agency.lean:136-140,166`）：knowledge依赖计算正确；同e，缺少同一系统执行绑定。 最小修正条件：复用同一绑定执行对象，分别删knowledge验证失败。 +- **g-collaboration — rejected**（`Agency.lean:136-140,167`）：collaborator缺失的Option失败正确；其同一主体/执行含义未建模。 最小修正条件：在上述共享执行对象中保留协作槽及单独缺失反例。 +- **h-no-autonomous-execution — rejected**（`Agency.lean:168`）：⟨none,none,none⟩导致独立求和函数失败；没有该系统自主执行接口，不能把任意失败函数当其不能自主执行。 最小修正条件：明确这就是被评系统的执行接口，并把无外援调用关联其执行结果。 +- **i-no-self-improvement — accepted**（`Agency.lean:116,169`）：常值trace每步无Expanded；可作为所选无自我改善轨迹，不是所有系统永远不改善。 +- **j-grounded-stability — rejected**（`Agency.lean:145-147,170`）：StableReason给出构造内容相等和inventory越过阈值1，但没有稳定动作或被追求的预算/价值条件；阈值本身尚未关联该系统稳定选择的理由。 最小修正条件：把1作为明示应用约束，并证明保留当前状态的动作满足它且不丢所需能力，同时政策仍Generative。 +- **k-self-announcement-not-achievement — rejected**（`Agency.lean:149,171`）：expanded=expanded只是枚举构造器自等式，不是某系统对同一变化的announcement，也没有achievement-support的失败命题。 最小修正条件：定义带主体、before/after和claim的实际报告，构造报告生成而同一claim不成立/缺充分支持的反例。 + +### T07 — rejected + +分类：D conditional fragment with N accountability。 + +实际前提与对象范围：achievementNeedsSupport前提为Compatible records actual和Supports records achievement，结论直接应用support；AchievementAccountability完全等于Grounds。 + +冻结声明：`CoreReader.Evidence.AchievementAccountability`, `CoreReader.Evidence.achievementNeedsSupport`。 + +来源：`organon.charter.self-transcendence.limits/p1`, `organon.charter.self-transcendence.limits/p2`, `organon.grounds/p1`, `organon.grounds.capabilities/p1`, `organon.grounds.capabilities/p2`。 + +- **conditional-inference — accepted**（`Evidence.lean:113-115`）：对任意W及claim，支持加actual兼容性推出actual处claim；没有伪称实际可靠性已证明。 +- **same-change-baseline-scope — rejected**（`Evidence.lean:102-115; Agency.lean:103-105`）：未把achievement实例化为同一before/after的Expanded；没有对应基线、记录内容、条件或非空支持见证。 最小修正条件：给变化世界/记录及明确Expanded类claim，证明非空兼容性、支持和actual结论；保留通用定理。 +- **orientation-and-report-insufficiency — rejected**（`Agency.lean:157-171; Evidence.lean:113-115`）：generationLimits只给无Expanded和标签自等式，未建立对上述achievement的support失败。 最小修正条件：复用同一变化世界，构造有取向/报告但兼容反世界使支持失败。 +- **accountability-interface — rejected**（`Evidence.lean:89-104`）：别名能存对应claim但value分支允许理由/commitment脱离，不能作为完整成就规范接口的完成证据；也没有achievement实例履行。 最小修正条件：将实际成就的适用经验/推论面与同一claim绑定，检查匹配的Grounds；不要由规范接口宣称真实成就已获证。 + +### T08 — accepted + +分类：D theorem and W countermodel。 + +实际前提与对象范围：W,Q任意Type；Consequence在同一t/c所有Admissible worlds上量化；显式存在admissible world；Q空时Consistent空真是范围边界。 + +冻结声明：`CoreReader.Logic.consequenceConsistency`, `CoreReader.Logic.jointConflict`。 + +来源：`organon.charter.consistency/p1`。 + +- **simultaneous-and-implications — accepted**（`Logic.lean:4-26`）：Theory含全部选择命题，Entails/Consequence量化所有模型，包括实际蕴涵而非仅扫描字符串列表。 +- **same-context-noncontradiction — accepted**（`Logic.lean:31-35`）：同一admissible witness使正反结论矛盾；不存在证明现实理论必有model的隐藏步骤。 +- **joint-conflict — accepted**（`Logic.lean:50-69`）：三个单项分别有Bool-pair模型，联合P、P→Q、¬Q无法满足；关键反例内容真实。 + +### T09 — accepted + +分类：W retraction and context models。 + +实际前提与对象范围：revisionSlice 0选择true、1选择false；固定时间的held理论由函数决定，撤回表现为旧命题不在新切片。 + +冻结声明：`CoreReader.Logic.revisionCanReverse`, `CoreReader.Logic.contextDifferences`。 + +来源：`organon.charter.consistency.meaning/p1`, `organon.charter.consistency.meaning/p2`。 + +- **retraction-and-opposite — accepted**（`Logic.lean:71-88`）：旧/新slice分别有true/false模型，联合无模型，编码的是撤回后的状态而非永久兼容要求。 +- **slice-consistency — accepted**（`Logic.lean:31-35,78-88`）：slice显式给Satisfiable而非直接Consistent；在空附加假设/全scope的自然问题上下文中，可由同一非空model一般定理得到一致性，未引入实质源外前提。 +- **assumption-change — accepted**（`Logic.lean:90-122`）：固定问题含义，仅世界假设true/false变化，正反后果各有admissible witness。 +- **meaning-change — accepted**（`Logic.lean:93-94,105-106,116-121`）：假设固定true，meaning改为等于true/false，反转判断而各context非空。 +- **scope-change — accepted**（`Logic.lean:95-96,107-108,118-122`）：假设为空、meaning固定，scope改选true/false；不要求跨context一致。 + +### T10 — accepted + +分类：N/D specification consequences plus W examples。 + +实际前提与对象范围：changed是¬SameContent或revisionIdentity不同；TruthfulReport是changed→report=true；规范本身是显式前提。 + +冻结声明：`CoreReader.Logic.semanticChangeMustBeReported`, `CoreReader.Logic.representationOrderIrrelevant`, `CoreReader.Logic.hiddenContextChangeRejected`。 + +来源：`organon.charter.consistency.meaning/p1`, `organon.charter.consistency.meaning/p2`。 + +- **semantic-change-report — accepted**（`Logic.lean:124-144`）：held/context语义成员、meaning、scope差异均触发报告责任；报告真不反推变化，无不报告变化的许可。 +- **representation-order — accepted**（`Logic.lean:150-152`）：union两个singleton的顺序变化不改变命题集合；仅覆盖这种表示变化。 +- **hidden-context-changes — accepted**（`Logic.lean:160-179`）：分别对assumption/meaning/scope构造¬SameContent，使false报告违反规范。 +- **independent-revision — accepted**（`Logic.lean:127,136,164,179`）：同content但revisionIdentity从0到1也禁止false报告；外部已识别文字/形式修订必须由调用方赋正确identity，不宣称代码检测了全部变化。 +- **report-not-adequacy — accepted**（`Logic.lean:165-181`）：true报告仍与新assumption在true实际world不成立并存，不为修订内容背书。 + +### T11 — accepted + +分类：W witness plus D norm consequence。 + +实际前提与对象范围：具体预算约束4≤n和n≤6；反向定理显式给同一t,c,q的positive/negative Consequence。 + +冻结声明：`CoreReader.Logic.tensionWithoutContradiction`, `CoreReader.Logic.conflictRequiresChange`。 + +来源：`organon.charter.consistency.limits/p1`。 + +- **tension-without-conflict — accepted**（`Logic.lean:186-190`）：预算5同时满足不同上下界，0证明两谓词不等；有限模型展示不同目标不等于不可同时满足。 +- **conflict-requires-nonretention — accepted**（`Logic.lean:195-197`）：同题同context正反后果使Consistent失败；在采纳一致性规范下不能原样保留该状态。未提供哪一项应改的价值判断或算法。 + +### T12 — accepted + +分类：W truth and coverage separation。 + +实际前提与对象范围：第一例取false为所检查实际world、true为model；第二例空Theory但Bool非空，指定claim w=true及其否定。 + +冻结声明：`CoreReader.Logic.consistentFalse`, `CoreReader.Logic.consistentIncomplete`。 + +来源：`organon.charter.consistency.limits/p1`, `organon.relationships.roles/p1`, `organon.relationships.roles/p2`, `organon.relationships.roles/p3`。 + +- **false-assumption — accepted**（`Logic.lean:205-208`）：singleton w=true可满足但在指定false world不成立，足以展示一致理论不自动为实际真。 +- **undecided-relevant-question — accepted**（`Logic.lean:216-222`）：明确检验w=true这一选择问题，两个Bool模型使正反均不被emptyTheory蕴涵。问题被指定为关注对象；未证明任何现实问题的重要性。 + +### T13 — rejected + +分类：N specification; projections are not executions。 + +实际前提与对象范围：Reflexive对任意owner、rules、records条件量化；Performed仅pair会员关系；Principle只有activity/applicable；Subject只有owner/id/phase。 + +冻结声明：`CoreReader.Agency.Reflexive`。 + +来源：`organon.charter.reflexivity/p1`, `organon.charter.reflexivity.meaning/p1`, `organon.charter.reflexivity.limits/p1`。 + +- **objects-and-activities — accepted**（`Agency.lean:175-207,253-269`）：系统、原则、formation/application/revision过程均有独立constructor/phase；generation和assessment两个活动均在非空ownRules中。 +- **applicability-conditions — accepted**（`Agency.lean:206-216`）：owner和rule.applicable是独立条件；自我身份不取消已适用规则的记录义务。 +- **formation-reasons-scope-revision-reasons — rejected**（`Agency.lean:192-207,261-269`）：没有任何subject关联的形成理由、适用域考察或修订理由字段/问题/评估内容；十个预填活动pair无法区分“仅合规自查”与来源要求的多问题审查。 最小修正条件：增加最小的assessment-question/content接口并关联原则及对应phase；明确三个问题均在责任范围，以非空解释性记录/实例证明覆盖。无需证明现实评估已发生。 + +### T14 — rejected + +分类：D conditional projection and W boundary cases。 + +实际前提与对象范围：noSelfExemption假定Reflexive及适用性；selfTest测固定算术predicate；localGenerator由Nat seed生成函数，代码无revision/producer/owner关系。 + +冻结声明：`CoreReader.Agency.noSelfExemption`, `CoreReader.Agency.applicabilityRetained`, `CoreReader.Agency.selfTestDoesNotProve`, `CoreReader.Evidence.selfOriginDoesNotSupport`。 + +来源：`organon.charter.reflexivity.limits/p1`。 + +- **no-self-exemption — accepted**（`Agency.lean:213-216`）：对同owner且适用的rule直接得到要求的record；不把identity与applicability等同。 +- **nonapplicable-boundary — accepted**（`Agency.lean:228-251`）：application-only规则可被履行而system assessment缺失；说明不能忽略条件要求所有自应用。 +- **finite-self-test-not-universal — accepted**（`Agency.lean:287-304`）：实际all运算在[1]通过，0使n+1=2n失败；有限内部测试不提供普遍正确性。 +- **self-origin-of-revision — rejected**（`Evidence.lean:331-350`）：证明生成函数f只在0为true且zero observation不支持allTrue，但未表示它是某系统自身生成的修订，也无修订前对象。作为局部观察反例有效，作为冻结自产修订分支欠对象联系。 最小修正条件：增加最小producer/owner及before/proposed关系或共享系统构造，让其自身生成该candidate，并保留当前内容性support反模型。 + +### T15 — rejected + +分类：D semantic support fragment plus N Grounds。 + +实际前提与对象范围：支持在记录兼容世界中全称；weakening明确假定p→q，scopeRestriction假定narrow⊆wide及wide支持；Grounds由调用方给actualApplicable。 + +冻结声明：`CoreReader.Evidence.Grounds`, `CoreReader.Evidence.supportWeakening`, `CoreReader.Evidence.scopeRestriction`。 + +来源：`organon.grounds/p1`, `organon.grounds.assessment/p1`, `organon.grounds.assessment/p2`, `organon.grounds.assessment/p3`。 + +- **same-claim-support — accepted**（`Evidence.lean:7-15,89-93`）：记录含实际test/result，经验/推论facet的claim与target必须相等；不是无解释support布尔字段。 +- **conclusion-weakening — accepted**（`Evidence.lean:123-132`）：假设同记录支持p及p→q，推出支持q；另有删记录会失支持反例，不混淆证据弱化。 +- **scope-restriction — accepted**（`Evidence.lean:140-144`）：将结论的量词域从wide缩为included narrow；不扩张观察域，也不补造现实可靠性。 +- **articulation-and-aspects — accepted**（`Evidence.lean:17-24,50-93`）：概念/假设/理由/限度可储存，facet对齐并要求所有声明适用面，经验加非空in-scope world排除矛盾观察空真。 +- **value-reason-correspondence — rejected**（`Evidence.lean:26-38,45-62`）：ValueProcedure不读取commitment或starting；替换任意不相关commitment不改变通过性。理由只需推出另一个任意consequence，不能确保陈述的是此立场的理由。False-commitment探针不是要求价值立场证明为真，而是揭示对应关系缺失。 最小修正条件：给可审查的立场/理由相关性与后果关系接口及非空实例，允许未证明的价值起点，拒绝不相关重贴和纯自断言；不必强制reason逻辑推出commitment。 +- **full-compliance-versus-interface — rejected**（`Evidence.lean:35-38,89-104`）：当前接口还允许空limits和恒定非空字符串使关键责任空真；原文保留适用性，但此代码不能由字段存在声称已经开放于相关批评。 最小修正条件：为作为完成见证的实例给实际适用世界和内容相关批评/响应，不把整个通用域强行设非空，也不将接口当现实履行证明。 + +### T16 — accepted + +分类：D union theorem and W mixed case。 + +实际前提与对象范围：Duties以任意Facet谓词为适用关系；labels在定义中无作用；mixed经验与价值facet的claim都为w=true。 + +冻结声明：`CoreReader.Evidence.assessmentUnion`, `CoreReader.Evidence.labelsCannotWaive`, `CoreReader.Evidence.mixedMissingResponsibility`。 + +来源：`organon.grounds.assessment/p1`, `organon.grounds.assessment/p2`, `organon.grounds.assessment/p3`。 + +- **union-not-exclusive — accepted**（`Evidence.lean:146-160`）：Facet是单面向枚举，但适用关系可同时选多个facet，union定理合并义务而非强制单选。 +- **unlabeled-duty — accepted**（`Evidence.lean:148-168,208-214`）：空标签不改变applicable责任；这是显式规范设计的定义后果，非实证分类器。 +- **actual-mixed-claim — accepted**（`Evidence.lean:181-214`）：switchEmpirical与unsupportedPosition同为w=true的主张；经验面实际discharged，价值面reasons=[]使义务失败，非两个无关claim标签。 +- **three-facet-and-articulation-elements — accepted**（`Evidence.lean:17-70`）：四类表达要素和三种责任接口独立存在；本项通过不认可ValueProcedure是完整价值正当性判定器。 + +### T17 — accepted + +分类：W countermodels。 + +实际前提与对象范围：Bool、Bool×Bool、Bool×Nat为实际模型类；可测测试读取一个coordinate；重复相同record不添加未测预算信息。 + +冻结声明：`CoreReader.Evidence.articulationNotSupport`, `CoreReader.Evidence.measurementRepeatNotSupport`, `CoreReader.Logic.compatibilityNotEntailment`, `CoreReader.Evidence.selfAssertionNotReason`。 + +来源：`organon.grounds.assessment/p1`, `organon.grounds.assessment/p2`, `organon.grounds.assessment/p3`。 + +- **articulated-not-established — accepted**（`Evidence.lean:216-235`）：非空concept/reasons但emptyTheory不支持w=true；另有不相关articulation与facet对齐失败。 +- **measurable-not-relevant-or-correct — accepted**（`Evidence.lean:237-243,273-293`）：第一coordinate可测且重复结果稳定，第二coordinate可true/false；单次和重复均不支持未测结论。 +- **repeat-not-value-reasons — accepted**（`Evidence.lean:248-293`）：action=true记录与budget0和3都兼容，无法支持budget consequence；非空announcement自述仍未履行价值reason→consequence检查。 +- **compatibility-not-entailment — accepted**（`Logic.lean:229-234`）：加入w=true与emptyTheory相容，但emptyTheory并不蕴涵它；有true/false反世界。 +- **self-assertion-not-reason — accepted**（`Evidence.lean:253-262,300-306`）：既有空reason反例，也有非空真自述在budget0不能推出所声称后果的内容性反例。 + +### T18 — accepted + +分类：W/N procedural satisfiability。 + +实际前提与对象范围：switchPosition取行动true，采用该承诺为起点，成本3/收益4；事实不被宣称必然推出价值采纳；反事实false world有响应。 + +冻结声明：`CoreReader.Evidence.valueWithoutSelfProof`, `CoreReader.Evidence.heterogeneousReasons`。 + +来源：`organon.grounds.assessment/p1`, `organon.grounds.assessment/p2`, `organon.grounds.assessment/p3`。 + +- **reasons-limits-consequence-openness — accepted**（`Evidence.lean:178-193`）：成本/收益理由与所选择true选项有具体关系，推出cost Exhibit the independence of the added choice obligation from the represented general assessment obligations, without placing it in those premises; qualify the model scope rather than claim neutral facts establish a value commitment. + +预定接口 `CoreReader.Choice.generalGroundsNotChoice` 只是待实现接口。本设计不因这个名字而要求或宣称完整规范 Grounds 已履行。 + +## 结论与精确命题 + +**可以在冻结的 represented general assessment obligations 边界内构造非空反例。** 取同一个优先主张 q、同一组非空地位理由 E、同一比较域和明确限度；正确完成对 E 是否支持 q 的评估，得到“不能推出”的判断；选择模块仍仅凭地位给出 q 所称优先性，违反额外选择条款的“地位本身不足以确立优先”限制。 + +应证明的是：存在一个内容模型 M，使以下二者同时成立： + +1. 对 M 中同一 q/E 的**有限评估程序职责**已完成，并有可核验的正确评估结果和反模型。 +2. M 中实际采用的优先理由仅是既有地位，因而不满足额外选择条款的一项必要条件。 + +**不能把它升级为**“同一未限定的优先主张 q 已充分满足完整一般 Grounds，但仍违反 Choice”。本模型中，q 的提出者若在知道理由不足后仍保持其无条件优先断言，便未满足 U14 的强度/范围与支持相称要求。完成评估不等于被评估主张获得支持；报告评估为不足不等于 q 必假。 + +这是对冻结目标已明示的模型范围作实例化，不修改目标，不增加规范，也不将难以证明的形式分支改列为边界。它不建立全部一般 Grounds 在充分规范意义上与 Choice 的独立性；该更强命题既不是此模型的结论，也不能借接口名称暗示。 + +## 同一对象的最小内容模型 + +### 1. 实现、任务和主张 + +取两个不同的实现 `A` 与 `B`。当前任务、比较范围、术语含义和假设保持固定。若实现中需要展示实际任务内容，可令两者都在布尔输入上计算恒等函数：A 直接返回输入，B 按真假分支返回相同布尔值。两者在该任务上都可行；这些可行性事实只是固定背景，不产生谁应优先的比较结论。 + +唯一被评估的选择主张 q 是： + +> 在当前任务及候选集合 {A, B} 中，A 应优先于 B。 + +q 是一个**规范性的优先主张**。以下形式解释检验“给定理由是否逻辑支持该主张”，不把 q 偷换为描述性命题“某排序程序恰好先输出 A”，也不把形式解释中的 q 真值宣称为实际价值真理。 + +### 2. 非空且有内容的理由 + +公开事实为：A 是既有实现；B 不是既有实现。理由集 E 包含这两个实际可识别的事实记录： + +- `Established(A)`； +- `not Established(B)`。 + +每个记录都关联 q 和同一任务/时间/候选范围，有清楚的概念含义和判定值。它们不为空，不是任意字符串，也不是“因为它应优先，所以应优先”的重述。它们提供了关于候选地位的真实内容；问题在于这些内容是否足以支持**优先性**，而不是这些事实有没有发生。 + +就非蕴涵证明而言，一个 A 地位事实已足以组成非空 E；此设计保留第二条，用来使 A/B 地位差异及选择行为明确。对象域采用两个候选和两种优先序；不声称已证明全局最小形式。 + +### 3. 两种具体优先序解释 + +取两个有限解释，地位事实完全相同，优先关系分别是： + +| 解释 | A 既有 | B 既有 | 严格优先序 | q | +| --- | --- | --- | --- | --- | +| w₁ | 是 | 否 | A 在 B 前 | 真 | +| w₂ | 是 | 否 | B 在 A 前 | 假 | + +“世界”在这里是可计算的语义解释，不是声称存在两套已被正确论证的现实价值体系。优先关系来自两个元素的两种排列，因而是有内容、可计算的严格全序；不是另设一个可任意填写的 `supports` 或 `nonEntails` 布尔量。 + +理由满足关系 `E(w)` 逐项检查地位事实。定义所建推论片段的支持： + +`InferentialSupport(E, q) := 对每个满足 E 的解释 w，q(w) 成立。` + +计算可得 w₁、w₂ 都满足 E，而 q(w₂) 不成立，所以 `not InferentialSupport(E, q)`。证明须显式给出 w₂ 及 E 在 w₂ 中成立、q 在 w₂ 中不成立；不是将“不支持”预装为输入字段。 + +该反例不假设地位永远无实际意义。它只检验给定理由中**没有**其他连接目标、价值和约束的优先理由时，不能由地位事实本身推出 q。没有加入 `Established(x) → Priority(x)` 之类的桥接前提；加入该前提会改变待检验的论证，而且其规范根据需要另行交代。 + +### 4. 同一主张的真实评估 + +评估记录必须直接包含 q 的标识、E 的全部记录标识、固定范围、计算所得两个兼容解释、判定“不蕴涵”和反例 w₂。验证器重新计算 E/q 的语义，核验报告中的反例，而不是只检查记录字段非空。 + +可表达限度具体是： + +- E 只提供当前候选的既有地位事实； +- 评估只讨论当前任务与 {A, B}，未声称其他候选或未来情况； +- 未提供由既有地位通向优先性的规范桥接前提； +- 因而 q 目前不被 E 推出；这不证明 q 在现实中错误，也不排除另有相关理由使 A 优先。 + +价值面向可如实记录：提出者的立场是仅因 A 既有而优先选择 A；给出的理由是 E；后果是 B 虽可行仍被排到 A 后；评估承认对“为何既有地位应优先”的批评，并明确当前理由不能回答这一批评。这样不是用“立场已陈述”证明价值正当性。实际理由不是空记录；准确结论正是“有理由内容，但没有所声称的支持力量”。 + +### 5. 选择仍违反额外条件 + +同一系统的选择模块按照既有地位将 A 排在 B 前。它对 q 的优先理由只使用 E，没有把其他实现的评估报告或另一个主张的根据拿来代替 q 的根据。审查模块正确指出 E 不推出 q，而选择模块继续持有 q；二者不是逻辑矛盾，因为“不被这些理由支持”不等于“q 为假”。 + +Choice 部分无需构造一个全新“实现必须满足什么”的规范。直接使用源文已有的必要条件：**仅既有地位不足以确立优先性**。实际优先理由全部是地位事实，且提出者仍声称据此具有优先性，因此该必要条件未满足。不能把单纯选择了可行 A 与宣称 A 凭地位享有优先权混同；违规的是后者的理由与优先主张。 + +若随后系统撤回 q，或者取得与目标、价值、约束相关的实际理由，这就是另一个状态。本反例不阻止它被修正，也不把既有实现永远排除。 + +## 哪些责任已完成，哪些没有 + +| 责任/性质 | 本模型状态 | 实际依据与限度 | +| --- | --- | --- | +| 对象与主张可识别 | 已完成 | q 始终是同一任务中 A 对 B 的规范优先主张 | +| 概念、假设、理由、限度可表达 | 已完成于有限结构 | 明确候选、地位事实、E、解释域及缺失桥接前提 | +| 理由非空且真实对应 q | 已完成 | 两条 E 记录就是提出者为 q 使用的地位事实；不借另一 claim | +| 事实记录在模型中可核验 | 已完成 | 两个解释都明确满足两条地位事实 | +| 检查 E 是否支持 q | 已完成且结果正确 | 实际枚举解释、提供并验证 w₂，结论为不蕴涵 | +| 不把不蕴涵当作 q 恒假 | 已完成 | w₁ 满足 q；报告仅拒绝所检验的推论 | +| 价值立场、给出理由、限度、后果及批评可见 | 可在该程序结构中完成 | 记录立场与真实有限理由，并承认其不能回答相关批评；不证明充分正当性 | +| 全部经验根据的现实可靠性 | 未证明，不属于此有限结果 | 地位事实是该有限模型的已给事实；不声称所有现实记录可靠 | +| 未限定 q 的支持强度/范围相称 | **未满足** | q 仍被声称，但 E 不推出 q；不能标成充分 Grounds 合规 | +| 初始价值立场的充分正当性 | 未证明 | 说明理由和接受批评不自动证成该立场 | +| 额外 Choice 的地位限制 | **未满足** | 实际优先仅以既有地位为理由 | + +由此，`represented assessment duties completed` 可以为真，而 `Choice status condition satisfied` 为假。`FullGrounds(q)` 不应被标真，也不应把“记录了 Grounds 结构”作为其证明。 + +## 建议的通用数学接口及不可偷换项 + +接口应参数化候选、事实理由、优先关系解释、主张语义、论据满足关系和评估报告，而非只为 A/B 定义一个恒真的 `GeneralGrounds`。至少区分： + +1. `ArticulatedArgument`：有可解读的同一 claim、premises/reasons、条件和限度。 +2. `AssessmentCompleted` 或同义名称：执行并正确记录“是否支持”的检查；允许支持或不支持两种结果。 +3. `InferentialSupport`：由解释集合的实际语义定义，不是记录存在性。 +4. `ProportionateAssertedClaim`：若选择模块保持该强度的 q，则需要与其相称的支持；本反例对这个性质不能出具证明。 +5. `ChoiceStatusCondition`：直接表达源文的地位本身不能给予优先，不冒充完整 Choice 的充分定义。 + +预定 `generalGroundsNotChoice` 若保留该名字，实际类型和读者解释必须写清它的前项是**represented finite assessment obligations**。若前项实际叫 `Grounds`，也必须在类型和文稿中公开说明它只表达此程序片段；否则容易将程序完成性读成全规范合规。不能把此模型的 `AssessmentCompleted` 与冻结 T15 中承载更广责任的 `Evidence.Grounds` 未加区分地等同。 + +禁止的修补包括： + +- 令另一个无关 claim 成为 Grounds 见证，仍对 q 做坏选择； +- 把 reasons/limits 填几个字符串即判为依据充分； +- 假设 `Support(E,q)`，再投影“已支持”； +- 把 q 改成“StatusFirst 算法输出 A”的描述性命题，却仍宣称证明规范优先性； +- 加入“所有既有实现本来就应优先”的新规范桥接前提而不承认目标已改变； +- 把“正确发现支持不足”算成“未限定 q 已受充分支持”； +- 用空 claim、空解释域或没有实际使用理由的选择变量获得反例。 + +## 实际可运行验证及结果 + +本轮以 `rtk run` 调用 Python 对独立设计执行有限枚举；没有创建或读取 Lean。第一次探索脚本检查两个排列、理由非空和反模型；第二次完整脚本让 q 的报告回指同一 claim/理由，并实际计算报告正确性、Choice 必要条件和所建推论片段的相称性。第二次结果为： + +```text +{'candidates': 2, 'worlds': 2, 'reasons': 2, + 'same_claim_report_valid': True, + 'inference_entailed': False, + 'choice_status_exclusion_satisfied': False, + 'modeled_inferential_proportionality': False} +actual_assertions=pass; full normative Grounds compliance not claimed +``` + +第二次脚本的核心断言可以原样重跑： + +```sh +rtk run 'python3 - <<'"'"'PY'"'"' +from itertools import permutations +candidates=("A","B") +orders=tuple(permutations(candidates)) +status={"A":True,"B":False} +reasons=(("established","A",True),("established","B",False)) +worlds=tuple({"order":o,"status":status.copy()} for o in orders) +def E(w): return all(w["status"][i]==v for tag,i,v in reasons) +def q(w): return w["order"].index("A")`，记录完整命令、cwd、返回码和输出至该次 `rechecks/run-*/receipt.json`，不覆盖冻结结果；首次复核结果保留在 `final-recheck-receipt.json`。语义判断仍来自定义、实际证明和反模型；构建通过不会替代来源审查。 + +| 源文件 | SHA-256 | +| --- | --- | +| `CoreReader/Agency.lean` | `b0dca4187a88a0a0f33c3dd6a11bb383907603ef514e80e9e3f09f95ce9633e2` | +| `CoreReader/Choice.lean` | `07cf17f73802bdd34ae00ecba317ddc0283321cce00f15a84b69df421c3fe25f` | +| `CoreReader/Evidence.lean` | `18beb2b94450fdab36229b645e2df129348f3e67306104e842e0dce6e72443e8` | +| `CoreReader/Integration.lean` | `6821e55e284fcc69136a77adf9375b335e9b5f567d9124ef728e562d4b9eb4e1` | +| `CoreReader/Logic.lean` | `6b70be8964763b6447a2603bde665ff58106678f2e1d421bebd8c6b29ae46e04` | +| `CoreReader/Reflexivity.lean` | `25292faa71c5585a8f50cb07d72c2f44fa12dcfb125b2b92094f9306fecb4fd0` | +| `CoreReader.lean` | `80eee78ec3453fefdb26d3dbce97f0447d4b9ffeb4683604dad0c03902a1bfdd` | + +## 实际语义及关键限制 + +- Logic 的一致性依赖显式 admissible world、固定问题语义和情境；可满足性不能转成现实真值。空问题类型仍可使一致性空真，因此正见证使用具体非空问题与世界。报告定理投影已采纳的单向 TruthfulReport，不提供自动检测或充分报告。 +- Evidence 的 Grounds 逐项检查已声明适用的同一主张方面。它不自动发现全部实际适用方面。空适用列表或空起始理论不是一概非法；只有当它们被用来冒充实际必要内容时才构成对应错误。有限支持模型允许空观察支持逻辑有效命题，不因此宣称现实经验根据已充分。 +- 新 ValuePosition 将立场选项与结果、目标、约束、理由相连；JointAdoption 排除无可满足联合起点。ValueProcedure 是所选程序适配，不是普遍价值理论。Integration 的 positionConsequence 在给定操作模型内直接成立，证明会忽略传入的理由模型前提；这是更强的模型内后果证明，并非隐藏结论前提，也不意味着理由是这些后果的必要原因。实际理由、在适用限度内成立的批评、反选项失败和外部价值边界需同时阅读。 +- Reflexive 不再只是 subject/activity 配对存在性。它要求真实问题、目标、适用范围、理由、方法对应与结果；有限算法的 insufficient 结果可算一次正确履行评估职责，绝不是原则已经正确。生成的候选方法只是 MethodDraft，不声称已成为正确方法或在现实中执行。 +- 外援、稳定、公告与自产修订已绑定同一模型主体及相关对象。外部评估者编号是区分角色的数学数据，证书携带同一 process 的实际证明；没有建立现实身份认证、外部消息来源或人的理解。 +- JustifiedChoice 现在同时要求 Feasible 和相关理由。廉价但输出错误的 successor 说明“内部理由相关”不是“所有目标约束充分”。两个候选构成封闭比较类，不是所有可行实现的枚举。 +- Integration 的一般 GroundsProvision、当前哲学方法与变化应用合同都有真正对象关联。applicationRetainsDuties 是明确条件接口的投影；独立补充 applicationVariation 才给出同系统改变真实目标后的失败实例。没有把规范条件写成现实已履行。 + +## T23 的最后质疑与解除边界 + +首案只有 `statusFacts` 不蕴涵 `priorityClaim`，再合取 status-only 选择失败；这不足以提供独立可变的选择政策。修订后 `ChoicePolicy` 的 `priorityReasons` 与审查对象相互独立，两个政策保留同一 selected、同一非空事实理由、同一实际 priority 问题及正确的否定审查，而采用不同实际优先理由。`PolicyIndependenceExample` 证明一项符合额外选择规范、另一项不符合。该独立政策缺口已真实修复。 + +仍须区分两个前项：A 是完成所表示的理由评估程序，允许正确发现给定理由不蕴涵主张；G 是除额外 Choice 外全部实际适用 Grounds 责任充分履行，包括所有方面以及强度/范围与支持相称。`GeneralAssessmentFulfilled` 只包含表述、同一审查和准确性，因此模型证明 A∧¬C，并提供 A∧C 对照；没有证明 G∧¬C。从前者不能推出后者。 + +最终接受 A 范围有直接来源根据：原文 2.4 指定 “general requirement to assess reasons”，2.1 将评估解释为检查是否支持，而不是确保被评主张获得支持；冻结英文明确写 “represented general assessment obligations” 和 “qualify the model scope”。这不是仅凭函数名解释目标。原 source-first 中文末句“不包含该额外承诺的一般要求”确有被读为 G 的较强歧义，不能说原稿从未有歧义，也不能凭设计早于代码便断言完全等强。如果把该中文强读法作为额外合同，G 分支仍未完成；本次 accepted 不覆盖该强读法。后续来源澄清保留了这个历史差异，未改原稿或冻结哈希。 + +此外，`¬ Entails statusFacts priorityClaim` 只否定所表示的推论支持，不证明该价值优先主张恒假、缺乏所有可能价值理由或必然违反全部一般相称要求。反解释也没有加入全部实际应用可行性条件；不能把 successor 反世界说成在 identityRequirements 下同样可行。两个政策保持实际实现函数和已证明可辨识表现不变；这些事实本身不赋予额外价值优先规范。 + +如果读者稿写成“完整一般 Grounds 合规仍可仅凭地位正当地获得优先”或用 generalGroundsNotChoice 的名称省略上述 A/G 区别，该表述应 rejected，即使这次有限类型证明通过。 + +## 逐目标结果与首案变化 + +下表是阅读索引；`final-target-verdicts.json` 保留每个原 branch、原判定、原缺口与最小修正条件，并给当前陈述、真实声明行号、证明范围和修订依据。行号属于最终 7 文件，不复用历史空白副本的行号。 + +| 目标 | 首案 → 最终 | 最终依据与范围 | +| --- | --- | --- | +| T01 | accepted → accepted | 权威、采纳性质、来源全文及章节角色边界保留；这是来源与解释边界合格，不是哲学正确性定理。 | +| T02 | rejected → accepted | 同一个actualSystem/actual现在同时承载实质反身记录、实际能力与证据、可行选择和五项具有各自理由及限度的承诺。旧联合见证缺少的内容联系已经补齐。 | +| T03 | accepted → accepted | Generative保留采纳的扩展价值与所有当前形式可修订性；不会从规范接口推出真实变化或进步。 | +| T04 | accepted → accepted | neutralPolicy允许真正不同版本但不赋扩展价值，继续构成许可与价值取向的非蕴涵见证。 | +| T05 | accepted → accepted | 所有形式种类的条件覆盖及可修订而无进步的非空例子成立。 | +| T06 | rejected → accepted | 11分支均有同对象内容：三类数量膨胀不扩能，同一生成系统执行分别依赖经验/知识/协作，无外援失败，稳定动作保持所需能力并满足预算，自述对同一次变化的内容被反驳。 | +| T07 | rejected → accepted | 保留任意支持关系的条件推论，并新增同一次扩展的基线、测试条件、记录、非空兼容世界和Grounds；同一报告在膨胀反世界也成立，故报告不支持成就。 | +| T08 | accepted → accepted | 显式可满足前提支持同题同条件的一致性；三项各自可满足但联合冲突的实际见证保留。 | +| T09 | accepted → accepted | 撤回后反转、假设变化、术语含义变化和适用范围变化各自有非空实例，不要求跨条件永久兼容。 | +| T10 | accepted → accepted | 语义变化必须报告的条件规范、表示顺序不变、独立revisionIdentity变化和隐藏条件变化反例均保留。 | +| T11 | accepted → accepted | 具有共同可行解的张力与同条件不相容后果已区别；不保留冲突是已采纳一致性约束的后果。 | +| T12 | accepted → accepted | 模型可满足与指定实际世界为真不同；一个明确问题的正反结论均不蕴涵，故一致性不保证真或充分。 | +| T13 | rejected → accepted | Reflexive现在要求一致的原则登记、同所有者对象、实际问题/理由/范围/结果及方法契约；形成、应用、修订内容已由有限评估与生成函数实际计算。 | +| T14 | rejected → accepted | 无自我豁免和适用条件保留；有限自测仍不证明普遍正确；自产修订现在与同一owner、before和after相连且有局部变化但全局失败。 | +| T15 | rejected → accepted | Grounds逐方面要求同一主张、对应表述与履责；价值接口改为选项/结果/目标/约束/理由，并要求联合可采纳世界，消除了任意重贴commitment及不一致起点通过的问题。 | +| T16 | accepted → accepted | 义务并集、标签不能豁免以及同一switch主张的经验加价值缺责反例成立；canonical表述按方面实际内容构造。 | +| T17 | accepted → accepted | 表述清楚、测量/重复、相容与自述均有实际不足反模型；价值反例针对对应选项的预算后果，不能冒充价值命题恒假。 | +| T18 | accepted → accepted | 有限价值立场有可满足但无需自证的起点、选项相关理由、限度、后果和批评响应；两理由联合充分而各自不足，异类方面无需统一尺度。 | +| T19 | accepted → accepted | 真实观测域{0}内一致而在1不同的函数构成局部支持与普遍非支持；省略差异不能消除差异。 | +| T20 | accepted → accepted | 单次观察有限支持、无必需统一链的推论、不同结果保持指定界，以及核验/条件复现/结论稳定的分离均成立。 | +| T21 | rejected → accepted | 同一process的输出与附加解释要求分开，两种应用都有对应Grounds；外部证书携带不同评估者/被评者标识及该process实际输出证明；四类库存复制不扩展所表示能力。 | +| T22 | accepted → accepted | 在额外采纳的选择规范下三类纯身份理由均失败；既有惯用实现仍凭实际输出理由和可行性获接受。 | +| T23 | rejected → accepted | 新政策对象在相同且准确的否定审查后独立采用不同优先理由，完成所表示的一般理由审查而额外选择规范一成一败；通过严格限于冻结清单所称represented assessment obligations。 | +| T24 | accepted → accepted | 单一可行实现、不等价、局部相同全局不同及四种内部理由均有实例；新增廉价错误输出反例说明相关理由不是自动充分。 | +| T25 | rejected → accepted | Grounds承诺已扩展对应一般GroundsProvision而非一条能力义务；实际哲学方法绑定同系统原则形式和政策，并对两个提案计算选择，旧对象错配已消除。 | +| T26 | rejected → accepted | 取向不保证反身履行、Charter不提供某个能力证据包的支持，以及共享全接口正见证均成立；仅证明这些指定方向。 | +| T27 | rejected → accepted | 任意应用要求和合同的条件义务接口已参数化；补充applicationVariation对同一系统改变真实期望输出并证明旧证据失败；五项承诺由各自选项后果、理由和限度区分。 | +| T28 | accepted → accepted | 结构化推论评估给出真实n=2到n+1=3的根据且不要求经验测试；经验方面仍保留观察责任。 | + +## 来源条目判定 + +`final-source-entries.json` 提供全部 33 段的 fidelity、英文 reason 和对应 reason_zh。accepted 目标不自动把来源升级为 full；有限类型、规范接口及有限反模型与原文现实/规范范围的差异逐段保存。 + +`organon.preamble#p1` 是权威、采纳性质及非普遍正确性边界，判 not_applicable。它虽被 T02/jointWitness 作背景范围引用，jointWitness 只遵守该阅读边界并展示所采纳接口的相容实例，不证明元层权威声明。背景引用不能强迫这段成为数学证明源；schema 如把这种引用等同 formal proof coverage，应修复角色适配而不是硬升 fidelity。`organon.charter.overview#p1` 是三标题结构列表，亦不适用。其余 31 段有实际有限对应且保留未形式化部分，故 partial；没有全段 full。 + +## 逐行稿与交付边界 + +本人生成的 informed 英中逐行片段覆盖 `CoreReader.lean`、Agency、Reflexivity、Integration 的全部 1141 个非空行，包括来源映射注释，键是精确相对路径与 1-based 行号。根文件 1 行、Agency 251 行、Reflexivity 367 行、Integration 522 行。空白行无说明。英文说明解释实际语义和证明步骤，中文按同一结构翻译；canonical articulation 表示按已有内容构造表述，不是新添哲学规范。 + +Logic/Evidence/Choice 的最终逐行稿由另一个获委派的 informed 稿件作者提供；本人独立读取并审查其模型语义，但不冒称本次片段已包含那三文件。Root 合并及读者任务验证属于后续整套读者交付检查。本报告不提前断言合并稿已经通过。 + +没有编辑模型或哲学原文，没有删除或覆盖初始判断。此次比较不对未提供的更晚候选、未来修改或现实部署生效。 diff --git a/lean/philosophy/reviews/code-review-identity.json b/lean/philosophy/reviews/code-review-identity.json new file mode 100644 index 0000000..aa0b3bd --- /dev/null +++ b/lean/philosophy/reviews/code-review-identity.json @@ -0,0 +1,52 @@ +{ + "review_kind": "informed revision comparison, not blind", + "snapshot": "Core/private historical check objects/2026-09-14T03-53-09.030Z-12298-3c6aab", + "target_statuses": { + "accepted": 28, + "rejected": 0, + "pending": 0 + }, + "target_scope": "T23 accepted for represented finite assessment duties A only; stronger full non-Choice Grounds G independence is not established", + "source_statuses": { + "partial": 31, + "full": 0, + "not_applicable": 2, + "rejected": 0, + "pending": 0 + }, + "line_fragments": { + "files": [ + "CoreReader.lean", + "CoreReader/Agency.lean", + "CoreReader/Reflexivity.lean", + "CoreReader/Integration.lean" + ], + "nonempty_lines": 1141, + "coverage": "Agency/Reflexivity/Integration/root only; remaining three modules authored separately" + }, + "historical_preserved_sha256": { + "BLIND-INITIAL.md": "2575d7f5963e22b2729ac837d30d54e302f63085588030bb25f5ea1961173484", + "code-explanations-en.json": "e00bf3e4a16265caea1d065d4103c7dff08235949054efe084308446863a754e", + "SOURCE-COMPARISON-INITIAL.md": "7f43edcb8eeefb62f102fde11c239c5f7e286e26c5413dbb59d07bc965d4c273", + "target-verdicts-initial.json": "e29e5e008c4b84268c8be97c82687c00edb6d83993e4cef05a330c1e4e43ecb9" + }, + "inputs_sha256": { + "Core/PHILOSOPHY.md": "1a0bebd61e35d46a3ba2e882305ce60f423e37a343ecdfd0b6f314e437aade59", + "Core/private maintenance records/source-first.md": "9d6db04489a10a5aab217601ad69f006d4fd1ee1183aec9a7314764b4c3d8afd", + "Core/private maintenance records/targets-frozen.json": "35cda8ba439af8b32fd180efae2829b370bc5b82960cc91feb24e3e03636d2f4", + "Core/private maintenance records/source-paragraphs.json": "011581c7b79823bf0a68275cd7b695ba074a1a027fbe7063d29f7b3f6bf8dab8", + "Core/private maintenance records/source-first-T23-design.md": "58486132f6c712c9db3c2a2dc0f159f2a02fd98de5c825d899effbe8d5cd35c4", + "Core/private maintenance records/T23-scope-reconciliation.md": "e5faa35d911bddd1100fb16a9b2d651adf4c6fd34ddc8262ae7a38b5428c59c8" + }, + "artifacts_sha256": { + "final-target-verdicts.json": "bc7832edfe322293783a91b0583edbeff1435e4ff8c62d182a6a7ad7a32c0a77", + "final-source-entries.json": "5e5dd7f82844deb10f246bb83f427a77720a0a39e95a4d64a394b9b7219411df", + "final-source-comparison.md": "8676b4e3f63cb3868bdec79e49ed4bd0ead2006ae6fde659dde64159a5bacaa2", + "code-explanations-final-en-part.json": "d8743576726a90b5fc4bd40ca2df65265764e1e615f32eb56054ec9a7b8c4311", + "code-explanations-final-zh-part.json": "35050657e105df084b4836f9073f56daf5ab634a0fb4f3217d488f3ef2d72fd0", + "final-execution-checks-v3.json": "cc25d759d0c2a081bda9f96fe669ce1d09f18d7ad189c861656ebf2cae1e1d22", + "final-recheck-receipt.json": "531dd734fcbcd5c2c2d694225bf9ad825290c255bfbaf49e30367b221b741c04", + "recheck-final.py": "969ec8fc4f0998044e0576395c27146903f02492c590d26c2f5a556b9d084457", + "FinalReviewCheck.lean": "e7037edf17953820b4b05c4a52c9b71ec18bf71d611bf6fb0d9e0eaab86be1d4" + } +} diff --git a/lean/philosophy/reviews/code-source-entries-final.json b/lean/philosophy/reviews/code-source-entries-final.json new file mode 100644 index 0000000..18d2870 --- /dev/null +++ b/lean/philosophy/reviews/code-source-entries-final.json @@ -0,0 +1,353 @@ +[ + { + "id": "organon.preamble#p1", + "fidelity": "not_applicable", + "reason": "This declares textual authority and adopted-commitment scope, not a mathematical proposition about all systems. The review retains this boundary without manufacturing a Lean theorem of authority.", + "reason_zh": "本段声明文本权威与采纳承诺的范围，并非关于所有系统的数学命题。审查保留该边界，不制造证明文本权威的Lean定理。", + "targets": [ + "T01", + "T02" + ], + "mapping_role": "authority-and-adoption-boundary; linked declarations illustrate compliance with this reading, not a proof of the boundary" + }, + { + "id": "organon.preamble#p2", + "fidelity": "partial", + "reason": "The shared model exhibits compatible constraints without a chapter-priority inference. Authority of meanings and limits, the role of Rationale and revisability of actual skills remain textual commitments outside this finite witness.", + "reason_zh": "共享模型展示约束可以共同成立，未从章节位置推出优先性。含义与限度的权威、Rationale的角色及实际技能可修订性仍是有限见证之外的文本承诺。", + "targets": [ + "T01", + "T02" + ] + }, + { + "id": "organon.charter.overview#p1", + "fidelity": "not_applicable", + "reason": "This is a structural list of three headings. It organizes substantive provisions and requires no fabricated theorem.", + "reason_zh": "本段是列出三项标题的结构性文本，用于组织实质条款，无需虚构定理。", + "targets": [ + "T01" + ], + "mapping_role": "structural-heading" + }, + { + "id": "organon.charter.overview#p2", + "fidelity": "partial", + "reason": "jointWitness combines valued expansion, revisability, contextual consistency and contentful owned principle work in one inhabited system. It proves model satisfiability, not actual compliance by arbitrary systems.", + "reason_zh": "jointWitness在同一非空系统中组合扩展价值、可修订性、情境一致性和具有内容的自有原则工作；它证明模型可满足，不证明任意现实系统履行这些要求。", + "targets": [ + "T01", + "T02", + "T03" + ] + }, + { + "id": "organon.charter.overview#p3", + "fidelity": "partial", + "reason": "The three requirements remain distinct predicates with a shared example and specific nonentailments. Their interpretation as philosophical obligations and their full conditions in arbitrary applications are not derived from the example.", + "reason_zh": "三项要求保留为不同谓词，并有共享实例和特定非蕴涵结果。其作为哲学义务的解释及任意应用中的完整条件，不能由实例推出。", + "targets": [ + "T01", + "T02", + "T03" + ] + }, + { + "id": "organon.charter.self-transcendence#p1", + "fidelity": "partial", + "reason": "Generative specifies valuation and revisability of current forms. The finite tags and state examples do not characterize every form of understanding, construction or intrinsic orientation.", + "reason_zh": "Generative规定对扩展的赋值及当前形式的可修订性。有限标签和状态实例没有刻画理解、构造或内在取向的全部形式。", + "targets": [ + "T03" + ] + }, + { + "id": "organon.charter.self-transcendence.orientation#p1", + "fidelity": "partial", + "reason": "The neutral-policy counterexample separates permission for distinct versions from the adopted valuation predicate. It does not establish what every real system values or justify the adopted value universally.", + "reason_zh": "中性政策反例把不同版本的变更许可与采纳的价值谓词分开；它不确立每个现实系统重视什么，也不普遍证成所采纳的价值。", + "targets": [ + "T03", + "T04" + ] + }, + { + "id": "organon.charter.self-transcendence.non-finality#p1", + "fidelity": "partial", + "reason": "All five represented form kinds, including organization, method and principle, fall under conditional revisability; a constant trace shows no progress guarantee. The chosen representation is not an exhaustive ontology or an executed revision.", + "reason_zh": "五类已表示的形式包括组织、方法和原则，均受条件性可修订要求约束；常值轨迹说明不保证进步。该表示不是穷尽性本体分类，也不是已经执行的修订。", + "targets": [ + "T03", + "T05" + ] + }, + { + "id": "organon.charter.self-transcendence.limits#p1", + "fidelity": "partial", + "reason": "The same before/after states increase inventory, abstraction and vocabulary without adding represented capabilities. Actual performance records can distinguish a genuine extension in a two-case world; empirical reliability beyond that world is not proved.", + "reason_zh": "同一前后状态增加库存、抽象层级和词汇，却未增加已表示的能力。实际表现记录能在两类世界中区分真正扩展，但没有证明该世界之外的经验可靠性。", + "targets": [ + "T03", + "T06", + "T07" + ] + }, + { + "id": "organon.charter.self-transcendence.limits#p2", + "fidelity": "partial", + "reason": "Bound execution exhibits separate external dependencies, grounded stability, a nonimproving trace and a refuted owned announcement. These are finite compatibility and failure examples; philosophical adoption and real autonomous development remain outside their conclusions.", + "reason_zh": "绑定的执行接口分别展示外部依赖、有根据的稳定、无改善轨迹及被反驳的自有报告。这些是有限相容性与失败实例，哲学采纳和现实自主发展不在其结论范围内。", + "targets": [ + "T03", + "T06", + "T07" + ] + }, + { + "id": "organon.charter.consistency#p1", + "fidelity": "partial", + "reason": "The general semantic theorem prevents opposite consequences under one theory/context when an admissible world exists. Existence of such a world, choice of questions and interpretation of held judgments are explicit modeling conditions, not guaranteed for reality.", + "reason_zh": "一般语义定理在存在可容许世界时，排除同一理论和情境中的正反后果。该世界存在、问题选择及所持判断的解释都是明确建模条件，不是现实保证。", + "targets": [ + "T08" + ] + }, + { + "id": "organon.charter.consistency.meaning#p1", + "fidelity": "partial", + "reason": "Concrete retraction slices can reverse judgments, and a conditional reporting specification disallows concealing recognized change. No automatic detector, adequate report generator or real revision history is established.", + "reason_zh": "具体撤回切片允许判断反转，条件性报告规范排除隐瞒已识别变化；没有确立自动检测器、充分报告生成器或现实修订历史。", + "targets": [ + "T09", + "T10" + ] + }, + { + "id": "organon.charter.consistency.meaning#p2", + "fidelity": "partial", + "reason": "Separate assumption, meaning and scope changes admit different judgments; hidden changes fail the adopted report condition. This covers explicit semantic models, not every practical ambiguity or method of concealment.", + "reason_zh": "假设、含义和范围的分别变化允许不同判断；隐藏变化违反采纳的报告条件。结果覆盖明确语义模型，不覆盖全部实际歧义或隐瞒方式。", + "targets": [ + "T09", + "T10" + ] + }, + { + "id": "organon.charter.consistency.limits#p1", + "fidelity": "partial", + "reason": "Finite witnesses distinguish tension from contradiction and consistency from truth or completeness. Refusing to retain a demonstrated conflict is a conditional consequence of an adopted consistency requirement, not an implemented revision strategy.", + "reason_zh": "有限见证区分张力与矛盾、一致性与真或完整性。不保留已示冲突是采纳一致性要求后的条件后果，不是已经实现的修订策略。", + "targets": [ + "T11", + "T12" + ] + }, + { + "id": "organon.charter.reflexivity#p1", + "fidelity": "partial", + "reason": "Reflexive quantifies applicable owned rules and subjects, with coherent keys and meaningful application records. The concrete rule set has generation and assessment work but does not cover every possible real principle.", + "reason_zh": "Reflexive量化适用的自有规则和对象，并要求一致的标识与有意义的适用记录。具体规则集包含生成和评估工作，但不覆盖所有可能的现实原则。", + "targets": [ + "T13" + ] + }, + { + "id": "organon.charter.reflexivity.meaning#p1", + "fidelity": "partial", + "reason": "The revised module models formation purposes, requested applicability scopes and revision counterexamples with actual evaluation and generation outcomes. These finite inquiry contracts do not establish the correctness or completeness of every assessment methodology.", + "reason_zh": "修订模块通过实际评估和生成结果表示形成目的、待考察适用范围和修订反例。这些有限问题契约不确立所有评估方法的正确性或完整性。", + "targets": [ + "T13" + ] + }, + { + "id": "organon.charter.reflexivity.limits#p1", + "fidelity": "partial", + "reason": "Applicability is retained, self-exemption fails where conditions hold, and finite self-tests plus a produced revision fail to establish universal support. The owned records and source identities are mathematical objects, not authenticated execution histories.", + "reason_zh": "适用性得到保留，条件成立时不能自我豁免；有限自测和自产修订不能确立普遍支持。自有记录和来源标识是数学对象，不是经过认证的执行历史。", + "targets": [ + "T13", + "T14" + ] + }, + { + "id": "organon.grounds#p1", + "fidelity": "partial", + "reason": "Grounds checks identified applicable facets of the same claim; support, entailment and an option-indexed value procedure carry distinct responsibilities. This is a chosen formal interface and finite fulfillment examples, not a universal sufficient criterion for all philosophical grounds.", + "reason_zh": "Grounds检查同一主张的已识别适用方面；支持、蕴涵及选项相关价值程序承担不同责任。它是选定的形式接口与有限履责实例，不是所有哲学根据的普遍充分标准。", + "targets": [ + "T07", + "T15" + ] + }, + { + "id": "organon.grounds.assessment#p1", + "fidelity": "partial", + "reason": "Articulation content is linked to each facet and separated from its discharge; union and missing-aspect examples prevent labels from waiving represented duties. Identifying every actually relevant aspect remains an application responsibility not solved by the datatype.", + "reason_zh": "表述内容与每个方面相连，并与该方面的履责分开；并集和缺失方面实例防止标签豁免已表示义务。识别所有实际相关方面仍是应用责任，不能由数据类型解决。", + "targets": [ + "T15", + "T16", + "T17", + "T18", + "T28" + ] + }, + { + "id": "organon.grounds.assessment#p2", + "fidelity": "partial", + "reason": "The three modeled adapters check observational compatibility/support, semantic entailment, and value reasons with limits/consequences/criticism. Actual relevance, empirical uncertainty and the adequacy of value criticism beyond the chosen cases are not exhaustively formalized.", + "reason_zh": "三个已建模适配接口分别检查观察相容性与支持、语义蕴涵，以及带限度、后果和批评的价值理由。所选案例之外的实际相关性、经验不确定性和价值批评充分性没有被穷尽形式化。", + "targets": [ + "T15", + "T16", + "T17", + "T18", + "T28" + ] + }, + { + "id": "organon.grounds.assessment#p3", + "fidelity": "partial", + "reason": "JointAdoption requires consistent instantiated starting commitments without proving all starting assumptions. A two-reason example and heterogeneous facets avoid a universal numerical scale. They demonstrate procedural consistency, not ultimate value justification.", + "reason_zh": "JointAdoption要求起始承诺有一致的实例，而不证明所有起始假设。双理由实例和异类方面避免使用统一数值尺度；它们展示程序一致性，不提供终极价值证成。", + "targets": [ + "T15", + "T16", + "T17", + "T18", + "T28" + ] + }, + { + "id": "organon.grounds.scope#p1", + "fidelity": "partial", + "reason": "A proper local observation scope supports a local function claim while admitting a counterexample outside it. This establishes the specified nonentailment; it neither identifies all relevant real differences nor rules out justified wider evidence.", + "reason_zh": "真子域内的局部观察支持局部函数主张，同时容许域外反例。结果确立指定的非蕴涵，不识别所有现实相关差异，也不排除有根据的更广证据。", + "targets": [ + "T19", + "T20" + ] + }, + { + "id": "organon.grounds.scope#p2", + "fidelity": "partial", + "reason": "Repeated irrelevant measurements fail support, while a valid inferential assessment needs no empirical chain. This refutes a universal mandatory chain within the represented responsibilities but does not characterize every framework or measurement practice.", + "reason_zh": "重复无关测量不能提供支持，而有效推论评估无需经验链条。这在已表示责任中反驳统一必需链条，但不刻画所有框架或测量实践。", + "targets": [ + "T19", + "T20" + ] + }, + { + "id": "organon.grounds.scope#p3", + "fidelity": "partial", + "reason": "A single observation has limited support and distinct trial outcomes preserve a fixed bound. Verification, reproducible conditions and conclusion stability use separate predicates; no probability distribution or general reproducibility law is proved.", + "reason_zh": "单次观察具有有限支持，不同试验结果保持固定界。核验、可复现条件和结论稳定使用不同谓词；没有证明概率分布或一般复现规律。", + "targets": [ + "T19", + "T20" + ] + }, + { + "id": "organon.grounds.capabilities#p1", + "fidelity": "partial", + "reason": "Output-only and explanation-bearing contracts concern the same process and each has its own checked Grounds; applicationVariation changes the actual objective and invalidates old evidence. No uniform real mastery or capability-level definition is derived.", + "reason_zh": "仅输出合同和附加解释合同针对同一过程，各有经过检查的Grounds；applicationVariation改变实际目标并使旧证据失效。没有推导现实中统一的方法掌握或能力等级定义。", + "targets": [ + "T07", + "T21" + ] + }, + { + "id": "organon.grounds.capabilities#p2", + "fidelity": "partial", + "reason": "A distinct assessor role supplies a proof about the exact output process while no explanation certificate is attached; duplicating four inventory kinds leaves represented capability unchanged. Role numbers and certificates do not prove external provenance or human-like understanding.", + "reason_zh": "不同评估者角色为确切输出过程提供证明，而该过程没有附带解释证书；复制四类库存不改变已表示能力。角色编号和证书不证明外部来源或类似人的理解。", + "targets": [ + "T07", + "T21" + ] + }, + { + "id": "organon.grounds.implementations#p1", + "fidelity": "partial", + "reason": "The adopted choice interface requires feasibility and an objective/value/constraint-linked reason and rejects status-only reasons. Its finite reason vocabulary and concrete feasibility checks do not supply a general theory of warranted real implementation choice.", + "reason_zh": "采纳的选择接口要求可行性及与目标、价值、约束相连的理由，并拒绝纯地位理由。有限理由词汇和具体可行性检查不构成现实实现选择的一般证成理论。", + "targets": [ + "T22", + "T23" + ] + }, + { + "id": "organon.grounds.implementations#p2", + "fidelity": "partial", + "reason": "Two independent policies share a correct negative audit but differ on the added choice norm, establishing independence from the represented assessment procedure. This does not show an unsupported priority claim fully satisfies general Grounds, or derive a value commitment from neutral facts.", + "reason_zh": "两个独立政策共享正确的否定审查，却对额外选择规范一成一败，确立相对于已表示评估程序的独立性。这不表明无支持的优先主张完全满足一般Grounds，也不从中性事实推出价值承诺。", + "targets": [ + "T22", + "T23" + ] + }, + { + "id": "organon.grounds.implementations.limits#p1", + "fidelity": "partial", + "reason": "Concrete cases have one feasible candidate, unequal implementations, local agreement with wider difference and four eligible internal reasons. A cheap wrong-output method shows eligibility alone is insufficient. These results concern selected candidates and contracts, not all methods.", + "reason_zh": "具体案例展示唯一可行候选、不等价实现、局部相同而更广范围不同，以及四种合格内部理由。廉价但输出错误的方法说明理由合格并不足够。结果针对所选候选和合同，不覆盖所有方法。", + "targets": [ + "T24" + ] + }, + { + "id": "organon.relationships.roles#p1", + "fidelity": "partial", + "reason": "One shared model combines the charter and Grounds and assigns five commitments distinct operational reasons, limits and live criticism. Specified nonentailments prevent chapter order from doing logical work; neither the universal adoption nor ultimate justification of all commitments follows.", + "reason_zh": "一个共享模型组合章程与Grounds，并为五项承诺赋予不同的操作性理由、限度和实际批评。指定非蕴涵防止章节顺序承担推理作用；所有承诺的普遍采纳或终极证成并不随之成立。", + "targets": [ + "T02", + "T12", + "T23", + "T25", + "T26", + "T27" + ] + }, + { + "id": "organon.relationships.roles#p2", + "fidelity": "partial", + "reason": "Consistency/support and orientation/capability remain separate; changing an application objective changes its actual claim and can defeat retained evidence. Universal application compliance is only an assumed conditional interface, not an achieved fact.", + "reason_zh": "一致性与支持、取向与能力保持分离；改变应用目标会改变实际主张，并可能使保留证据失败。普遍应用履责仅由有前提的条件接口表达，不是已经实现的事实。", + "targets": [ + "T02", + "T12", + "T23", + "T25", + "T26", + "T27" + ] + }, + { + "id": "organon.relationships.roles#p3", + "fidelity": "partial", + "reason": "Contentful self-application, exact own-capability assessment, the general Grounds provision and the same current philosophy method are linked in the model. Their checked coexistence supplies no self-proof, real execution guarantee or unconditional applicability.", + "reason_zh": "模型连接具有内容的自我适用、确切自有能力评估、一般Grounds条款与同一个当前哲学方法。经过检查的共同成立不提供自证、现实执行保证或无条件适用性。", + "targets": [ + "T02", + "T12", + "T23", + "T25", + "T26", + "T27" + ] + }, + { + "id": "organon.relationships.terms#p1", + "fidelity": "partial", + "reason": "FormKind includes organization, methods and principles, and an inferential assessment has no executable-test requirement. These representations illustrate the terms without exhaustively defining every existing form or every non-test assessment.", + "reason_zh": "FormKind包含组织、方法和原则，推论评估没有可执行测试要求。这些表示说明术语，但未穷尽定义所有既有形式或所有非测试评估。", + "targets": [ + "T05", + "T28" + ] + } +] diff --git a/lean/philosophy/reviews/code-targets-final.json b/lean/philosophy/reviews/code-targets-final.json new file mode 100644 index 0000000..d9a6351 --- /dev/null +++ b/lean/philosophy/reviews/code-targets-final.json @@ -0,0 +1,2731 @@ +[ + { + "id": "T01", + "status": "accepted", + "reason": "权威、采纳性质、来源全文及章节角色边界保留；这是来源与解释边界合格，不是哲学正确性定理。", + "reason_en": "No theorem establishes textual authority or universal adoption. All source meanings and limits remain authoritative; chapter order supplies no proof priority.", + "reason_zh": "权威、采纳性质、来源全文及章节角色边界保留；这是来源与解释边界合格，不是哲学正确性定理。", + "classification": "N/E-V boundary", + "previous_status": "accepted", + "previous_reason": "来源、规范/事实及章节角色边界得到保留；本项通过仅表示边界和来源记录合格，不代表其余27项目全部实现。", + "source_refs": [ + { + "unit": "organon.preamble", + "clause": "p1" + }, + { + "unit": "organon.preamble", + "clause": "p2" + }, + { + "unit": "organon.charter.overview", + "clause": "p1" + }, + { + "unit": "organon.charter.overview", + "clause": "p2" + }, + { + "unit": "organon.charter.overview", + "clause": "p3" + } + ], + "required_declarations": [], + "proof_and_scope": "No theorem establishes textual authority or universal adoption. All source meanings and limits remain authoritative; chapter order supplies no proof priority.", + "findings": [ + { + "branch": "authority", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "原文SHA与冻结目标一致。数学类型不包含“所有现实系统都遵守”或哲学普遍正确性结论。", + "previous_minimal_fix": null, + "current_analysis": "权威、采纳性质、来源全文及章节角色边界保留；这是来源与解释边界合格，不是哲学正确性定理。 No theorem establishes textual authority or universal adoption. All source meanings and limits remain authoritative; chapter order supplies no proof priority.", + "current_code": [], + "minimal_fix": null + }, + { + "branch": "meanings-and-limits-record", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "22单元含义、条件、表格和bullet均作为来源保留；具体语义实现缺口在相应T项判定，不能由本项通过抹去。", + "previous_minimal_fix": null, + "current_analysis": "权威、采纳性质、来源全文及章节角色边界保留；这是来源与解释边界合格，不是哲学正确性定理。 No theorem establishes textual authority or universal adoption. All source meanings and limits remain authoritative; chapter order supplies no proof priority.", + "current_code": [], + "minimal_fix": null + }, + { + "branch": "roles-and-headings", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "Charter/Relationships标题未被制造为True定理；来源明确Rationale/Skills不增加核心义务，组合代码未赋章节顺序以演绎权威。", + "previous_minimal_fix": null, + "current_analysis": "权威、采纳性质、来源全文及章节角色边界保留；这是来源与解释边界合格，不是哲学正确性定理。 No theorem establishes textual authority or universal adoption. All source meanings and limits remain authoritative; chapter order supplies no proof priority.", + "current_code": [], + "minimal_fix": null + } + ] + }, + { + "id": "T02", + "status": "accepted", + "reason": "同一个actualSystem/actual现在同时承载实质反身记录、实际能力与证据、可行选择和五项具有各自理由及限度的承诺。旧联合见证缺少的内容联系已经补齐。", + "reason_en": "jointWitness constructs a single system/world, not five unrelated existence claims. It uses computed identity output, actual observation support, coherent owned principle work, and each option-indexed commitment procedure. This is one finite satisfiability witness.", + "reason_zh": "同一个actualSystem/actual现在同时承载实质反身记录、实际能力与证据、可行选择和五项具有各自理由及限度的承诺。旧联合见证缺少的内容联系已经补齐。", + "classification": "W satisfiability plus N interpretation", + "previous_status": "rejected", + "previous_reason": "jointWitness确有非空数学见证，但其反身工作与各承诺理由未达到冻结的共享、内容对应模型；较弱接口的可满足性不能算所选Core规范已联合满足。", + "source_refs": [ + { + "unit": "organon.preamble", + "clause": "p1" + }, + { + "unit": "organon.preamble", + "clause": "p2" + }, + { + "unit": "organon.charter.overview", + "clause": "p2" + }, + { + "unit": "organon.charter.overview", + "clause": "p3" + }, + { + "unit": "organon.relationships.roles", + "clause": "p1" + }, + { + "unit": "organon.relationships.roles", + "clause": "p2" + }, + { + "unit": "organon.relationships.roles", + "clause": "p3" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Integration.jointWitness", + "kind": "case", + "location": "CoreReader/Integration.lean:595", + "meaning": "Constructs one shared system/world satisfying actual judgments, full reflexivity, capability evidence, feasible choice and each interpreted commitment's Grounds; it is a bounded model, not universal philosophical correctness." + } + ], + "proof_and_scope": "jointWitness constructs a single system/world, not five unrelated existence claims. It uses computed identity output, actual observation support, coherent owned principle work, and each option-indexed commitment procedure. This is one finite satisfiability witness.", + "findings": [ + { + "branch": "inhabited-world-and-judgments", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "actual提供真实模型；held有能力和预算命题，观察在两个候选内识别identity，非空且非全真记录占位。", + "previous_minimal_fix": null, + "current_analysis": "同一个actualSystem/actual现在同时承载实质反身记录、实际能力与证据、可行选择和五项具有各自理由及限度的承诺。旧联合见证缺少的内容联系已经补齐。 jointWitness constructs a single system/world, not five unrelated existence claims. It uses computed identity output, actual observation support, coherent owned principle work, and each option-indexed commitment procedure. This is one finite satisfiability witness.", + "current_code": [ + "CoreReader/Integration.lean:595" + ], + "minimal_fix": null + }, + { + "branch": "shared-capability-and-choice", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "相同implementation用于capability、budget、observation和output choice；这一部分确有模块交互，观察推广限于封闭候选类。", + "previous_minimal_fix": null, + "current_analysis": "同一个actualSystem/actual现在同时承载实质反身记录、实际能力与证据、可行选择和五项具有各自理由及限度的承诺。旧联合见证缺少的内容联系已经补齐。 jointWitness constructs a single system/world, not five unrelated existence claims. It uses computed identity output, actual observation support, coherent owned principle work, and each option-indexed commitment procedure. This is one finite satisfiability witness.", + "current_code": [ + "CoreReader/Integration.lean:595" + ], + "minimal_fix": null + }, + { + "branch": "principle-process-content", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "五个对象/两种活动确非空，但Performed仅pair会员关系，原则形成理由、适用域考察和修订理由没有可表达内容；预填记录不足以完成冻结的内容性对象分支。", + "previous_minimal_fix": "补充与这些subject相连的实际评估问题/理由/范围/结果对象，并用非空记录验证相应义务；不要求现实系统已经运行。", + "current_analysis": "Reflexivity.lean:128、151、287、318、366要求并构造含问题、理由、限度和实际计算结果的ValidApplication；Integration.lean:124、129将同owner/rules/work接入Charter。", + "current_code": [ + "CoreReader/Integration.lean:595" + ], + "minimal_fix": null + }, + { + "branch": "individual-commitment-reasons", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "generation理由是两函数在0输出不同，仅推出存在不同输入；Grounds承诺字段可任意重贴而ValueProcedure不变。因此联合对象尚未提供每项承诺自身理由。", + "previous_minimal_fix": "建立每项承诺与其理由、限度及批评响应的可审查联系，保留价值承诺不必被证明为事实的边界。", + "current_analysis": "Integration.lean:282、356、364、377、389、423将各承诺的选项、后果、约束、理由及实际批评相连；反选项程序失败。", + "current_code": [ + "CoreReader/Integration.lean:595" + ], + "minimal_fix": null + }, + { + "branch": "no-priority-from-conjunction", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "合取本身未推出章节优先级或普遍哲学正确性。", + "previous_minimal_fix": null, + "current_analysis": "同一个actualSystem/actual现在同时承载实质反身记录、实际能力与证据、可行选择和五项具有各自理由及限度的承诺。旧联合见证缺少的内容联系已经补齐。 jointWitness constructs a single system/world, not five unrelated existence claims. It uses computed identity output, actual observation support, coherent owned principle work, and each option-indexed commitment procedure. This is one finite satisfiability witness.", + "current_code": [ + "CoreReader/Integration.lean:595" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T03", + "status": "accepted", + "reason": "Generative保留采纳的扩展价值与所有当前形式可修订性；不会从规范接口推出真实变化或进步。", + "reason_en": "Policy fields remain independent predicates. Generative requires the adopted aim and current-form revisability; it neither executes a transition nor guarantees Expanded.", + "reason_zh": "Generative保留采纳的扩展价值与所有当前形式可修订性；不会从规范接口推出真实变化或进步。", + "classification": "N specification", + "previous_status": "accepted", + "previous_reason": "Generative作为明确采纳的有限规范接口保留价值取向与当前形式可修订性，未内置必然变化或进步。", + "source_refs": [ + { + "unit": "organon.charter.overview", + "clause": "p2" + }, + { + "unit": "organon.charter.overview", + "clause": "p3" + }, + { + "unit": "organon.charter.self-transcendence", + "clause": "p1" + }, + { + "unit": "organon.charter.self-transcendence.orientation", + "clause": "p1" + }, + { + "unit": "organon.charter.self-transcendence.non-finality", + "clause": "p1" + }, + { + "unit": "organon.charter.self-transcendence.limits", + "clause": "p1" + }, + { + "unit": "organon.charter.self-transcendence.limits", + "clause": "p2" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Agency.Generative", + "kind": "definition", + "location": "CoreReader/Agency.lean:33", + "meaning": "A policy satisfies this predicate when it values the designated expansion aim and declares every current form revisable. This states no actual progress condition." + } + ], + "proof_and_scope": "Policy fields remain independent predicates. Generative requires the adopted aim and current-form revisability; it neither executes a transition nor guarantees Expanded.", + "findings": [ + { + "branch": "orientation", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "worthPursuing选择理解/构造扩展这一被采纳目标；与permitsVersion字段独立。", + "previous_minimal_fix": null, + "current_analysis": "Generative保留采纳的扩展价值与所有当前形式可修订性；不会从规范接口推出真实变化或进步。 Policy fields remain independent predicates. Generative requires the adopted aim and current-form revisability; it neither executes a transition nor guarantees Expanded.", + "current_code": [ + "CoreReader/Agency.lean:33" + ], + "minimal_fix": null + }, + { + "branch": "nonfinal-current-forms", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "∀current form→revisable覆盖组织/方法/原则及外观/产物；没有预装严格改善序列。", + "previous_minimal_fix": null, + "current_analysis": "Generative保留采纳的扩展价值与所有当前形式可修订性；不会从规范接口推出真实变化或进步。 Policy fields remain independent predicates. Generative requires the adopted aim and current-form revisability; it neither executes a transition nor guarantees Expanded.", + "current_code": [ + "CoreReader/Agency.lean:33" + ], + "minimal_fix": null + }, + { + "branch": "no-actual-success-guarantee", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "定义不含实际transition或Expanded证明；无进步trace提供边界。", + "previous_minimal_fix": null, + "current_analysis": "Generative保留采纳的扩展价值与所有当前形式可修订性；不会从规范接口推出真实变化或进步。 Policy fields remain independent predicates. Generative requires the adopted aim and current-form revisability; it neither executes a transition nor guarantees Expanded.", + "current_code": [ + "CoreReader/Agency.lean:33" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T04", + "status": "accepted", + "reason": "neutralPolicy允许真正不同版本但不赋扩展价值，继续构成许可与价值取向的非蕴涵见证。", + "reason_en": "The version pair 0 and 1 is distinct and permitted, whereas the required valuation is false. Permission is not execution or actual improvement.", + "reason_zh": "neutralPolicy允许真正不同版本但不赋扩展价值，继续构成许可与价值取向的非蕴涵见证。", + "classification": "W nonentailment", + "previous_status": "accepted", + "previous_reason": "明确非空政策允许不同版本对，但完全不赋扩展价值，足以区分许可与价值取向。", + "source_refs": [ + { + "unit": "organon.charter.self-transcendence.orientation", + "clause": "p1" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Agency.permissionNotValuation", + "kind": "case", + "location": "CoreReader/Agency.lean:49", + "meaning": "Shows permission for version 0 to 1 and distinct versions coexist with failure of the generation predicate." + } + ], + "proof_and_scope": "The version pair 0 and 1 is distinct and permitted, whereas the required valuation is false. Permission is not execution or actual improvement.", + "findings": [ + { + "branch": "permissible-nontrivial-change", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "允许0→1且0≠1；证明许可，不声称此变化已执行。", + "previous_minimal_fix": null, + "current_analysis": "neutralPolicy允许真正不同版本但不赋扩展价值，继续构成许可与价值取向的非蕴涵见证。 The version pair 0 and 1 is distinct and permitted, whereas the required valuation is false. Permission is not execution or actual improvement.", + "current_code": [ + "CoreReader/Agency.lean:49" + ], + "minimal_fix": null + }, + { + "branch": "valuation-independent", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "Generative因所需价值取向为False而失败；不是将两个概念写成同一布尔量。", + "previous_minimal_fix": null, + "current_analysis": "neutralPolicy允许真正不同版本但不赋扩展价值，继续构成许可与价值取向的非蕴涵见证。 The version pair 0 and 1 is distinct and permitted, whereas the required valuation is false. Permission is not execution or actual improvement.", + "current_code": [ + "CoreReader/Agency.lean:49" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T05", + "status": "accepted", + "reason": "所有形式种类的条件覆盖及可修订而无进步的非空例子成立。", + "reason_en": "revisabilityCovers projects an explicitly assumed Generative policy. revisionWithoutProgress combines openPolicy with a constant base-state trace; possible revision is not promised progress.", + "reason_zh": "所有形式种类的条件覆盖及可修订而无进步的非空例子成立。", + "classification": "N/D projection and W witness", + "previous_status": "accepted", + "previous_reason": "通用kind/version覆盖和具体可修订却无扩展见证均成立；投影性质须如实标记。", + "source_refs": [ + { + "unit": "organon.charter.self-transcendence.non-finality", + "clause": "p1" + }, + { + "unit": "organon.relationships.terms", + "clause": "p1" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Agency.revisabilityCovers", + "kind": "theorem", + "location": "CoreReader/Agency.lean:58", + "meaning": "Extracts revisability of a specified current kind/version from an assumed generation predicate; it does not revise that form." + }, + { + "name": "CoreReader.Agency.revisionWithoutProgress", + "kind": "case", + "location": "CoreReader/Agency.lean:123", + "meaning": "Exhibits a policy meeting the generation interface and universal revisability while its independently chosen constant trace never expands." + } + ], + "proof_and_scope": "revisabilityCovers projects an explicitly assumed Generative policy. revisionWithoutProgress combines openPolicy with a constant base-state trace; possible revision is not promised progress.", + "findings": [ + { + "branch": "form-coverage", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "任意五种form kind均受∀current→revisable规范约束，包含全部必要种类。", + "previous_minimal_fix": null, + "current_analysis": "所有形式种类的条件覆盖及可修订而无进步的非空例子成立。 revisabilityCovers projects an explicitly assumed Generative policy. revisionWithoutProgress combines openPolicy with a constant base-state trace; possible revision is not promised progress.", + "current_code": [ + "CoreReader/Agency.lean:58", + "CoreReader/Agency.lean:123" + ], + "minimal_fix": null + }, + { + "branch": "projection-boundary", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "只是将已采纳规范实例化，不是发明可修订性或执行修订；这正是冻结规范后果范围。", + "previous_minimal_fix": null, + "current_analysis": "所有形式种类的条件覆盖及可修订而无进步的非空例子成立。 revisabilityCovers projects an explicitly assumed Generative policy. revisionWithoutProgress combines openPolicy with a constant base-state trace; possible revision is not promised progress.", + "current_code": [ + "CoreReader/Agency.lean:58", + "CoreReader/Agency.lean:123" + ], + "minimal_fix": null + }, + { + "branch": "revisable-without-progress", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "openPolicy可修订与常值baseState trace并存，每步Expanded均假。", + "previous_minimal_fix": null, + "current_analysis": "所有形式种类的条件覆盖及可修订而无进步的非空例子成立。 revisabilityCovers projects an explicitly assumed Generative policy. revisionWithoutProgress combines openPolicy with a constant base-state trace; possible revision is not promised progress.", + "current_code": [ + "CoreReader/Agency.lean:58", + "CoreReader/Agency.lean:123" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T06", + "status": "accepted", + "reason": "11分支均有同对象内容：三类数量膨胀不扩能，同一生成系统执行分别依赖经验/知识/协作，无外援失败，稳定动作保持所需能力并满足预算，自述对同一次变化的内容被反驳。", + "reason_en": "GeneratingSystem binds policy, current state, execution, required operations and budget. The resource deletion calls all use its execute interface. Stable action retains current content within the stated budget. Announcement carries owner, before/after, operation, input and expected output; its claimed membership/output expansion fails for inflatedState. All are explicit finite examples, not empirical laws.", + "reason_zh": "11分支均有同对象内容：三类数量膨胀不扩能，同一生成系统执行分别依赖经验/知识/协作，无外援失败，稳定动作保持所需能力并满足预算，自述对同一次变化的内容被反驳。", + "classification": "W eleven branches", + "previous_status": "rejected", + "previous_reason": "数量与非进步分支有内容性见证；外部执行/稳定与同一系统状态的联系尚未建模，自称生成分支更只有构造器自等式，11分支未齐。", + "source_refs": [ + { + "unit": "organon.charter.self-transcendence.limits", + "clause": "p1" + }, + { + "unit": "organon.charter.self-transcendence.limits", + "clause": "p2" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Agency.generationLimits", + "kind": "case", + "location": "CoreReader/Agency.lean:222", + "meaning": "Checks all concrete branches on the bound system: unchanged capability despite list inflation, resource dependence, justified stable action and an untrue same-object achievement report." + } + ], + "proof_and_scope": "GeneratingSystem binds policy, current state, execution, required operations and budget. The resource deletion calls all use its execute interface. Stable action retains current content within the stated budget. Announcement carries owner, before/after, operation, input and expected output; its claimed membership/output expansion fails for inflatedState. All are explicit finite examples, not empirical laws.", + "findings": [ + { + "branch": "a-orientation-without-progress", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "有价值/非终局政策且base与inflated之间无理解/构造成员增加。", + "previous_minimal_fix": null, + "current_analysis": "generatingSystem.policy为openPolicy；baseState到inflatedState不增加understood/constructed成员，Generative仍成立。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "b-more-artifacts", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "同一before/after状态inventory复制，understood/constructed不变。", + "previous_minimal_fix": null, + "current_analysis": "inventory复制增长，而同一对状态的constructed/understood保持原内容。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "c-more-abstraction-layers", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "层级列表增加而同一状态的能力成员不增加。", + "previous_minimal_fix": null, + "current_analysis": "同一inflatedState增加层级列表但不增加能力成员。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "d-more-terms", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "词汇列表增加而理解/构造成员不变。", + "previous_minimal_fix": null, + "current_analysis": "同一inflatedState增加词汇列表但不增加能力成员。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "e-external-experience", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "Option计算确实读取experience，缺失即none；但没有标明该计算是这项Generative系统的执行，结果也不进入其状态。合取任意外部函数仅证明相容，未满足冻结同一内容系统要求。", + "previous_minimal_fix": "将政策、被执行算法、资源和before/after或执行结果纳入同一对象，再展示experience缺失的实际失败。", + "current_analysis": "GeneratingSystem.execute实际绑定assistedExecution；删去同一次调用的experience槽得到none。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "f-external-knowledge", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "knowledge依赖计算正确；同e，缺少同一系统执行绑定。", + "previous_minimal_fix": "复用同一绑定执行对象，分别删knowledge验证失败。", + "current_analysis": "同一生成系统的同一execute接口删去knowledge槽得到none。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "g-collaboration", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "collaborator缺失的Option失败正确；其同一主体/执行含义未建模。", + "previous_minimal_fix": "在上述共享执行对象中保留协作槽及单独缺失反例。", + "current_analysis": "同一生成系统execute删去collaborator槽得到none；不是独立无关函数的合取。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "h-no-autonomous-execution", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "⟨none,none,none⟩导致独立求和函数失败；没有该系统自主执行接口，不能把任意失败函数当其不能自主执行。", + "previous_minimal_fix": "明确这就是被评系统的执行接口，并把无外援调用关联其执行结果。", + "current_analysis": "该系统的execute在三个外援槽均none时失败；证明所示接口的依赖，不证明所有自主执行不可能。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "i-no-self-improvement", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "常值trace每步无Expanded；可作为所选无自我改善轨迹，不是所有系统永远不改善。", + "previous_minimal_fix": null, + "current_analysis": "stableTrace在每一步保持baseState，Expanded逐步失败。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "j-grounded-stability", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "StableReason给出构造内容相等和inventory越过阈值1，但没有稳定动作或被追求的预算/价值条件；阈值本身尚未关联该系统稳定选择的理由。", + "previous_minimal_fix": "把1作为明示应用约束，并证明保留当前状态的动作满足它且不丢所需能力，同时政策仍Generative。", + "current_analysis": "GeneratingSystem.stableAction保持current；requirementsMet保留所需copy操作，budgetJustified满足明确budget=1，且policy仍Generative。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + }, + { + "branch": "k-self-announcement-not-achievement", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "expanded=expanded只是枚举构造器自等式，不是某系统对同一变化的announcement，也没有achievement-support的失败命题。", + "previous_minimal_fix": "定义带主体、before/after和claim的实际报告，构造报告生成而同一claim不成立/缺充分支持的反例。", + "current_analysis": "inflatedAnnouncement含相同owner/before/after/op/input/output；claimedOperation=successor未成为新增能力，其实质claim被inflatedAnnouncementRefuted反驳。", + "current_code": [ + "CoreReader/Agency.lean:222" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T07", + "status": "accepted", + "reason": "保留任意支持关系的条件推论，并新增同一次扩展的基线、测试条件、记录、非空兼容世界和Grounds；同一报告在膨胀反世界也成立，故报告不支持成就。", + "reason_en": "ConcreteAchievementExample fixes transitionBefore/After and input. A performance record distinguishes extension from inflation in the two-case world. transitionReportDoesNotSupport supplies the compatible inflation countermodel. achievementNeedsSupport uses its generic premises and separately conjoins this checked instance; it does not discharge arbitrary real achievement claims.", + "reason_zh": "保留任意支持关系的条件推论，并新增同一次扩展的基线、测试条件、记录、非空兼容世界和Grounds；同一报告在膨胀反世界也成立，故报告不支持成就。", + "classification": "D conditional fragment with N accountability", + "previous_status": "rejected", + "previous_reason": "任意claim的support应用定理正确，但冻结要求的同一能力变化、基线和条件实例及取向/自述不提供其支持的反例没有完成。", + "source_refs": [ + { + "unit": "organon.charter.self-transcendence.limits", + "clause": "p1" + }, + { + "unit": "organon.charter.self-transcendence.limits", + "clause": "p2" + }, + { + "unit": "organon.grounds", + "clause": "p1" + }, + { + "unit": "organon.grounds.capabilities", + "clause": "p1" + }, + { + "unit": "organon.grounds.capabilities", + "clause": "p2" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Evidence.AchievementAccountability", + "kind": "definition", + "location": "CoreReader/Evidence.lean:125", + "meaning": "Defines achievement accountability as exactly the same Grounds predicate, with no additional execution or achievement proof." + }, + { + "name": "CoreReader.Evidence.achievementNeedsSupport", + "kind": "theorem", + "location": "CoreReader/Evidence.lean:217", + "meaning": "Applies supplied compatible-world support to the arbitrary actual claim and separately includes the checked concrete transition example." + } + ], + "proof_and_scope": "ConcreteAchievementExample fixes transitionBefore/After and input. A performance record distinguishes extension from inflation in the two-case world. transitionReportDoesNotSupport supplies the compatible inflation countermodel. achievementNeedsSupport uses its generic premises and separately conjoins this checked instance; it does not discharge arbitrary real achievement claims.", + "findings": [ + { + "branch": "conditional-inference", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "对任意W及claim，支持加actual兼容性推出actual处claim；没有伪称实际可靠性已证明。", + "previous_minimal_fix": null, + "current_analysis": "achievementNeedsSupport:217仍按Compatible与Supports前提实例化actual，另合取已检查的具体实例；泛型结论没有隐藏自动支持。", + "current_code": [ + "CoreReader/Evidence.lean:125", + "CoreReader/Evidence.lean:217" + ], + "minimal_fix": null + }, + { + "branch": "same-change-baseline-scope", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "未把achievement实例化为同一before/after的Expanded；没有对应基线、记录内容、条件或非空支持见证。", + "previous_minimal_fix": "给变化世界/记录及明确Expanded类claim，证明非空兼容性、支持和actual结论；保留通用定理。", + "current_analysis": "ConcreteAchievementExample:193要求同一transitionBefore/After、input=0、实际Expanded、性能记录兼容与支持和Grounds；concreteAchievementExample:204构造extension。", + "current_code": [ + "CoreReader/Evidence.lean:125", + "CoreReader/Evidence.lean:217" + ], + "minimal_fix": null + }, + { + "branch": "orientation-and-report-insufficiency", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "generationLimits只给无Expanded和标签自等式，未建立对上述achievement的support失败。", + "previous_minimal_fix": "复用同一变化世界，构造有取向/报告但兼容反世界使支持失败。", + "current_analysis": "transitionReportDoesNotSupport:186复用同一报告和inflate兼容反世界，反驳transitionAchievement的Supports。", + "current_code": [ + "CoreReader/Evidence.lean:125", + "CoreReader/Evidence.lean:217" + ], + "minimal_fix": null + }, + { + "branch": "accountability-interface", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "别名能存对应claim但value分支允许理由/commitment脱离，不能作为完整成就规范接口的完成证据；也没有achievement实例履行。", + "previous_minimal_fix": "将实际成就的适用经验/推论面与同一claim绑定，检查匹配的Grounds；不要由规范接口宣称真实成就已获证。", + "current_analysis": "transitionAccountable:172按同一achievement的实际经验方面构造Grounds；ValueProcedure的修复另由T15审查。", + "current_code": [ + "CoreReader/Evidence.lean:125", + "CoreReader/Evidence.lean:217" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T08", + "status": "accepted", + "reason": "显式可满足前提支持同题同条件的一致性；三项各自可满足但联合冲突的实际见证保留。", + "reason_en": "Consequence quantifies admissible worlds under one theory/context; a supplied admissible witness refutes simultaneous positive and negative consequences. Empty question types remain a vacuous boundary, not evidence of substantive completeness.", + "reason_zh": "显式可满足前提支持同题同条件的一致性；三项各自可满足但联合冲突的实际见证保留。", + "classification": "D theorem and W countermodel", + "previous_status": "accepted", + "previous_reason": "通用语义与非空见证阻止同题正反结论；实际三前提冲突显示不能仅逐项检查。", + "source_refs": [ + { + "unit": "organon.charter.consistency", + "clause": "p1" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Logic.consequenceConsistency", + "kind": "theorem", + "location": "CoreReader/Logic.lean:31", + "meaning": "Given an admissible witness, proves that no question can have both signed consequences. The witness is an explicit premise." + }, + { + "name": "CoreReader.Logic.jointConflict", + "kind": "case", + "location": "CoreReader/Logic.lean:59", + "meaning": "Exhibits individual models of each of three claims, then proves their conjunction has no model." + } + ], + "proof_and_scope": "Consequence quantifies admissible worlds under one theory/context; a supplied admissible witness refutes simultaneous positive and negative consequences. Empty question types remain a vacuous boundary, not evidence of substantive completeness.", + "findings": [ + { + "branch": "simultaneous-and-implications", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "Theory含全部选择命题，Entails/Consequence量化所有模型，包括实际蕴涵而非仅扫描字符串列表。", + "previous_minimal_fix": null, + "current_analysis": "显式可满足前提支持同题同条件的一致性；三项各自可满足但联合冲突的实际见证保留。 Consequence quantifies admissible worlds under one theory/context; a supplied admissible witness refutes simultaneous positive and negative consequences. Empty question types remain a vacuous boundary, not evidence of substantive completeness.", + "current_code": [ + "CoreReader/Logic.lean:31", + "CoreReader/Logic.lean:59" + ], + "minimal_fix": null + }, + { + "branch": "same-context-noncontradiction", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "同一admissible witness使正反结论矛盾；不存在证明现实理论必有model的隐藏步骤。", + "previous_minimal_fix": null, + "current_analysis": "显式可满足前提支持同题同条件的一致性；三项各自可满足但联合冲突的实际见证保留。 Consequence quantifies admissible worlds under one theory/context; a supplied admissible witness refutes simultaneous positive and negative consequences. Empty question types remain a vacuous boundary, not evidence of substantive completeness.", + "current_code": [ + "CoreReader/Logic.lean:31", + "CoreReader/Logic.lean:59" + ], + "minimal_fix": null + }, + { + "branch": "joint-conflict", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "三个单项分别有Bool-pair模型，联合P、P→Q、¬Q无法满足；关键反例内容真实。", + "previous_minimal_fix": null, + "current_analysis": "显式可满足前提支持同题同条件的一致性；三项各自可满足但联合冲突的实际见证保留。 Consequence quantifies admissible worlds under one theory/context; a supplied admissible witness refutes simultaneous positive and negative consequences. Empty question types remain a vacuous boundary, not evidence of substantive completeness.", + "current_code": [ + "CoreReader/Logic.lean:31", + "CoreReader/Logic.lean:59" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T09", + "status": "accepted", + "reason": "撤回后反转、假设变化、术语含义变化和适用范围变化各自有非空实例，不要求跨条件永久兼容。", + "reason_en": "Each revised slice has a concrete model; their union conflicts. The three context examples vary assumptions, meaning and scope separately. Slice satisfiability supplies the witness needed for the general consistency theorem.", + "reason_zh": "撤回后反转、假设变化、术语含义变化和适用范围变化各自有非空实例，不要求跨条件永久兼容。", + "classification": "W retraction and context models", + "previous_status": "accepted", + "previous_reason": "时间切片撤回旧命题后保留相反命题的可满足性及联合冲突明确；三种上下文变化分别有非空见证。", + "source_refs": [ + { + "unit": "organon.charter.consistency.meaning", + "clause": "p1" + }, + { + "unit": "organon.charter.consistency.meaning", + "clause": "p2" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Logic.revisionCanReverse", + "kind": "case", + "location": "CoreReader/Logic.lean:78", + "meaning": "Exhibits satisfiable time-zero and time-one slices whose union is unsatisfiable. No temporal update mechanism is implemented." + }, + { + "name": "CoreReader.Logic.contextDifferences", + "kind": "case", + "location": "CoreReader/Logic.lean:102", + "meaning": "Proves that changing any one of assumptions, meaning, or scope can reverse polarity, with explicit admissible witnesses in all displayed contexts." + } + ], + "proof_and_scope": "Each revised slice has a concrete model; their union conflicts. The three context examples vary assumptions, meaning and scope separately. Slice satisfiability supplies the witness needed for the general consistency theorem.", + "findings": [ + { + "branch": "retraction-and-opposite", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "旧/新slice分别有true/false模型，联合无模型，编码的是撤回后的状态而非永久兼容要求。", + "previous_minimal_fix": null, + "current_analysis": "撤回后反转、假设变化、术语含义变化和适用范围变化各自有非空实例，不要求跨条件永久兼容。 Each revised slice has a concrete model; their union conflicts. The three context examples vary assumptions, meaning and scope separately. Slice satisfiability supplies the witness needed for the general consistency theorem.", + "current_code": [ + "CoreReader/Logic.lean:78", + "CoreReader/Logic.lean:102" + ], + "minimal_fix": null + }, + { + "branch": "slice-consistency", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "slice显式给Satisfiable而非直接Consistent；在空附加假设/全scope的自然问题上下文中，可由同一非空model一般定理得到一致性，未引入实质源外前提。", + "previous_minimal_fix": null, + "current_analysis": "撤回后反转、假设变化、术语含义变化和适用范围变化各自有非空实例，不要求跨条件永久兼容。 Each revised slice has a concrete model; their union conflicts. The three context examples vary assumptions, meaning and scope separately. Slice satisfiability supplies the witness needed for the general consistency theorem.", + "current_code": [ + "CoreReader/Logic.lean:78", + "CoreReader/Logic.lean:102" + ], + "minimal_fix": null + }, + { + "branch": "assumption-change", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "固定问题含义，仅世界假设true/false变化，正反后果各有admissible witness。", + "previous_minimal_fix": null, + "current_analysis": "撤回后反转、假设变化、术语含义变化和适用范围变化各自有非空实例，不要求跨条件永久兼容。 Each revised slice has a concrete model; their union conflicts. The three context examples vary assumptions, meaning and scope separately. Slice satisfiability supplies the witness needed for the general consistency theorem.", + "current_code": [ + "CoreReader/Logic.lean:78", + "CoreReader/Logic.lean:102" + ], + "minimal_fix": null + }, + { + "branch": "meaning-change", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "假设固定true，meaning改为等于true/false，反转判断而各context非空。", + "previous_minimal_fix": null, + "current_analysis": "撤回后反转、假设变化、术语含义变化和适用范围变化各自有非空实例，不要求跨条件永久兼容。 Each revised slice has a concrete model; their union conflicts. The three context examples vary assumptions, meaning and scope separately. Slice satisfiability supplies the witness needed for the general consistency theorem.", + "current_code": [ + "CoreReader/Logic.lean:78", + "CoreReader/Logic.lean:102" + ], + "minimal_fix": null + }, + { + "branch": "scope-change", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "假设为空、meaning固定，scope改选true/false；不要求跨context一致。", + "previous_minimal_fix": null, + "current_analysis": "撤回后反转、假设变化、术语含义变化和适用范围变化各自有非空实例，不要求跨条件永久兼容。 Each revised slice has a concrete model; their union conflicts. The three context examples vary assumptions, meaning and scope separately. Slice satisfiability supplies the witness needed for the general consistency theorem.", + "current_code": [ + "CoreReader/Logic.lean:78", + "CoreReader/Logic.lean:102" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T10", + "status": "accepted", + "reason": "语义变化必须报告的条件规范、表示顺序不变、独立revisionIdentity变化和隐藏条件变化反例均保留。", + "reason_en": "TruthfulReport is an assumed one-way obligation. SameContent compares semantic content and the separate revision identity is also checked. The result is not an automatic change detector and report=true does not establish adequate reporting.", + "reason_zh": "语义变化必须报告的条件规范、表示顺序不变、独立revisionIdentity变化和隐藏条件变化反例均保留。", + "classification": "N/D specification consequences plus W examples", + "previous_status": "accepted", + "previous_reason": "单向报告规范、语义变化反例、表示顺序不变以及独立revisionIdentity触发均达到冻结的规范接口范围；并未实现自动检测。", + "source_refs": [ + { + "unit": "organon.charter.consistency.meaning", + "clause": "p1" + }, + { + "unit": "organon.charter.consistency.meaning", + "clause": "p2" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Logic.semanticChangeMustBeReported", + "kind": "theorem", + "location": "CoreReader/Logic.lean:142", + "meaning": "Instantiates the reporting interface with a supplied change proof; it cannot discover changes on its own." + }, + { + "name": "CoreReader.Logic.representationOrderIrrelevant", + "kind": "theorem", + "location": "CoreReader/Logic.lean:150", + "meaning": "Proves swapping the order of two singleton components leaves theory membership unchanged." + }, + { + "name": "CoreReader.Logic.hiddenContextChangeRejected", + "kind": "case", + "location": "CoreReader/Logic.lean:160", + "meaning": "Rejects false reports for three concrete context changes and a revision-only change; also shows reporting true does not make an incompatible assumption hold." + } + ], + "proof_and_scope": "TruthfulReport is an assumed one-way obligation. SameContent compares semantic content and the separate revision identity is also checked. The result is not an automatic change detector and report=true does not establish adequate reporting.", + "findings": [ + { + "branch": "semantic-change-report", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "held/context语义成员、meaning、scope差异均触发报告责任；报告真不反推变化，无不报告变化的许可。", + "previous_minimal_fix": null, + "current_analysis": "语义变化必须报告的条件规范、表示顺序不变、独立revisionIdentity变化和隐藏条件变化反例均保留。 TruthfulReport is an assumed one-way obligation. SameContent compares semantic content and the separate revision identity is also checked. The result is not an automatic change detector and report=true does not establish adequate reporting.", + "current_code": [ + "CoreReader/Logic.lean:142", + "CoreReader/Logic.lean:150", + "CoreReader/Logic.lean:160" + ], + "minimal_fix": null + }, + { + "branch": "representation-order", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "union两个singleton的顺序变化不改变命题集合；仅覆盖这种表示变化。", + "previous_minimal_fix": null, + "current_analysis": "语义变化必须报告的条件规范、表示顺序不变、独立revisionIdentity变化和隐藏条件变化反例均保留。 TruthfulReport is an assumed one-way obligation. SameContent compares semantic content and the separate revision identity is also checked. The result is not an automatic change detector and report=true does not establish adequate reporting.", + "current_code": [ + "CoreReader/Logic.lean:142", + "CoreReader/Logic.lean:150", + "CoreReader/Logic.lean:160" + ], + "minimal_fix": null + }, + { + "branch": "hidden-context-changes", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "分别对assumption/meaning/scope构造¬SameContent，使false报告违反规范。", + "previous_minimal_fix": null, + "current_analysis": "语义变化必须报告的条件规范、表示顺序不变、独立revisionIdentity变化和隐藏条件变化反例均保留。 TruthfulReport is an assumed one-way obligation. SameContent compares semantic content and the separate revision identity is also checked. The result is not an automatic change detector and report=true does not establish adequate reporting.", + "current_code": [ + "CoreReader/Logic.lean:142", + "CoreReader/Logic.lean:150", + "CoreReader/Logic.lean:160" + ], + "minimal_fix": null + }, + { + "branch": "independent-revision", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "同content但revisionIdentity从0到1也禁止false报告；外部已识别文字/形式修订必须由调用方赋正确identity，不宣称代码检测了全部变化。", + "previous_minimal_fix": null, + "current_analysis": "语义变化必须报告的条件规范、表示顺序不变、独立revisionIdentity变化和隐藏条件变化反例均保留。 TruthfulReport is an assumed one-way obligation. SameContent compares semantic content and the separate revision identity is also checked. The result is not an automatic change detector and report=true does not establish adequate reporting.", + "current_code": [ + "CoreReader/Logic.lean:142", + "CoreReader/Logic.lean:150", + "CoreReader/Logic.lean:160" + ], + "minimal_fix": null + }, + { + "branch": "report-not-adequacy", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "true报告仍与新assumption在true实际world不成立并存，不为修订内容背书。", + "previous_minimal_fix": null, + "current_analysis": "语义变化必须报告的条件规范、表示顺序不变、独立revisionIdentity变化和隐藏条件变化反例均保留。 TruthfulReport is an assumed one-way obligation. SameContent compares semantic content and the separate revision identity is also checked. The result is not an automatic change detector and report=true does not establish adequate reporting.", + "current_code": [ + "CoreReader/Logic.lean:142", + "CoreReader/Logic.lean:150", + "CoreReader/Logic.lean:160" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T11", + "status": "accepted", + "reason": "具有共同可行解的张力与同条件不相容后果已区别；不保留冲突是已采纳一致性约束的后果。", + "reason_en": "The tension example shares a feasible value without equating the value predicates. conflictRequiresChange assumes a consistent retained theory and uses conflicting consequences to refute retaining all incompatible content; it does not construct a revision algorithm.", + "reason_zh": "具有共同可行解的张力与同条件不相容后果已区别；不保留冲突是已采纳一致性约束的后果。", + "classification": "W witness plus D norm consequence", + "previous_status": "accepted", + "previous_reason": "两约束有共同可行值但非同一谓词；同条件正反后果明确违反一致性。修订责任是采纳规范的条件后果，未声称已实现修订算法。", + "source_refs": [ + { + "unit": "organon.charter.consistency.limits", + "clause": "p1" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Logic.tensionWithoutContradiction", + "kind": "case", + "location": "CoreReader/Logic.lean:186", + "meaning": "Exhibits overlapping lower/upper budget bounds while proving that the two predicates differ. This is a concrete compatible-constraints example." + }, + { + "name": "CoreReader.Logic.conflictRequiresChange", + "kind": "theorem", + "location": "CoreReader/Logic.lean:195", + "meaning": "Given both signed consequences for one question, proves inconsistency as defined. It does not construct a repair or establish which premise should change." + } + ], + "proof_and_scope": "The tension example shares a feasible value without equating the value predicates. conflictRequiresChange assumes a consistent retained theory and uses conflicting consequences to refute retaining all incompatible content; it does not construct a revision algorithm.", + "findings": [ + { + "branch": "tension-without-conflict", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "预算5同时满足不同上下界，0证明两谓词不等；有限模型展示不同目标不等于不可同时满足。", + "previous_minimal_fix": null, + "current_analysis": "具有共同可行解的张力与同条件不相容后果已区别；不保留冲突是已采纳一致性约束的后果。 The tension example shares a feasible value without equating the value predicates. conflictRequiresChange assumes a consistent retained theory and uses conflicting consequences to refute retaining all incompatible content; it does not construct a revision algorithm.", + "current_code": [ + "CoreReader/Logic.lean:186", + "CoreReader/Logic.lean:195" + ], + "minimal_fix": null + }, + { + "branch": "conflict-requires-nonretention", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "同题同context正反后果使Consistent失败；在采纳一致性规范下不能原样保留该状态。未提供哪一项应改的价值判断或算法。", + "previous_minimal_fix": null, + "current_analysis": "具有共同可行解的张力与同条件不相容后果已区别；不保留冲突是已采纳一致性约束的后果。 The tension example shares a feasible value without equating the value predicates. conflictRequiresChange assumes a consistent retained theory and uses conflicting consequences to refute retaining all incompatible content; it does not construct a revision algorithm.", + "current_code": [ + "CoreReader/Logic.lean:186", + "CoreReader/Logic.lean:195" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T12", + "status": "accepted", + "reason": "模型可满足与指定实际世界为真不同；一个明确问题的正反结论均不蕴涵，故一致性不保证真或充分。", + "reason_en": "Bool witnesses separate model existence from truth at the selected actual world. The incomplete case has admissible worlds on both sides of its question; philosophical importance of that question is supplied by interpretation.", + "reason_zh": "模型可满足与指定实际世界为真不同；一个明确问题的正反结论均不蕴涵，故一致性不保证真或充分。", + "classification": "W truth and coverage separation", + "previous_status": "accepted", + "previous_reason": "Bool模型具体区分可满足性与指定实际world真值，并给指定问题的双向非蕴涵；其现实重要性不由数学裁定。", + "source_refs": [ + { + "unit": "organon.charter.consistency.limits", + "clause": "p1" + }, + { + "unit": "organon.relationships.roles", + "clause": "p1" + }, + { + "unit": "organon.relationships.roles", + "clause": "p2" + }, + { + "unit": "organon.relationships.roles", + "clause": "p3" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Logic.consistentFalse", + "kind": "case", + "location": "CoreReader/Logic.lean:205", + "meaning": "Exhibits a satisfiable Boolean singleton theory that fails at the separately chosen world false; satisfiability is not truth at every world." + }, + { + "name": "CoreReader.Logic.consistentIncomplete", + "kind": "case", + "location": "CoreReader/Logic.lean:216", + "meaning": "Shows the empty Boolean theory is satisfiable while entailing neither the true-world claim nor its negation." + } + ], + "proof_and_scope": "Bool witnesses separate model existence from truth at the selected actual world. The incomplete case has admissible worlds on both sides of its question; philosophical importance of that question is supplied by interpretation.", + "findings": [ + { + "branch": "false-assumption", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "singleton w=true可满足但在指定false world不成立，足以展示一致理论不自动为实际真。", + "previous_minimal_fix": null, + "current_analysis": "模型可满足与指定实际世界为真不同；一个明确问题的正反结论均不蕴涵，故一致性不保证真或充分。 Bool witnesses separate model existence from truth at the selected actual world. The incomplete case has admissible worlds on both sides of its question; philosophical importance of that question is supplied by interpretation.", + "current_code": [ + "CoreReader/Logic.lean:205", + "CoreReader/Logic.lean:216" + ], + "minimal_fix": null + }, + { + "branch": "undecided-relevant-question", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "明确检验w=true这一选择问题，两个Bool模型使正反均不被emptyTheory蕴涵。问题被指定为关注对象；未证明任何现实问题的重要性。", + "previous_minimal_fix": null, + "current_analysis": "模型可满足与指定实际世界为真不同；一个明确问题的正反结论均不蕴涵，故一致性不保证真或充分。 Bool witnesses separate model existence from truth at the selected actual world. The incomplete case has admissible worlds on both sides of its question; philosophical importance of that question is supplied by interpretation.", + "current_code": [ + "CoreReader/Logic.lean:205", + "CoreReader/Logic.lean:216" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T13", + "status": "accepted", + "reason": "Reflexive现在要求一致的原则登记、同所有者对象、实际问题/理由/范围/结果及方法契约；形成、应用、修订内容已由有限评估与生成函数实际计算。", + "reason_en": "ValidApplication checks owner/key resolution, inquiry and method identity, nonempty target-linked reasons, limits and the registered meaning. ownContentEvaluates proves separate stated outcomes match the evaluator. All nine subjects receive assessment; generation excludes application-phase subjects by explicit applicability. Insufficient results are valid assessments, not correctness proofs.", + "reason_zh": "Reflexive现在要求一致的原则登记、同所有者对象、实际问题/理由/范围/结果及方法契约；形成、应用、修订内容已由有限评估与生成函数实际计算。", + "classification": "N specification; projections are not executions", + "previous_status": "rejected", + "previous_reason": "系统/原则/三阶段和两类活动的条件覆盖已表达，但原则形成理由、适用域审查及修订理由仍只由活动标签代替，未完成冻结的完整规范对象。", + "source_refs": [ + { + "unit": "organon.charter.reflexivity", + "clause": "p1" + }, + { + "unit": "organon.charter.reflexivity.meaning", + "clause": "p1" + }, + { + "unit": "organon.charter.reflexivity.limits", + "clause": "p1" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Agency.Reflexive", + "kind": "definition", + "location": "CoreReader/Reflexivity.lean:151", + "meaning": "Requires a coherent registry and a valid recorded application for every applicable same-owner subject and registered rule; this remains a model compliance condition." + } + ], + "proof_and_scope": "ValidApplication checks owner/key resolution, inquiry and method identity, nonempty target-linked reasons, limits and the registered meaning. ownContentEvaluates proves separate stated outcomes match the evaluator. All nine subjects receive assessment; generation excludes application-phase subjects by explicit applicability. Insufficient results are valid assessments, not correctness proofs.", + "findings": [ + { + "branch": "objects-and-activities", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "系统、原则、formation/application/revision过程均有独立constructor/phase；generation和assessment两个活动均在非空ownRules中。", + "previous_minimal_fix": null, + "current_analysis": "Subject包含system、principle、principleProcess三阶段；ownSubjects:226含9个对象，generatingRule与assessingRule分别生成/评估。", + "current_code": [ + "CoreReader/Reflexivity.lean:151" + ], + "minimal_fix": null + }, + { + "branch": "applicability-conditions", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "owner和rule.applicable是独立条件；自我身份不取消已适用规则的记录义务。", + "previous_minimal_fix": null, + "current_analysis": "Reflexive:151先检查登记一致，再量化已登记、同owner且applicable的rule/subject；生成不适用于application阶段是明确条件而非自我豁免。", + "current_code": [ + "CoreReader/Reflexivity.lean:151" + ], + "minimal_fix": null + }, + { + "branch": "formation-reasons-scope-revision-reasons", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "没有任何subject关联的形成理由、适用域考察或修订理由字段/问题/评估内容；十个预填活动pair无法区分“仅合规自查”与来源要求的多问题审查。", + "previous_minimal_fix": "增加最小的assessment-question/content接口并关联原则及对应phase；明确三个问题均在责任范围，以非空解释性记录/实例证明覆盖。无需证明现实评估已发生。", + "current_analysis": "inquiryFor:172、sourceReasonContents:180、assessInquiry:191分别编码形成目的/范围、适用范围问题和onlyAtZero在1失败的修订反例；ownContentEvaluates:287检查预定结果确等于算法结果。", + "current_code": [ + "CoreReader/Reflexivity.lean:151" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T14", + "status": "accepted", + "reason": "无自我豁免和适用条件保留；有限自测仍不证明普遍正确；自产修订现在与同一owner、before和after相连且有局部变化但全局失败。", + "reason_en": "noSelfExemption projects applicable owned obligations, not unconditional applicability. applicationWork is a nonempty restricted example. OwnedRevisionExample ties a producing process to prior and output functions; evaluation at zero changes, while the compatible counterworld fails at one. Origin supplies no global support.", + "reason_zh": "无自我豁免和适用条件保留；有限自测仍不证明普遍正确；自产修订现在与同一owner、before和after相连且有局部变化但全局失败。", + "classification": "D conditional projection and W boundary cases", + "previous_status": "rejected", + "previous_reason": "适用性与有限检验反例通过；自产修订分支没有与同一主体/旧新对象关联的自我产生事实，仅演示任意局部生成函数的观察不足。", + "source_refs": [ + { + "unit": "organon.charter.reflexivity.limits", + "clause": "p1" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Agency.noSelfExemption", + "kind": "theorem", + "location": "CoreReader/Reflexivity.lean:165", + "meaning": "Instantiates full reflexivity at a registered applicable same-owner subject, then extracts its performance record." + }, + { + "name": "CoreReader.Agency.applicabilityRetained", + "kind": "theorem", + "location": "CoreReader/Reflexivity.lean:407", + "meaning": "Derives record scope from full reflexivity, proves its classical conditional/disjunctive equivalence, and gives a valid restricted example with no system assessment." + }, + { + "name": "CoreReader.Agency.selfTestDoesNotProve", + "kind": "case", + "location": "CoreReader/Agency.lean:275", + "meaning": "Computes success on sample 1 and failure at 0, refuting universal success. This concerns the particular arithmetic predicate, not a universal impossibility theorem about all self-tests." + }, + { + "name": "CoreReader.Evidence.selfOriginDoesNotSupport", + "kind": "case", + "location": "CoreReader/Evidence.lean:616", + "meaning": "Retains the local observation countermodel and adds an actual owned before/after revision with the same unsupported global claim." + } + ], + "proof_and_scope": "noSelfExemption projects applicable owned obligations, not unconditional applicability. applicationWork is a nonempty restricted example. OwnedRevisionExample ties a producing process to prior and output functions; evaluation at zero changes, while the compatible counterworld fails at one. Origin supplies no global support.", + "findings": [ + { + "branch": "no-self-exemption", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "对同owner且适用的rule直接得到要求的record；不把identity与applicability等同。", + "previous_minimal_fix": null, + "current_analysis": "无自我豁免和适用条件保留；有限自测仍不证明普遍正确；自产修订现在与同一owner、before和after相连且有局部变化但全局失败。 noSelfExemption projects applicable owned obligations, not unconditional applicability. applicationWork is a nonempty restricted example. OwnedRevisionExample ties a producing process to prior and output functions; evaluation at zero changes, while the compatible counterworld fails at one. Origin supplies no global support.", + "current_code": [ + "CoreReader/Reflexivity.lean:165", + "CoreReader/Reflexivity.lean:407", + "CoreReader/Agency.lean:275", + "CoreReader/Evidence.lean:616" + ], + "minimal_fix": null + }, + { + "branch": "nonapplicable-boundary", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "application-only规则可被履行而system assessment缺失；说明不能忽略条件要求所有自应用。", + "previous_minimal_fix": null, + "current_analysis": "无自我豁免和适用条件保留；有限自测仍不证明普遍正确；自产修订现在与同一owner、before和after相连且有局部变化但全局失败。 noSelfExemption projects applicable owned obligations, not unconditional applicability. applicationWork is a nonempty restricted example. OwnedRevisionExample ties a producing process to prior and output functions; evaluation at zero changes, while the compatible counterworld fails at one. Origin supplies no global support.", + "current_code": [ + "CoreReader/Reflexivity.lean:165", + "CoreReader/Reflexivity.lean:407", + "CoreReader/Agency.lean:275", + "CoreReader/Evidence.lean:616" + ], + "minimal_fix": null + }, + { + "branch": "finite-self-test-not-universal", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "实际all运算在[1]通过，0使n+1=2n失败；有限内部测试不提供普遍正确性。", + "previous_minimal_fix": null, + "current_analysis": "无自我豁免和适用条件保留；有限自测仍不证明普遍正确；自产修订现在与同一owner、before和after相连且有局部变化但全局失败。 noSelfExemption projects applicable owned obligations, not unconditional applicability. applicationWork is a nonempty restricted example. OwnedRevisionExample ties a producing process to prior and output functions; evaluation at zero changes, while the compatible counterworld fails at one. Origin supplies no global support.", + "current_code": [ + "CoreReader/Reflexivity.lean:165", + "CoreReader/Reflexivity.lean:407", + "CoreReader/Agency.lean:275", + "CoreReader/Evidence.lean:616" + ], + "minimal_fix": null + }, + { + "branch": "self-origin-of-revision", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "证明生成函数f只在0为true且zero observation不支持allTrue，但未表示它是某系统自身生成的修订，也无修订前对象。作为局部观察反例有效，作为冻结自产修订分支欠对象联系。", + "previous_minimal_fix": "增加最小producer/owner及before/proposed关系或共享系统构造，让其自身生成该candidate，并保留当前内容性support反模型。", + "current_analysis": "Evidence.lean:581–616将GeneratingProcess.owner、prior和outputRevision绑定ProducedRevision；OwnedRevisionExample同时有实际0处改变和1处失败的支持反例。", + "current_code": [ + "CoreReader/Reflexivity.lean:165", + "CoreReader/Reflexivity.lean:407", + "CoreReader/Agency.lean:275", + "CoreReader/Evidence.lean:616" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T15", + "status": "accepted", + "reason": "Grounds逐方面要求同一主张、对应表述与履责；价值接口改为选项/结果/目标/约束/理由，并要求联合可采纳世界，消除了任意重贴commitment及不一致起点通过的问题。", + "reason_en": "ValuePosition derives commitment from selected=adopted and specializes reasons to the adopted option. ValueProcedure requires nonempty reasons, JointAdoption, scoped consequence under all stated reasons and an actual criticism response. It is a chosen procedural adapter, not a complete universal theory of good reasons or fulfillment by every application. Weakening and scope restriction remain explicit conditional theorems.", + "reason_zh": "Grounds逐方面要求同一主张、对应表述与履责；价值接口改为选项/结果/目标/约束/理由，并要求联合可采纳世界，消除了任意重贴commitment及不一致起点通过的问题。", + "classification": "D semantic support fragment plus N Grounds", + "previous_status": "rejected", + "previous_reason": "结论弱化与范围缩窄定理成立；完整Grounds规范中的价值理由对应当前claim仍无检查，不能以该较弱接口代表全部来源责任已保留。", + "source_refs": [ + { + "unit": "organon.grounds", + "clause": "p1" + }, + { + "unit": "organon.grounds.assessment", + "clause": "p1" + }, + { + "unit": "organon.grounds.assessment", + "clause": "p2" + }, + { + "unit": "organon.grounds.assessment", + "clause": "p3" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Evidence.Grounds", + "kind": "definition", + "location": "CoreReader/Evidence.lean:112", + "meaning": "Grounds packages a nonempty facet list, coverage of a supplied applicability predicate, common claim identity, articulation presence/alignment, and every listed facet's discharge. It is not uniformly a truth certificate for the claim." + }, + { + "name": "CoreReader.Evidence.supportWeakening", + "kind": "theorem", + "location": "CoreReader/Evidence.lean:228", + "meaning": "Preserves support when a supported claim implies a weaker claim at every world; it does not weaken the record set." + }, + { + "name": "CoreReader.Evidence.scopeRestriction", + "kind": "theorem", + "location": "CoreReader/Evidence.lean:245", + "meaning": "Restricts a universally supported property from a wider input domain to an included narrower domain, for arbitrary world and input types." + } + ], + "proof_and_scope": "ValuePosition derives commitment from selected=adopted and specializes reasons to the adopted option. ValueProcedure requires nonempty reasons, JointAdoption, scoped consequence under all stated reasons and an actual criticism response. It is a chosen procedural adapter, not a complete universal theory of good reasons or fulfillment by every application. Weakening and scope restriction remain explicit conditional theorems.", + "findings": [ + { + "branch": "same-claim-support", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "记录含实际test/result，经验/推论facet的claim与target必须相等；不是无解释support布尔字段。", + "previous_minimal_fix": null, + "current_analysis": "Grounds逐方面要求同一主张、对应表述与履责；价值接口改为选项/结果/目标/约束/理由，并要求联合可采纳世界，消除了任意重贴commitment及不一致起点通过的问题。 ValuePosition derives commitment from selected=adopted and specializes reasons to the adopted option. ValueProcedure requires nonempty reasons, JointAdoption, scoped consequence under all stated reasons and an actual criticism response. It is a chosen procedural adapter, not a complete universal theory of good reasons or fulfillment by every application. Weakening and scope restriction remain explicit conditional theorems.", + "current_code": [ + "CoreReader/Evidence.lean:112", + "CoreReader/Evidence.lean:228", + "CoreReader/Evidence.lean:245" + ], + "minimal_fix": null + }, + { + "branch": "conclusion-weakening", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "假设同记录支持p及p→q，推出支持q；另有删记录会失支持反例，不混淆证据弱化。", + "previous_minimal_fix": null, + "current_analysis": "Grounds逐方面要求同一主张、对应表述与履责；价值接口改为选项/结果/目标/约束/理由，并要求联合可采纳世界，消除了任意重贴commitment及不一致起点通过的问题。 ValuePosition derives commitment from selected=adopted and specializes reasons to the adopted option. ValueProcedure requires nonempty reasons, JointAdoption, scoped consequence under all stated reasons and an actual criticism response. It is a chosen procedural adapter, not a complete universal theory of good reasons or fulfillment by every application. Weakening and scope restriction remain explicit conditional theorems.", + "current_code": [ + "CoreReader/Evidence.lean:112", + "CoreReader/Evidence.lean:228", + "CoreReader/Evidence.lean:245" + ], + "minimal_fix": null + }, + { + "branch": "scope-restriction", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "将结论的量词域从wide缩为included narrow；不扩张观察域，也不补造现实可靠性。", + "previous_minimal_fix": null, + "current_analysis": "Grounds逐方面要求同一主张、对应表述与履责；价值接口改为选项/结果/目标/约束/理由，并要求联合可采纳世界，消除了任意重贴commitment及不一致起点通过的问题。 ValuePosition derives commitment from selected=adopted and specializes reasons to the adopted option. ValueProcedure requires nonempty reasons, JointAdoption, scoped consequence under all stated reasons and an actual criticism response. It is a chosen procedural adapter, not a complete universal theory of good reasons or fulfillment by every application. Weakening and scope restriction remain explicit conditional theorems.", + "current_code": [ + "CoreReader/Evidence.lean:112", + "CoreReader/Evidence.lean:228", + "CoreReader/Evidence.lean:245" + ], + "minimal_fix": null + }, + { + "branch": "articulation-and-aspects", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "概念/假设/理由/限度可储存，facet对齐并要求所有声明适用面，经验加非空in-scope world排除矛盾观察空真。", + "previous_minimal_fix": null, + "current_analysis": "Grounds逐方面要求同一主张、对应表述与履责；价值接口改为选项/结果/目标/约束/理由，并要求联合可采纳世界，消除了任意重贴commitment及不一致起点通过的问题。 ValuePosition derives commitment from selected=adopted and specializes reasons to the adopted option. ValueProcedure requires nonempty reasons, JointAdoption, scoped consequence under all stated reasons and an actual criticism response. It is a chosen procedural adapter, not a complete universal theory of good reasons or fulfillment by every application. Weakening and scope restriction remain explicit conditional theorems.", + "current_code": [ + "CoreReader/Evidence.lean:112", + "CoreReader/Evidence.lean:228", + "CoreReader/Evidence.lean:245" + ], + "minimal_fix": null + }, + { + "branch": "value-reason-correspondence", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "ValueProcedure不读取commitment或starting；替换任意不相关commitment不改变通过性。理由只需推出另一个任意consequence，不能确保陈述的是此立场的理由。False-commitment探针不是要求价值立场证明为真，而是揭示对应关系缺失。", + "previous_minimal_fix": "给可审查的立场/理由相关性与后果关系接口及非空实例，允许未证明的价值起点，拒绝不相关重贴和纯自断言；不必强制reason逻辑推出commitment。", + "current_analysis": "Evidence.lean:28–59中commitment由selected/adopted导出，reasons依选项变化；JointAdoption排除无可满足起点。switchPosition实际后果匹配选项，并拒绝反选项与不可能起点。", + "current_code": [ + "CoreReader/Evidence.lean:112", + "CoreReader/Evidence.lean:228", + "CoreReader/Evidence.lean:245" + ], + "minimal_fix": null + }, + { + "branch": "full-compliance-versus-interface", + "status": "accepted", + "previous_status": "rejected", + "previous_analysis": "当前接口还允许空limits和恒定非空字符串使关键责任空真；原文保留适用性，但此代码不能由字段存在声称已经开放于相关批评。", + "previous_minimal_fix": "为作为完成见证的实例给实际适用世界和内容相关批评/响应，不把整个通用域强行设非空，也不将接口当现实履行证明。", + "current_analysis": "Grounds是采纳接口；每个已列facet都须同claim、匹配表述并履责。有限实例表明部分实际履行，不能把定义或空适用列表读作所有现实责任已经履行。", + "current_code": [ + "CoreReader/Evidence.lean:112", + "CoreReader/Evidence.lean:228", + "CoreReader/Evidence.lean:245" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T16", + "status": "accepted", + "reason": "义务并集、标签不能豁免以及同一switch主张的经验加价值缺责反例成立；canonical表述按方面实际内容构造。", + "reason_en": "Grounds quantifies applicable facets independently of labels and checks every listed facet. The mixed example omits a truly applicable value facet of the same claim, so empirical discharge alone fails. The three facet constructors model responsibilities, not mutually exclusive exhaustive philosophical kinds.", + "reason_zh": "义务并集、标签不能豁免以及同一switch主张的经验加价值缺责反例成立；canonical表述按方面实际内容构造。", + "classification": "D union theorem and W mixed case", + "previous_status": "accepted", + "previous_reason": "面向义务的并集/标签不变和同一switch claim的经验＋价值缺责反例完整；规范接口局限另见T15。", + "source_refs": [ + { + "unit": "organon.grounds.assessment", + "clause": "p1" + }, + { + "unit": "organon.grounds.assessment", + "clause": "p2" + }, + { + "unit": "organon.grounds.assessment", + "clause": "p3" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Evidence.assessmentUnion", + "kind": "theorem", + "location": "CoreReader/Evidence.lean:261", + "meaning": "Proves that discharging the union of two applicability predicates is equivalent to discharging each separately." + }, + { + "name": "CoreReader.Evidence.labelsCannotWaive", + "kind": "theorem", + "location": "CoreReader/Evidence.lean:272", + "meaning": "Proves changing labels cannot change duties because labels were ignored by definition; no external classification mechanism is analyzed." + }, + { + "name": "CoreReader.Evidence.mixedMissingResponsibility", + "kind": "case", + "location": "CoreReader/Evidence.lean:362", + "meaning": "Shows a discharged empirical facet does not discharge a union of applicable facets when an included value facet has no reasons." + } + ], + "proof_and_scope": "Grounds quantifies applicable facets independently of labels and checks every listed facet. The mixed example omits a truly applicable value facet of the same claim, so empirical discharge alone fails. The three facet constructors model responsibilities, not mutually exclusive exhaustive philosophical kinds.", + "findings": [ + { + "branch": "union-not-exclusive", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "Facet是单面向枚举，但适用关系可同时选多个facet，union定理合并义务而非强制单选。", + "previous_minimal_fix": null, + "current_analysis": "义务并集、标签不能豁免以及同一switch主张的经验加价值缺责反例成立；canonical表述按方面实际内容构造。 Grounds quantifies applicable facets independently of labels and checks every listed facet. The mixed example omits a truly applicable value facet of the same claim, so empirical discharge alone fails. The three facet constructors model responsibilities, not mutually exclusive exhaustive philosophical kinds.", + "current_code": [ + "CoreReader/Evidence.lean:261", + "CoreReader/Evidence.lean:272", + "CoreReader/Evidence.lean:362" + ], + "minimal_fix": null + }, + { + "branch": "unlabeled-duty", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "空标签不改变applicable责任；这是显式规范设计的定义后果，非实证分类器。", + "previous_minimal_fix": null, + "current_analysis": "义务并集、标签不能豁免以及同一switch主张的经验加价值缺责反例成立；canonical表述按方面实际内容构造。 Grounds quantifies applicable facets independently of labels and checks every listed facet. The mixed example omits a truly applicable value facet of the same claim, so empirical discharge alone fails. The three facet constructors model responsibilities, not mutually exclusive exhaustive philosophical kinds.", + "current_code": [ + "CoreReader/Evidence.lean:261", + "CoreReader/Evidence.lean:272", + "CoreReader/Evidence.lean:362" + ], + "minimal_fix": null + }, + { + "branch": "actual-mixed-claim", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "switchEmpirical与unsupportedPosition同为w=true的主张；经验面实际discharged，价值面reasons=[]使义务失败，非两个无关claim标签。", + "previous_minimal_fix": null, + "current_analysis": "义务并集、标签不能豁免以及同一switch主张的经验加价值缺责反例成立；canonical表述按方面实际内容构造。 Grounds quantifies applicable facets independently of labels and checks every listed facet. The mixed example omits a truly applicable value facet of the same claim, so empirical discharge alone fails. The three facet constructors model responsibilities, not mutually exclusive exhaustive philosophical kinds.", + "current_code": [ + "CoreReader/Evidence.lean:261", + "CoreReader/Evidence.lean:272", + "CoreReader/Evidence.lean:362" + ], + "minimal_fix": null + }, + { + "branch": "three-facet-and-articulation-elements", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "四类表达要素和三种责任接口独立存在；本项通过不认可ValueProcedure是完整价值正当性判定器。", + "previous_minimal_fix": null, + "current_analysis": "义务并集、标签不能豁免以及同一switch主张的经验加价值缺责反例成立；canonical表述按方面实际内容构造。 Grounds quantifies applicable facets independently of labels and checks every listed facet. The mixed example omits a truly applicable value facet of the same claim, so empirical discharge alone fails. The three facet constructors model responsibilities, not mutually exclusive exhaustive philosophical kinds.", + "current_code": [ + "CoreReader/Evidence.lean:261", + "CoreReader/Evidence.lean:272", + "CoreReader/Evidence.lean:362" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T17", + "status": "accepted", + "reason": "表述清楚、测量/重复、相容与自述均有实际不足反模型；价值反例针对对应选项的预算后果，不能冒充价值命题恒假。", + "reason_en": "Counterworlds invalidate support or entailment while preserving the stated observations or compatibility. unrelatedArticulationRejected ties articulation content to the facet. Self-assertion has empty reasons or fails the option-specific consequence, rather than being rejected merely for its label.", + "reason_zh": "表述清楚、测量/重复、相容与自述均有实际不足反模型；价值反例针对对应选项的预算后果，不能冒充价值命题恒假。", + "classification": "W countermodels", + "previous_status": "accepted", + "previous_reason": "所列不充分替代物有实际内容反模型；非蕴涵未被说成结论恒假。价值反例只证明所示理由/预算责任失败，不是价值真理。", + "source_refs": [ + { + "unit": "organon.grounds.assessment", + "clause": "p1" + }, + { + "unit": "organon.grounds.assessment", + "clause": "p2" + }, + { + "unit": "organon.grounds.assessment", + "clause": "p3" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Evidence.articulationNotSupport", + "kind": "case", + "location": "CoreReader/Evidence.lean:377", + "meaning": "Proves this articulation passes the nonemptiness check while its assumptions do not entail that the world is true." + }, + { + "name": "CoreReader.Evidence.measurementRepeatNotSupport", + "kind": "case", + "location": "CoreReader/Evidence.lean:451", + "meaning": "Combines explicit countermodels showing that repeated measurement of one coordinate does not support an unmeasured coordinate or a budget consequence, and does not fix the announcement value procedure." + }, + { + "name": "CoreReader.Logic.compatibilityNotEntailment", + "kind": "case", + "location": "CoreReader/Logic.lean:229", + "meaning": "Shows that adding a claim can remain satisfiable even though the original empty theory did not entail that claim." + }, + { + "name": "CoreReader.Evidence.selfAssertionNotReason", + "kind": "case", + "location": "CoreReader/Evidence.lean:478", + "meaning": "Combines empty-reason and nonempty-but-budget-irrelevant self-assertion failures, with a joint adoption witness for the latter." + } + ], + "proof_and_scope": "Counterworlds invalidate support or entailment while preserving the stated observations or compatibility. unrelatedArticulationRejected ties articulation content to the facet. Self-assertion has empty reasons or fails the option-specific consequence, rather than being rejected merely for its label.", + "findings": [ + { + "branch": "articulated-not-established", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "非空concept/reasons但emptyTheory不支持w=true；另有不相关articulation与facet对齐失败。", + "previous_minimal_fix": null, + "current_analysis": "表述清楚、测量/重复、相容与自述均有实际不足反模型；价值反例针对对应选项的预算后果，不能冒充价值命题恒假。 Counterworlds invalidate support or entailment while preserving the stated observations or compatibility. unrelatedArticulationRejected ties articulation content to the facet. Self-assertion has empty reasons or fails the option-specific consequence, rather than being rejected merely for its label.", + "current_code": [ + "CoreReader/Evidence.lean:377", + "CoreReader/Evidence.lean:451", + "CoreReader/Logic.lean:229", + "CoreReader/Evidence.lean:478" + ], + "minimal_fix": null + }, + { + "branch": "measurable-not-relevant-or-correct", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "第一coordinate可测且重复结果稳定，第二coordinate可true/false；单次和重复均不支持未测结论。", + "previous_minimal_fix": null, + "current_analysis": "表述清楚、测量/重复、相容与自述均有实际不足反模型；价值反例针对对应选项的预算后果，不能冒充价值命题恒假。 Counterworlds invalidate support or entailment while preserving the stated observations or compatibility. unrelatedArticulationRejected ties articulation content to the facet. Self-assertion has empty reasons or fails the option-specific consequence, rather than being rejected merely for its label.", + "current_code": [ + "CoreReader/Evidence.lean:377", + "CoreReader/Evidence.lean:451", + "CoreReader/Logic.lean:229", + "CoreReader/Evidence.lean:478" + ], + "minimal_fix": null + }, + { + "branch": "repeat-not-value-reasons", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "action=true记录与budget0和3都兼容，无法支持budget consequence；非空announcement自述仍未履行价值reason→consequence检查。", + "previous_minimal_fix": null, + "current_analysis": "表述清楚、测量/重复、相容与自述均有实际不足反模型；价值反例针对对应选项的预算后果，不能冒充价值命题恒假。 Counterworlds invalidate support or entailment while preserving the stated observations or compatibility. unrelatedArticulationRejected ties articulation content to the facet. Self-assertion has empty reasons or fails the option-specific consequence, rather than being rejected merely for its label.", + "current_code": [ + "CoreReader/Evidence.lean:377", + "CoreReader/Evidence.lean:451", + "CoreReader/Logic.lean:229", + "CoreReader/Evidence.lean:478" + ], + "minimal_fix": null + }, + { + "branch": "compatibility-not-entailment", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "加入w=true与emptyTheory相容，但emptyTheory并不蕴涵它；有true/false反世界。", + "previous_minimal_fix": null, + "current_analysis": "表述清楚、测量/重复、相容与自述均有实际不足反模型；价值反例针对对应选项的预算后果，不能冒充价值命题恒假。 Counterworlds invalidate support or entailment while preserving the stated observations or compatibility. unrelatedArticulationRejected ties articulation content to the facet. Self-assertion has empty reasons or fails the option-specific consequence, rather than being rejected merely for its label.", + "current_code": [ + "CoreReader/Evidence.lean:377", + "CoreReader/Evidence.lean:451", + "CoreReader/Logic.lean:229", + "CoreReader/Evidence.lean:478" + ], + "minimal_fix": null + }, + { + "branch": "self-assertion-not-reason", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "既有空reason反例，也有非空真自述在budget0不能推出所声称后果的内容性反例。", + "previous_minimal_fix": null, + "current_analysis": "表述清楚、测量/重复、相容与自述均有实际不足反模型；价值反例针对对应选项的预算后果，不能冒充价值命题恒假。 Counterworlds invalidate support or entailment while preserving the stated observations or compatibility. unrelatedArticulationRejected ties articulation content to the facet. Self-assertion has empty reasons or fails the option-specific consequence, rather than being rejected merely for its label.", + "current_code": [ + "CoreReader/Evidence.lean:377", + "CoreReader/Evidence.lean:451", + "CoreReader/Logic.lean:229", + "CoreReader/Evidence.lean:478" + ], + "minimal_fix": null + } + ] + }, + { + "id": "T18", + "status": "accepted", + "reason": "有限价值立场有可满足但无需自证的起点、选项相关理由、限度、后果和批评响应；两理由联合充分而各自不足，异类方面无需统一尺度。", + "reason_en": "switchPosition has a checked admissible joint adoption and rejects the opposite option and impossible starts. jointReasonPosition combines benefit/cost premises with counterworlds showing neither alone supports the consequence. No theorem proves the ultimate worth of the adopted value or every starting assumption.", + "reason_zh": "有限价值立场有可满足但无需自证的起点、选项相关理由、限度、后果和批评响应；两理由联合充分而各自不足，异类方面无需统一尺度。", + "classification": "W/N procedural satisfiability", + "previous_status": "accepted", + "previous_reason": "具体switch价值立场有成本/收益理由、限度、非空批评响应及可满足起点，并未从空理论推出承诺；异类支持不用统一数值尺度。", + "source_refs": [ + { + "unit": "organon.grounds.assessment", + "clause": "p1" + }, + { + "unit": "organon.grounds.assessment", + "clause": "p2" + }, + { + "unit": "organon.grounds.assessment", + "clause": "p3" + } + ], + "required_declarations": [ + { + "name": "CoreReader.Evidence.valueWithoutSelfProof", + "kind": "case", + "location": "CoreReader/Evidence.lean:493", + "meaning": "Exhibits a coherent reasoned position not derivable from empty assumptions, and rejects opposite-option, inconsistent-start and impossible-adoption variants." + }, + { + "name": "CoreReader.Evidence.heterogeneousReasons", + "kind": "case", + "location": "CoreReader/Evidence.lean:564", + "meaning": "Combines empirical, inferential and value examples with a genuine two-reason combination that neither reason alone establishes." + } + ], + "proof_and_scope": "switchPosition has a checked admissible joint adoption and rejects the opposite option and impossible starts. jointReasonPosition combines benefit/cost premises with counterworlds showing neither alone supports the consequence. No theorem proves the ultimate worth of the adopted value or every starting assumption.", + "findings": [ + { + "branch": "reasons-limits-consequence-openness", + "status": "accepted", + "previous_status": "accepted", + "previous_analysis": "成本/收益理由与所选择true选项有具体关系，推出cost