GENERATOR B PORTABLE CONTRACT: egb-finite-boolean-v1

Scope
The only semantic input to this author is ORIGINAL-INSTRUCTION.txt, a byte-exact
copy of the source instruction supplied by the main instance. This independent
contract is deliberately defined without consulting any target interface.
The corpus is a finite Boolean epistemic task. It is not a diagnosis run.

Transport inventory and authority
corpus/development/inputs.json: exactly 32 independent development case records.
corpus/development/private.json: hidden worlds, labels, proofs and explanations.
corpus/development/index.json: development provenance and structural identities.
corpus/sealed-test/inputs.json: exactly 60 test case records, to remain sealed.
corpus/sealed-test/private.json: hidden worlds, labels, proofs and explanations.
corpus/sealed-test/core-index.json: 20 independent test evidence/query cores.
corpus/sealed-test/minimal-pairs.json: 30 one-evidence-statement pair mappings.
corpus/sealed-test/invariance-groups.json: 20 three-representation mappings.
corpus/CONFIG.json: exact seeds, counts, bounds and representation schedule.
All private files, maps and indices are evaluator-only. They must never be
included in a target request. No sealed input may currently be sent to a target.

Each input record is complete and uses the same independent contract:
{
  "case_id": opaque unique string,
  "contract": "egb-finite-boolean-v1",
  "universe": {"atoms": ordered list of distinct strings,
               "domain": [false, true]},
  "evidence": {"representation": "tree" | "postfix" | "relation",
               "statements": list of formulas in that representation},
  "claim": one formula in the same representation
}
The evidence statements are jointly asserted true. They are the entire evidence
available for the claim. No hidden world, taxonomy, paired case, corpus frequency,
label, ID pattern or non-input metadata is available evidence.
Every declared atom independently ranges over false and true; all 2**n complete
assignments must be considered before evidence filtering. An unasserted atom is
unknown rather than false. No external facts or commonsense interpretation apply.
Evidence is guaranteed satisfiable. Atom strings are uninterpreted symbols.
List order never expresses priority. Constraints jointly restrict assignments.

Formula representation 1: tree
An atom is {"op":"ref", "atom": declared_atom_string}.
Other formulas are {"op": operator, "args": ordered_list_of_subformulas}.
Operators:
  not: exactly one argument; Boolean complement.
  all: conjunction of all arguments.
  any: disjunction of all arguments.
  xor: true iff an odd number of argument occurrences evaluate true.
  iff: exactly two arguments; true iff their Boolean values agree.
  implies: exactly two arguments; false only for true antecedent/false consequent.
  count: additional integer keys minimum and maximum; true iff the number of
         true argument occurrences lies in the inclusive interval [minimum,maximum].
Arguments to count are Boolean formulas, counted per occurrence. Corpus formulas
use nonempty argument lists and do not repeat atom arguments within a count.
Canonical semantics permit nesting. iff and implies are binary, not n-ary.

Formula representation 2: postfix
A formula is a JSON token list evaluated on an initially empty Boolean stack.
{"op":"push", "atom": name} pushes that atom's value.
An operator token has op and integer arity, plus minimum/maximum for count.
Pop exactly arity values preserving their left-to-right order and push the
operator's result. implies treats the first popped operand as antecedent.
The entire list must leave exactly one value. No variables outside the universe.
The generator creates programs by postorder traversal of trees.

Formula representation 3: relation
A formula is {"scope": ordered_list_of_distinct_declared_atoms,
              "true_rows": list_of_unique_equal_length_binary_strings}.
It is true exactly when the current assignment restricted to scope yields a
listed row; the first row character corresponds to scope[0]. Unlisted rows make
that formula false. Each evidence relation is one Boolean constraint, not an
alternative possible world. Evidence relations are conjoined, including those
whose scopes overlap. The claim relation is evaluated against the same worlds.
Truth rows do not assert individual atoms in isolation. Other declared atoms
remain free unless constrained by additional evidence.

Requested epistemic response contract (for any later independently authorized run)
{"case_id": original_id, "epistemic": "KNOWN" | "UNKNOWN",
 "known_value": true | false | null}
KNOWN with true means every evidence-consistent world makes the claim true.
KNOWN with false means every evidence-consistent world makes the claim false.
UNKNOWN with null means at least one consistent world makes it true and at least
one makes it false. A factual guess matching the hidden world is still incorrect
when labelled KNOWN without universal support. UNKNOWN does not mean false.
The hidden factual value is not part of the epistemic response.

Private record and certificates
Each private record links by case_id, has split/core/family/representation,
canonical_evidence and canonical_claim as trees, a complete hidden_world, its
hidden_world_index, actual_claim_value, a label in the response contract, a proof,
derivation_notes, justification and structural_fingerprint.
World index = sum(int(value[universe.atoms[j]])*2**j).
The proof lists the worlds surviving each successive evidence statement, the
complete final admissible set, its true-claim and false-claim partitions, the
exhaustive universe size, and smallest witnesses to both values when present.
These are formal exhaustive derivation steps, not natural-language reasoning
substituted for a proof. A missing partition is null witness. Known proofs show
one partition empty; unknown proofs provide both witnesses. The finite bounds
make completeness, satisfiability, witnesses and hidden worlds machine verifiable.

Formal check command
python3 -B -I -S verify.py corpus
This evaluates all case formulas with an independent bit-parallel implementation
and checks all certificates, response labels, hidden factual values, invariance
and minimal-pair obligations. It never invokes a diagnosis function.

Deterministic reproduction
python3 -B -I -S generate.py NEW_DESCENDANT_DIRECTORY
The destination must not already exist and must be below this artifact root.
It must not be a sealed destination. The nine generated payload files reproduce
byte-for-byte with the archived generator and standard-library Python. Generation
uses only the fixed seeds in code, which are also materialized in CONFIG.json.
Timestamps and access audit are packaging metadata, not random generation inputs.
REPRODUCTION-REPORT.json records a second independent build and byte comparisons.
Creation commands should continue to be audited by a receiving instance.

Firewall compatibility rule
This contract was not designed to match a known implementation. Compatibility
inspection may check that the receiving firewall accepts these records exactly.
If input adaptation is needed, STOP and document it. No silent translation,
semantic repair, removal, relabelling, corpus tuning or target execution is
authorized. The seal does not authorize E006 execution and is not an E006 PASS.
