diff --git a/HexManual/Chapters/HexRCF/AlgebraicCells.lean b/HexManual/Chapters/HexRCF/AlgebraicCells.lean index d55c2a6a3a..57ee561191 100644 --- a/HexManual/Chapters/HexRCF/AlgebraicCells.lean +++ b/HexManual/Chapters/HexRCF/AlgebraicCells.lean @@ -602,7 +602,9 @@ Its default proof callback, `FieldRuntime.nonnegative`, attempts routine nonnegativity facts and restores its state on decline. A caller can supply another callback returning an ordinary proof or `none`; thrown exceptions remain terminal. Preparation checks each supplied proof and retains one -aggregate reflection budget across the source, coefficients and divisors: +aggregate reflection budget across the source, coefficients and divisors. +The source equivalence is charged during reification and again when retained +as a private theorem for later composition: ```lean open Lean Meta Qq @@ -628,6 +630,64 @@ authenticate quoted literals for the computed proposals. This preparation API does not install a new `rcf` handler or close the remaining frozen-context, literal-authentication and general source-quotation obligations. +For the retained algebraic expressions, `prepared.acceptanceIff` proves an exact +acceptance equivalence. The left side requires the actual algebraic producer +to return a complete packet and that packet's checker to accept `true`. The +right side contains both the original real statement and every original +divisor's nonzero condition. Guard validity is a conclusion of acceptance, +even when cancellation or an empty interval makes the statement trivial. +The helper reconstructs the ordered original guard inventory from the target; +editing both stored guard arrays cannot remove or replace an obligation. +The existing producer completeness and domain laws prove this equivalence; +no successful child calculation is assumed. + +```lean +open Hex Lean Meta Qq +open Hex.RCF.RealCoefficients +open Hex.RealClosure.BaseContext +run_meta do + let target : Q(Prop) := + q(∀ x : ℝ, x^2 + Real.sqrt 2 > 0) + let .ok prepared ← + AlgebraicPreparation.prepare + target + | throwError "unsupported source" + let before := prepared.usage + let registry : Q(Registry) := + q(fun _ => none) + let .ok (equivalence, usage) ← + prepared.acceptanceIff + target registry + | throwError + "source equivalence failed" + let auxName := mkPrivateName + (← getEnv) + (← mkFreshUserName `sourceDoc) + let _ ← + withDeclNameForAuxNaming + auxName do + Hex.RCF.checkProof + `sourceAcceptance + (← inferType equivalence) + equivalence + unless usage.proofNodes > + before.proofNodes do + throwError + "proof usage did not increase" +``` + +This proof uses the checked algebraic expressions and their source identities. +It does not identify separately computed proposals with frozen literals, +reconstruct provider histories, or add a tactic handler. Those authentication +and quotation obligations remain separate. The helper continues the same +aggregate reflection budget, returns its updated usage for later stages, and +restores caller state on exhaustion or failure. +Callers continue with `{prepared with usage}` when constructing further proofs. +Both preparation and acceptance preserve a caller's lowered recursion limit. +Fresh importing regressions check its actual theorem bodies, true and false +sources, retained zero guards and reversed intervals, with exactly the standard +three axioms. + The automatic-input conformance uses both selected signs of √2 alongside an independent positive √3. It checks simultaneous conditions and a repeated zero root, both true and false quantified verdicts, an unused zero input, a late diff --git a/adapters/HexRCF/RealCoefficients/AlgebraicCells.lean b/adapters/HexRCF/RealCoefficients/AlgebraicCells.lean index 9acffc3be7..63d7d8abbc 100644 --- a/adapters/HexRCF/RealCoefficients/AlgebraicCells.lean +++ b/adapters/HexRCF/RealCoefficients/AlgebraicCells.lean @@ -296,4 +296,79 @@ theorem build_sound (registry : BaseContext.Registry) (generators : Fin m → Re cases same exact checked +/-- Acceptance by the actual algebraic producer and its complete packet +checker. This predicate retains the exact source tuple, indices and original +nonzero-divisor obligations; it does not assert frozen-history quotation. -/ +@[expose] def accepts (registry : BaseContext.Registry) (generators : Fin m → RealAlgebraicNumber) + (indices : Fin n → Fin m) (original : List (Fin m)) + (formula : Hex.RealFormula.QF (n+1)) (quantifier : Hex.RealFormula.Quantifier) : Prop := + ∃ result, build registry generators indices original formula = .ok result ∧ + let sources := result.1 + let shared := result.2.1 + let packet := result.2.2 + CompleteReplay.check packet.family.collection.input.context.codec + (packet.family.collection.input.value ∘ GatherCells.values shared (coefficients sources indices)) formula + ((GatherCells.guards shared (guards sources original)).map packet.family.collection.input.value) + packet.radical quantifier packet.rootGraph packet.cells = .ok true + +/-- Accepted true packets are equivalent to the original domains and shared +sentence together. Guard validity, complete roots and real samples follow +from the producer's existing laws, without a child-success hypothesis. -/ +theorem accepts_iff (registry : BaseContext.Registry) (generators : Fin m → RealAlgebraicNumber) + (indices : Fin n → Fin m) (original : List (Fin m)) + (formula : Hex.RealFormula.QF (n+1)) (quantifier : Hex.RealFormula.Quantifier) : + accepts registry generators indices original formula quantifier ↔ + (∀ i ∈ original, (generators i).toReal ≠ 0) ∧ + (Hex.RealFormula.Prenex.quant quantifier (.matrix formula)).toProp + (fun i => (generators (indices i)).toReal) := by + constructor + · rintro ⟨result, produced, accepted⟩ + refine ⟨build_domains registry generators indices original formula result.1 result.2 produced, ?_⟩ + obtain ⟨verdict, checked, meaning⟩ := + build_sound registry generators indices original formula result produced quantifier + have same : verdict = true := Except.ok.inj (checked.symm.trans accepted) + exact meaning.mp same + · rintro ⟨domains, truth⟩ + have nonzero : ∀ i ∈ original, generators i ≠ 0 := by + intro i member zero + apply domains i member + simp only [zero, RealAlgebraicNumber.zero_toReal] + obtain ⟨sources, shared, packet, produced, checked⟩ := + build_complete registry generators indices original formula nonzero + obtain ⟨verdict, accepted, meaning⟩ := checked quantifier + have same : verdict = true := meaning.mpr truth + exact ⟨⟨sources, shared, packet⟩, produced, by simpa only [same] using accepted⟩ + +/-- Coefficient and original-divisor coordinates have separate ordered +positions in the native producer. Every divisor remains a checked domain. -/ +theorem accepts_tuple (registry : BaseContext.Registry) + (values : Fin n → RealAlgebraicNumber) (divisors : Fin d → RealAlgebraicNumber) + (formula : Hex.RealFormula.QF (n+1)) (quantifier : Hex.RealFormula.Quantifier) : + accepts registry (Fin.addCases values divisors) (Fin.castAdd d) + (List.ofFn (Fin.natAdd n)) formula quantifier ↔ + (∀ i, (divisors i).toReal ≠ 0) ∧ + (Hex.RealFormula.Prenex.quant quantifier (.matrix formula)).toProp + (fun i => (values i).toReal) := by + rw [accepts_iff] + simp + +/-- Checked valuation identities and the frontend's exact equivalence connect +producer acceptance to the original proposition and every original divisor. +The identities are ordinary proof inputs supplied by source preparation. -/ +theorem accepts_source (registry : BaseContext.Registry) + (values : Fin n → RealAlgebraicNumber) (divisors : Fin d → RealAlgebraicNumber) + (realValues : Fin n → ℝ) (realDivisors : Fin d → ℝ) + (formula : Hex.RealFormula.QF (n+1)) (quantifier : Hex.RealFormula.Quantifier) + {source : Prop} + (coefficientEq : (fun i => (values i).toReal) = realValues) + (divisorEq : (fun i => (divisors i).toReal) = realDivisors) + (equivalence : (Hex.RealFormula.Prenex.quant quantifier (.matrix formula)).toProp realValues ↔ source) : + accepts registry (Fin.addCases values divisors) (Fin.castAdd d) + (List.ofFn (Fin.natAdd n)) formula quantifier ↔ + (∀ i, realDivisors i ≠ 0) ∧ source := by + rw [accepts_tuple, coefficientEq] + have domains : (∀ i, (divisors i).toReal ≠ 0) ↔ (∀ i, realDivisors i ≠ 0) := by + rw [← divisorEq] + exact and_congr domains equivalence + end Hex.RCF.RealCoefficients.AlgebraicCells diff --git a/adapters/HexRCF/RealCoefficients/AlgebraicPreparation.lean b/adapters/HexRCF/RealCoefficients/AlgebraicPreparation.lean index f08a1a7bb8..b7cfef4d86 100644 --- a/adapters/HexRCF/RealCoefficients/AlgebraicPreparation.lean +++ b/adapters/HexRCF/RealCoefficients/AlgebraicPreparation.lean @@ -15,7 +15,7 @@ computed values are proposals. This does not quote a complete certificate or install a tactic handler. In particular the producer's native context is not a frozen source/history certificate. -/ namespace Hex.RCF.RealCoefficients.AlgebraicPreparation -open Hex Lean Meta +open Hex Lean Meta Qq /-- A checked source interpretation and its executable proposal. The proof identifies `expression.toReal` with the source, not with a quoted proposal. -/ @@ -33,6 +33,8 @@ structure Inputs where formula : RealFormula.QF (source.coefficients.size+1) quantifier : RealFormula.Quantifier usage : Hex.Reflect.BudgetUsage + /-- Continue proof construction under the same reflection limits. -/ + config : Hex.RealFormula.Reify.Config /-- Keep coefficient coordinates first and every original divisor afterward. No equality of independently computed algebraic representations is assumed. -/ @@ -47,7 +49,7 @@ def Inputs.indices (environment : Inputs) : Fin environment.source.coefficients. def Inputs.guards (environment : Inputs) : List (Fin (environment.source.coefficients.size + environment.source.divisors.size)) := - (List.finRange environment.source.divisors.size).map (Fin.natAdd environment.source.coefficients.size) + List.ofFn (Fin.natAdd environment.source.coefficients.size) /-- The original selected presentations and their complete native packet. -/ abbrev Inputs.Result (environment : Inputs) (registry : RealClosure.BaseContext.Registry) := @@ -77,7 +79,8 @@ def Inputs.buildWith (environment : Inputs) (registry : RealClosure.BaseContext. Core.checkInterrupted consumeBuilt environment registry (environment.build registry) consume -private def entry (source : Expr) (prepared : Coefficients.Prepared) : MetaM Entry := do +private def entry (source : Expr) (prepared : Coefficients.Prepared) : + Hex.RealFormula.Reify.ReifyM Entry := do let expression ← instantiateMVars prepared.value let identity ← instantiateMVars prepared.proof unless !expression.hasFVar && !expression.hasMVar && !expression.hasLooseBVars do @@ -85,6 +88,7 @@ private def entry (source : Expr) (prepared : Coefficients.Prepared) : MetaM Ent let expression ← Hex.RCF.checkExpr `AlgebraicPreparation.input expression -- Interpretation's debug kernel check does not enforce this exact target -- or screen its axioms. Retain the checked, private source identity. + Hex.RealFormula.Reify.accountProof identity let identity ← Hex.RCF.checkProof `AlgebraicPreparation.identity (← mkEq (← mkAppM ``RealAlgebraicNumber.toReal #[expression]) source) identity Core.checkInterrupted @@ -99,6 +103,19 @@ private def prepareCore (target : Expr) (nonnegative : Expr → MetaM (Option Ex | .ok source => pure source | .error error => return .error error Core.checkInterrupted + -- Reification checked the raw equivalence. Charge its additional private + -- retention before the kernel check; later assembly checks only this constant. + let retain : Hex.RealFormula.Reify.ReifyM Unit := + Hex.RealFormula.Reify.accountProof source.proof + let retained ← (retain.run + {config, budget := {initial := config.ring.budget, consumed := source.usage}}).run + let usage ← match retained with + | .error error => return .error error + | .ok (_, state) => pure state.budget.consumed + let sourceType ← mkAppM ``Iff + #[← mkAppM ``RealFormula.Prenex.toProp #[source.formula, source.valuation], target] + let equivalence ← Hex.RCF.checkProof `AlgebraicPreparation.equivalence sourceType source.proof + let source := {source with proof := equivalence} let .quant quantifier (.matrix formula) ← FieldRuntime.evalFormula source.coefficients.size source.formula | return .error (.unsupported target "expected exactly one real quantifier") Core.checkInterrupted @@ -107,18 +124,19 @@ private def prepareCore (target : Expr) (nonnegative : Expr → MetaM (Option Ex Coefficients.interpret source.coefficients[i] nonnegative let divisors ← Vector.ofFnM fun i : Fin source.divisors.size => Coefficients.interpret source.divisors[i] nonnegative + let coefficients ← Vector.ofFnM fun i => entry source.coefficients[i] coefficients[i] + let divisors ← Vector.ofFnM fun i => entry source.divisors[i] divisors[i] pure (coefficients,divisors)).run - {config,budget := {initial := config.ring.budget,consumed := source.usage}}).run + {config,budget := {initial := config.ring.budget,consumed := usage}}).run match interpreted with | .error error => return .error error | .ok ((coefficients,divisors),state) => - let coefficients ← Vector.ofFnM fun i => entry source.coefficients[i] coefficients[i] - let divisors ← Vector.ofFnM fun i => entry source.divisors[i] divisors[i] return .ok { source := source formula := formula quantifier := quantifier usage := state.budget.consumed + config := config coefficients := coefficients divisors := divisors } @@ -126,15 +144,19 @@ private def prepareCore (target : Expr) (nonnegative : Expr → MetaM (Option Ex presentations. Reuse shared source lowering, all original divisor obligations and aggregate reflection accounting. Unsupported syntax and resource failures remain distinct; failed attempts restore the complete elaborator state. +The source equivalence consumes proof budget during reification and again +when retained as a checked private theorem for later composition. Proposals require executable closed constructions. Native compilation failures and exceptions from callbacks are terminal, rather than syntax declines. -/ def prepare (target : Expr) (nonnegative : Expr → MetaM (Option Expr) := FieldRuntime.nonnegative) (config : Hex.RealFormula.Reify.Config := {}) : MetaM (Except Hex.RealFormula.Reify.Error Inputs) := do let saved ← saveState + let depthLimit := (← readThe Core.Context).maxRecDepth let auxName := mkPrivateName (← getEnv) (← mkFreshUserName `AlgebraicPreparation) - let (result,_) ← tryFinally' (withDeclNameForAuxNaming auxName <| withNewMCtxDepth <| withOptions (fun options => - debug.skipKernelTC.set (Elab.async.set options false) false) + let (result,_) ← tryFinally' (withDeclNameForAuxNaming auxName <| withNewMCtxDepth <| Core.withIncRecDepth <| + withOptions (fun options => maxRecDepth.set + (debug.skipKernelTC.set (Elab.async.set options false) false) depthLimit) (prepareCore target nonnegative config)) fun result => do match result with | some (.ok _) => modify fun state => {state with @@ -142,4 +164,101 @@ def prepare (target : Expr) (nonnegative : Expr → MetaM (Option Expr) := Field zetaDeltaFVarIds := saved.meta.zetaDeltaFVarIds} | _ => saved.restore return result + +private def sourceFunction (entries : Array Entry) (sources : Array Expr) + (expected : Expr) : Hex.RealFormula.Reify.ReifyM (Expr × Expr) := do + unless entries.size == sources.size do throwError "source identity count differs from its source coordinates" + let zero : Q(RealAlgebraicNumber) := q(RealAlgebraicNumber.ofRat 0) + let mut values : Array Expr := #[] + let mut proofs : Array Expr := #[] + for (entry, source) in entries.zip sources do + Core.checkInterrupted + let value ← instantiateMVars entry.expression + unless !value.hasFVar && !value.hasMVar && !value.hasLooseBVars do + throwError "source acceptance requires closed algebraic expressions" + let value ← Hex.RCF.checkExpr `sourceAcceptanceValue value + let type ← mkEq (← mkAppM ``RealAlgebraicNumber.toReal #[value]) source + Hex.RealFormula.Reify.accountProof entry.identity + let proof ← Hex.RCF.checkProof `sourceAcceptanceIdentity type entry.identity + Core.checkInterrupted + values := values.push value + proofs := proofs.push proof + let function ← FieldLiteral.finiteExpr (mkConst ``RealAlgebraicNumber) values zero + let domain := mkApp (mkConst ``Fin) (mkNatLit entries.size) + let pointwise ← withLocalDeclD `i domain fun i => do + let actual ← mkAppM ``RealAlgebraicNumber.toReal #[mkApp function i] + mkForallFVars #[i] (← mkEq actual (mkApp expected i)) + let identity ← mkAppM ``funext #[← FieldLiteral.proveFinCases pointwise proofs] + Core.checkInterrupted + return (function, identity) + +private def acceptanceCore (prepared : Inputs) (target registry : Expr) : + Hex.RealFormula.Reify.ReifyM Expr := do + Core.checkSystem "rcf source acceptance" + let source := prepared.source + let original ← instantiateMVars source.original + let target ← instantiateMVars target + unless original == target do throwError "source acceptance has a different original target" + let divisors ← Reify.guardSources target + let retained ← source.divisors.mapM instantiateMVars + unless divisors == retained do + throwError "source acceptance has a different original divisor inventory" + let sourceType ← mkAppM ``Iff + #[← mkAppM ``RealFormula.Prenex.toProp #[source.formula, source.valuation], original] + Hex.RealFormula.Reify.accountProof source.proof + let equivalence ← Hex.RCF.checkProof `sourceAcceptanceEquivalence sourceType source.proof + let schema := (← whnf source.formula).consumeMData + unless schema.isAppOfArity ``RealFormula.Prenex.quant 3 do + throwError "source acceptance requires exactly one real quantifier" + let args := schema.getAppArgs + let quantifier := args[args.size-2]! + let matrix := (← whnf args.back!).consumeMData + unless matrix.isAppOfArity ``RealFormula.Prenex.matrix 2 do + throwError "source acceptance requires a shared quantifier-free matrix" + let formula := matrix.getAppArgs.back! + let (values, coefficientEq) ← sourceFunction prepared.coefficients.toArray + source.coefficients source.valuation + let realZero : Q(ℝ) := q(0) + let realDivisors ← FieldLiteral.finiteExpr (mkConst ``Real) source.divisors realZero + let (divisors, divisorEq) ← sourceFunction prepared.divisors.toArray source.divisors realDivisors + let registry ← Hex.RCF.checkExpr `sourceAcceptanceRegistry registry + let proof ← mkAppM ``AlgebraicCells.accepts_source + #[registry, values, divisors, source.valuation, realDivisors, + formula, quantifier, coefficientEq, divisorEq, equivalence] + Hex.RealFormula.Reify.accountProof proof + let type ← inferType proof + Hex.RCF.checkProof `sourceAcceptance type proof + +/-- Connect mathematical producer acceptance at the retained kernel algebraic +expressions to the exact expected target and original divisors after checked +alias substitution. This returns an equivalence, not evidence of acceptance. +It does not authenticate runtime proposals or frozen source histories. + +Each proof is charged before checking it. The returned usage continues the +preparation's aggregate budget, including a fresh original-divisor inventory +scan. Callers must thread it into later stages with `{prepared with usage}`. +Exhaustion, failure and interruption restore the complete saved state. -/ +def Inputs.acceptanceIff (prepared : Inputs) (target registry : Expr) : + MetaM (Except Hex.RealFormula.Reify.Error (Expr × Hex.Reflect.BudgetUsage)) := do + let saved ← saveState + let depthLimit := (← readThe Core.Context).maxRecDepth + let auxName := mkPrivateName (← getEnv) (← mkFreshUserName `SourceAcceptance) + let (result, _) ← tryFinally' (withDeclNameForAuxNaming auxName <| withNewMCtxDepth <| Core.withIncRecDepth <| + withOptions (fun options => maxRecDepth.set + (debug.skipKernelTC.set (Elab.async.set options false) false) depthLimit) do + let action := acceptanceCore prepared target registry + let state : Hex.RealFormula.Reify.State := { + config := prepared.config + budget := {initial := prepared.config.ring.budget, consumed := prepared.usage} } + let accounted ← (action.run state).run + match accounted with + | .error error => return .error error + | .ok (proof, state) => return .ok (proof, state.budget.consumed)) fun result => do + match result with + | some (.ok _) => modify fun state => {state with + mctx := saved.meta.mctx, postponed := saved.meta.postponed, + zetaDeltaFVarIds := saved.meta.zetaDeltaFVarIds} + | _ => saved.restore + return result + end Hex.RCF.RealCoefficients.AlgebraicPreparation diff --git a/adapters/HexRCF/RealCoefficients/Reify.lean b/adapters/HexRCF/RealCoefficients/Reify.lean index f4e509416c..916c05e29b 100644 --- a/adapters/HexRCF/RealCoefficients/Reify.lean +++ b/adapters/HexRCF/RealCoefficients/Reify.lean @@ -418,7 +418,7 @@ termination_by values.size - i /-- Substitute only explicit checked real aliases, retaining the exact syntax of their closed values and a proof back to the original proposition. -/ -private def closeSource (source : Expr) : FrontendM (Expr × Expr) := do +private def closeSourceCore (source : Expr) : FrontendM (Expr × Expr) := do if source.hasMVar || source.hasLooseBVars then reject source "source sentence has unresolved metavariables" let mut closed := source @@ -431,9 +431,13 @@ private def closeSource (source : Expr) : FrontendM (Expr × Expr) := do proof ← mkEqTrans proof (← mkAppM ``congrArg #[abstraction, binding.proof]) closed := closed.replaceFVar symbol binding.value unless isClosed closed do reject source "source sentence has free parameters" - checkWithKernel proof return (closed, proof) +private def closeSource (source : Expr) : FrontendM (Expr × Expr) := do + let result ← closeSourceCore source + checkWithKernel result.2 + return result + private def prepareCore (registered : Array Expr) (original : Expr) (config : Hex.RealFormula.Reify.Config) : FrontendM Source := do let cap := (← get).budget.remaining.sourceNodes Hex.RealFormula.Reify.charge .sourceNodes (Hex.Reflect.sourceNodeCount original (cap + 1)) @@ -552,27 +556,42 @@ private def prepareCore (registered : Array Expr) (original : Expr) (config : He set state return result +/-- Recover original divisor syntax in the caller's continued reflection budget. +Charge both source views and the alias proof before checking it. This action +does not discharge guards or construct a formula; callers provide transactional +state restoration around the complete proof operation. -/ +def guardSources (original : Expr) : Hex.RealFormula.Reify.ReifyM (Array Expr) := do + Core.checkSystem "rcf original divisor inventory" + let cap := (← get).budget.remaining.sourceNodes + Hex.RealFormula.Reify.charge .sourceNodes (Hex.Reflect.sourceNodeCount original (cap + 1)) + checkDomains original + let (source, proof) ← closeSourceCore original + Hex.RealFormula.Reify.accountProof proof + let _ ← liftM (withoutModifyingEnv <| Hex.RCF.checkProof `Hex.RCF.RealCoefficients.Reify.guards + (← mkEq original source) proof) + Core.checkInterrupted + let cap := (← get).budget.remaining.sourceNodes + Hex.RealFormula.Reify.charge .sourceNodes (Hex.Reflect.sourceNodeCount source (cap + 1)) + let divisors ← preflight #[] source + let divisors ← divisors.mapM instantiateMVars + if divisors.any Expr.hasMVar then + throwThe Hex.RealFormula.Reify.Error (.internal "original divisors contain unresolved metavariables") + return divisors + /-- Recover all original divisor obligations after checked alias substitution. This reuses source preflight without coefficient lowering, schema construction -or root/sign production. Successful results preserve caller metavariables. -/ +or root/sign production. Both source views and the checked alias proof consume +`config.ring.budget`; exhaustion returns a structured budget error. +Successful results preserve caller metavariables. -/ def guards (original : Expr) (config : Hex.RealFormula.Reify.Config := {}) : MetaM (Except Hex.RealFormula.Reify.Error (Array Expr)) := do let saved ← saveState let (result, _) ← tryFinally' (withNewMCtxDepth do - let action : FrontendM (Array Expr) := do - checkDomains original - let (source, proof) ← closeSource original - let _ ← liftM (withoutModifyingEnv <| Hex.RCF.checkProof `Hex.RCF.RealCoefficients.Reify.guards - (← mkEq original source) proof) - preflight #[] source + let action := guardSources original let outcome ← (action.run {config, budget := .ofBudget config.ring.budget}).run match outcome with | .error error => return .error error - | .ok (divisors, _) => - let divisors ← divisors.mapM instantiateMVars - if divisors.any Expr.hasMVar then - return .error (.internal "original divisors contain unresolved metavariables") - return .ok divisors) + | .ok (divisors, _) => return .ok divisors) (fun result => do match result with | some (.ok _) => modify fun state => {state with diff --git a/conformance/HexRCF/AlgebraicPreparationCases.lean b/conformance/HexRCF/AlgebraicPreparationCases.lean index 4e8e4e3be5..8835f2e01f 100644 --- a/conformance/HexRCF/AlgebraicPreparationCases.lean +++ b/conformance/HexRCF/AlgebraicPreparationCases.lean @@ -227,6 +227,215 @@ run_meta do mixed.formula ((GatherCells.guards shared (AlgebraicCells.guards sources mixed.guards)).map input.value) packet.radical mixed.quantifier packet.rootGraph packet.cells).toOption == some expected do throwError "mixed coefficient/divisor layout changed the quantified verdict" + let registry : Q(RealClosure.BaseContext.Registry) := q(fun _ => none) + let replacementGuard ← checked q(∀ _ : ℝ, 0 / (1 : ℝ) = 0) + unless replacementGuard.source.divisors.size == 1 do + throwError "replacement guard control has the wrong inventory" + for (label, target, guardCount) in #[ + (`rationalAcceptance, q(∀ x : ℝ, x^2 ≥ 0), 0), + (`algebraicAcceptance, q(∀ x : ℝ, x^2 + Real.sqrt 2 > 0), 0), + (`falseAcceptance, q(∀ x : ℝ, x^2 + Real.sqrt 2 < 0), 0), + (`divisorAcceptance, q(∀ x : ℝ, x / (Real.sqrt 2 + 1) = x * (Real.sqrt 2 + 1)⁻¹), 2), + (`zeroGuardAcceptance, q(∀ _ : ℝ, 0 / (Real.sqrt 2 * Real.sqrt 2 - 2) = 0), 1), + (`emptyDomainAcceptance, q(∀ x ∈ Set.Ioc (2 : ℝ) 1, + x + 0 / (Real.sqrt 2 * Real.sqrt 2 - 2) = x), 1), + (`validEmptyDomainAcceptance, q(∀ x ∈ Set.Ioc (2 : ℝ) 1, x < 0), 0)] do + let prepared ← checked target + unless prepared.source.divisors.size == guardCount do + throwError "source acceptance guard count changed for {label}: {prepared.source.divisors.size}, expected {guardCount}" + let before := (← getMCtx).decls.toList.length + let .ok (proof, usage) ← prepared.acceptanceIff target registry + | throwError "source acceptance equivalence failed: {label}" + unless (← getMCtx).decls.toList.length == before do + throwError "successful source acceptance changed caller metavariables" + let type ← inferType proof + unless type.isAppOfArity ``Iff 2 do throwError "source acceptance returned no equivalence" + let domain := mkApp (mkConst ``Fin) (mkNatLit prepared.source.divisors.size) + let divisors ← FieldLiteral.finiteExpr (mkConst ``Real) prepared.source.divisors q((0 : ℝ)) + let guards ← withLocalDeclD `i domain fun i => do + mkForallFVars #[i] (← mkAppM ``Ne #[mkApp divisors i, q((0 : ℝ))]) + let expected ← mkAppM ``And #[guards, target] + let rhs ← instantiateMVars type.getAppArgs[1]! + unless rhs.isAppOfArity ``And 2 && rhs.getAppArgs[1]! == target do + throwError "source acceptance changed the exact original goal: {label}" + -- Numeral instances and binder names can differ in the guard function. + -- Only that function is compared reducibly; the original target is exact. + unless ← withTransparency .reducible (isDefEq rhs expected) do + throwError "source acceptance changed its original divisor conjunction: {label}" + let lhs := type.getAppArgs[0]! + unless lhs.isAppOfArity ``AlgebraicCells.accepts 8 do + throwError "source equivalence does not refer to the actual producer acceptance" + let info ← getFunInfoNArgs lhs.getAppFn lhs.getAppArgs.size + let explicit := lhs.getAppArgs.zipIdx |>.filterMap fun (arg, i) => + if info.paramInfo[i]!.binderInfo.isExplicit then some arg else none + unless explicit.size == 6 do throwError "source acceptance has an unexpected arity" + let generators := explicit[1]!.eta + let parts := generators.getAppArgs + unless generators.getAppFn.isConstOf ``Fin.addCases && parts.size >= 2 do + throwError "source acceptance lost its coefficient/divisor tuple: {← ppExpr generators}" + let zero : Q(RealAlgebraicNumber) := q(RealAlgebraicNumber.ofRat 0) + let coefficients ← FieldLiteral.finiteExpr (mkConst ``RealAlgebraicNumber) + (prepared.coefficients.toArray.map (·.expression)) zero + let originalDivisors ← FieldLiteral.finiteExpr (mkConst ``RealAlgebraicNumber) + (prepared.divisors.toArray.map (·.expression)) zero + unless parts[parts.size-2]! == coefficients && parts.back! == originalDivisors do + throwError "source acceptance did not use the exact checked algebraic expressions" + let proposals := prepared.coefficients.map fun entry => + {entry with proposal := RealAlgebraicNumber.ofRat 0} + let divisorProposals := prepared.divisors.map fun entry => + {entry with proposal := RealAlgebraicNumber.ofRat 0} + let edited := {prepared with + coefficients := proposals + divisors := divisorProposals + formula := .not prepared.formula + quantifier := .existsReal + usage := usage } + let .ok (unchangedProof, furtherUsage) ← edited.acceptanceIff target registry + | throwError "runtime-only edits changed source equivalence" + unless (← inferType unchangedProof) == type do + throwError "runtime proposals or runtime syntax entered source acceptance evidence" + unless furtherUsage.proofNodes > usage.proofNodes && usage.proofNodes > prepared.usage.proofNodes do + throwError "source acceptance did not return its continued aggregate proof usage" + unless furtherUsage.sourceNodes > usage.sourceNodes && usage.sourceNodes > prepared.usage.sourceNodes do + throwError "source acceptance did not charge its continued original-source scans" + let name := `Hex.RCF.AlgebraicPreparationConformance ++ label + addDecl (.thmDecl {name,levelParams := [],type,value := proof}) + let budget := {prepared.config.ring.budget with proofNodes := usage.proofNodes - 1} + let ring := {prepared.config.ring with budget} + let config := {prepared.config with ring} + let limited := {prepared with config} + let beforeNames := (← (← getEnv).getLocalConstantInfos).map (·.name) + unchanged do + let .error (.budget exhausted) ← limited.acceptanceIff target registry + | throwError "source acceptance reset its aggregate proof budget" + unless exhausted.dimension == .proofNodes do throwError "wrong source acceptance exhaustion" + unless (← (← getEnv).getLocalConstantInfos).map (·.name) == beforeNames do + throwError "exhausted source acceptance leaked auxiliary declarations" + let budget := {budget with proofNodes := usage.proofNodes} + let ring := {ring with budget} + let config := {config with ring} + let exactLimit := {prepared with config} + let .ok (_, exactUsage) ← exactLimit.acceptanceIff target registry + | throwError "source acceptance failed at its exact aggregate proof limit" + unless exactUsage.proofNodes == usage.proofNodes do + throwError "source acceptance changed its exact charged proof count" + if label == `divisorAcceptance then + -- This source has no aliases, so both charged source views are identical. + let count := Hex.Reflect.sourceNodeCount target (prepared.config.ring.budget.sourceNodes + 1) + unless usage.sourceNodes == prepared.usage.sourceNodes + 2 * count do + throwError "source acceptance did not charge both original source views" + let budget := {prepared.config.ring.budget with sourceNodes := usage.sourceNodes - 1} + let ring := {prepared.config.ring with budget} + let config := {prepared.config with ring} + let limited := {prepared with config} + let names := (← (← getEnv).getLocalConstantInfos).map (·.name) + unchanged do + let .error (.budget exhausted) ← limited.acceptanceIff target registry + | throwError "source acceptance reset the original-source scan budget" + unless exhausted.dimension == .sourceNodes do throwError "wrong source-scan exhaustion" + unless (← (← getEnv).getLocalConstantInfos).map (·.name) == names do + throwError "exhausted source scan leaked auxiliary declarations" + let budget := {budget with sourceNodes := usage.sourceNodes} + let ring := {ring with budget} + let config := {config with ring} + let sourceLimit := {prepared with config} + let .ok (_, exactUsage) ← sourceLimit.acceptanceIff target registry + | throwError "source acceptance failed at its exact original-source limit" + unless exactUsage.sourceNodes == usage.sourceNodes do + throwError "source acceptance changed its exact charged source count" + let beforeNames := (← (← getEnv).getLocalConstantInfos).map (·.name) + unchanged do + let failed ← tryCatchRuntimeEx + (prepared.acceptanceIff q(True) registry *> pure false) (fun _ => pure true) + unless failed do throwError "source acceptance ignored its expected original target" + for (resource, limits, expectedException) in resources do + unchanged do + let terminal ← observeTerminal (withTheReader Core.Context limits do + let _ ← prepared.acceptanceIff target registry + pure false) (fun error => do + unless expectedException error do throw error + pure true) + unless terminal do throwError "source acceptance swallowed terminal {resource}" + if label == `algebraicAcceptance then + -- Entry passes at depth zero; these must fail inside the operation. + -- Resetting the caller's context limit from options would hide failure. + for (operation, action) in [ + ("acceptance", prepared.acceptanceIff target registry *> pure ()), + ("preparation", AlgebraicPreparation.prepare target *> pure ())] do + unchanged do + let terminal ← observeTerminal (withTheReader Core.Context + (fun context => {context with maxRecDepth := 8, currRecDepth := 0}) do + action + pure false) (fun error => do + unless error.isMaxRecDepth do throw error + pure true) + unless terminal do throwError "source {operation} reset an inner recursion limit" + unless (← (← getEnv).getLocalConstantInfos).map (·.name) == beforeNames do + throwError "terminal source acceptance failure leaked auxiliary declarations" + if h : 0 < prepared.source.coefficients.size then + let i : Fin prepared.source.coefficients.size := ⟨0,h⟩ + let entry := prepared.coefficients[i] + let edited := {entry with identity := q(True.intro)} + let corrupt := {prepared with coefficients := prepared.coefficients.set i edited} + unchanged do + let failed ← tryCatchRuntimeEx (corrupt.acceptanceIff target registry *> pure false) (fun _ => pure true) + unless failed do throwError "source acceptance trusted an edited coefficient identity" + unless (← (← getEnv).getLocalConstantInfos).map (·.name) == beforeNames do + throwError "rejected source acceptance leaked auxiliary declarations" + if h : 0 < prepared.source.divisors.size then + let i : Fin prepared.source.divisors.size := ⟨0,h⟩ + let edited := {prepared.divisors[i] with identity := q(True.intro)} + let corrupt := {prepared with divisors := prepared.divisors.set i edited} + unchanged do + let failed ← tryCatchRuntimeEx (corrupt.acceptanceIff target registry *> pure false) (fun _ => pure true) + unless failed do throwError "source acceptance trusted an edited divisor identity" + let omitted := {prepared with + source := {prepared.source with divisors := #[]} + divisors := Vector.ofFn (fun i : Fin 0 => i.elim0)} + unchanged do + let failed ← tryCatchRuntimeEx (omitted.acceptanceIff target registry *> pure false) (fun _ => pure true) + unless failed do throwError "source acceptance trusted an omitted original divisor inventory" + unless (← (← getEnv).getLocalConstantInfos).map (·.name) == beforeNames do + throwError "rejected divisor acceptance leaked auxiliary declarations" + if label == `zeroGuardAcceptance then + unless prepared.source.divisors.size == replacementGuard.source.divisors.size do + throwError "guard replacement control changed its coordinate count" + let substituted := {prepared with + source := {prepared.source with divisors := replacementGuard.source.divisors} + divisors := replacementGuard.divisors} + unchanged do + let failed ← tryCatchRuntimeEx (substituted.acceptanceIff target registry *> pure false) (fun _ => pure true) + unless failed do throwError "source acceptance trusted a different valid divisor inventory" + unless (← (← getEnv).getLocalConstantInfos).map (·.name) == beforeNames do + throwError "replaced divisor acceptance leaked auxiliary declarations" + -- The matching unchanged record must still succeed after the forgeries. + -- No diagnostic-string classification is needed for the invalid records. + unchanged do + let .ok (control, _) ← prepared.acceptanceIff target registry + | throwError "source acceptance rejected the unchanged divisor control" + unless (← inferType control) == type do + throwError "source acceptance changed the unchanged divisor control" + withLocalDeclD `c q(ℝ) fun c => do + let identity ← mkEq c q(Real.sqrt 2) + withLocalDeclD `identity identity fun identity => do + let c : Q(ℝ) := c + let target : Q(Prop) := q(∀ x : ℝ, x^2 + $c > 0) + let prepared ← checked target + let .ok (proof, usage) ← prepared.acceptanceIff target registry + | throwError "source acceptance lost the checked local alias" + let cap := prepared.config.ring.budget.sourceNodes + 1 + let originalCount := Hex.Reflect.sourceNodeCount target cap + let closedCount := Hex.Reflect.sourceNodeCount (target.replaceFVar c q(Real.sqrt 2)) cap + unless originalCount != closedCount do + throwError "alias source-scan control has indistinguishable views" + unless usage.sourceNodes == prepared.usage.sourceNodes + originalCount + closedCount do + throwError "source acceptance did not charge the distinct alias-substituted view" + let type ← mkForallFVars #[c,identity] (← inferType proof) + let value ← mkLambdaFVars #[c,identity] proof + addDecl (.thmDecl { + name := `Hex.RCF.AlgebraicPreparationConformance.aliasAcceptance + levelParams := [], type, value }) + logInfo "exact original algebraic producer acceptance, false source, original zero guards, empty domains, aggregate proof/source budgets, inner recursion limits and forged guard inventories checked" addDecl (.thmDecl { name := `Hex.RCF.AlgebraicPreparationConformance.runFinished levelParams := [], type := mkConst ``True, value := mkConst ``True.intro }) diff --git a/conformance/HexRCF/AlgebraicPreparationConformance.lean b/conformance/HexRCF/AlgebraicPreparationConformance.lean index 16b10b0b2b..113c8bf481 100644 --- a/conformance/HexRCF/AlgebraicPreparationConformance.lean +++ b/conformance/HexRCF/AlgebraicPreparationConformance.lean @@ -4,6 +4,9 @@ Released under Apache 2.0 license as described in the file LICENSE. Authors: Kim Morrison -/ import HexRCF.AlgebraicPreparationCases +import HexRCF.SourceAcceptancePublic +import KernelReplay.AxiomClosure +import HexRCF.ProofEvidence open Lean Meta -- A separate importing module requires the end-of-run marker. A swallowed @@ -13,3 +16,21 @@ run_meta do | throwError "native source conformance did not finish" let _ ← Hex.RCF.checkProof `nativeSourceRunCompleted declaration.type declaration.value logInfo "native source conformance completion independently checked" + +run_meta do + let names := #[`rationalAcceptance, `algebraicAcceptance, `falseAcceptance, + `divisorAcceptance, `zeroGuardAcceptance, `emptyDomainAcceptance, `validEmptyDomainAcceptance, `aliasAcceptance].map + (`Hex.RCF.AlgebraicPreparationConformance ++ ·) + let names := names.push ``Hex.RCF.SourceAcceptanceTests.empty + for name in names do + let .thmInfo declaration ← getConstInfo name | throwError "source acceptance consumer is missing" + let _ ← Hex.RCF.checkProof name declaration.type declaration.value + let axioms ← Hex.RealClosure.Algebraic.KernelReplay.AxiomClosure.collect names + unless axioms == (#[``propext, ``Classical.choice, ``Quot.sound].qsort Name.lt) do + throwError "source acceptance has an unexpected complete axiom closure" + let dependencies ← Hex.RCF.ProofEvidence.projectDependencies names + for name in #[``Hex.RCF.RealCoefficients.AlgebraicCells.accepts_iff, + ``Hex.RCF.RealCoefficients.AlgebraicCells.build_complete, + ``Hex.RCF.RealCoefficients.AlgebraicCells.build_domains] do + unless dependencies.contains name do throwError "source acceptance omitted an actual owner law" + logInfo "fresh source acceptance bodies retain original domains and actual complete production laws with the standard three axioms" diff --git a/conformance/HexRCF/SourceAcceptancePublic.lean b/conformance/HexRCF/SourceAcceptancePublic.lean new file mode 100644 index 0000000000..70b562109d --- /dev/null +++ b/conformance/HexRCF/SourceAcceptancePublic.lean @@ -0,0 +1,29 @@ +/- +Copyright (c) 2026 Lean FRO, LLC. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Kim Morrison +-/ +module +public import HexRCF.RealCoefficients.AlgebraicCells +public section +open Hex Hex.RealClosure Hex.RCF.RealCoefficients +namespace Hex.RCF.SourceAcceptanceTests + +/-- Construct acceptance from an actual produced packet through ordinary +public imports, rather than assuming the existential predicate. -/ +theorem empty (registry : BaseContext.Registry) : + AlgebraicCells.accepts registry (fun i : Fin 0 => i.elim0) + (fun i : Fin 0 => i.elim0) [] (.tt : RealFormula.QF 1) .forallReal := by + unfold AlgebraicCells.accepts + obtain ⟨sources, shared, packet, produced, accepted⟩ := + AlgebraicCells.build_complete registry (fun i : Fin 0 => i.elim0) + (fun i : Fin 0 => i.elim0) [] (.tt : RealFormula.QF 1) (by simp) + obtain ⟨verdict, checked, meaning⟩ := accepted .forallReal + have truth : verdict = true := meaning.mpr (by intro x; trivial) + exact ⟨⟨sources, shared, packet⟩, produced, by simpa only [truth] using checked⟩ + +/-- info: 'Hex.RCF.SourceAcceptanceTests.empty' depends on axioms: [propext, Classical.choice, Quot.sound] -/ +#guard_msgs in +#print axioms empty + +end Hex.RCF.SourceAcceptanceTests diff --git a/lakefile.lean b/lakefile.lean index bd3820df1b..f930262f8f 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -1336,7 +1336,7 @@ lean_lib HexConformance where srcDir := "conformance" globs := Array.filter (fun g => !isParkedGlob g) <| #[ `HexPosDef.Conformance, `HexArith.Conformance, `HexArith.CrossCheck, `HexBerlekamp.Conformance, `HexBerlekampZassenhaus.Conformance, `HexBerlekampZassenhaus.CrossCheck, `HexBerlekampZassenhausTheory.Conformance, `HexConway.Conformance, `HexGF2.Conformance, `HexGF2.CrossCheck, `HexGF2.FastCheck, `HexGFq.Conformance, `HexGFq.CrossCheck, `HexGFqField.Conformance, `HexGFqRing.Conformance, `HexGramSchmidt.Conformance, `HexGraphIso.Conformance, `HexHensel.Conformance, `HexHensel.CrossCheck, `HexInterval.Conformance, `HexIntervalTheory.IntervalConformance, `HexInterval.CenterConformance, `HexInterval.ScaleConformance, `HexInterval.PropagatorConformance, `HexInterval.ScopeConformance, `HexInterval.StructuralMatcherConformance, `HexInterval.MatcherSchedulerConformance, `HexInterval.NestedBranchConformance, `HexInterval.StructureViewConformance, `HexInterval.PolicyConformance, `HexInterval.PolicyFrontierConformance, `HexInterval.PolicyDriverConformance, `HexInterval.PackageRegistryConformance, `HexInterval.DyadicIntervalConformance, `HexInterval.DyadicRulesConformance, `HexInterval.PayloadArenaConformance, `HexInterval.PayloadSessionConformance, `HexInterval.PolicySessionConformance, `HexInterval.PolicyFunctionConformance, `HexInterval.SemanticReplayConformance, `HexInterval.ChronologicalReplayConformance, `HexInterval.GenericInstanceReconstructionConformance, `HexInterval.ProofEmitterConformance, `HexInterval.TraceReplayConformance, `HexInterval.SinTenIntervalConformance, `HexIntervalTheory.DyadicIntervalConformance, `HexIntervalTheory.CenteredConformance, `HexIntervalTheory.SineSignConformance, `HexIntervalTheory.SineProofConformance, `HexIntervalTheory.SineTacticConformance, `HexIntervalTheory.ProofRegistryConformance, `HexIntervalTheory.ExpSignConformance, `HexIntervalTheory.ReluConformance, `HexIntervalTheory.RefuteConformance, `HexIntervalTheory.PntLogTableConformance, `HexIntervalTheory.PntNestedLogConformance, `HexIntervalTheory.PntExpTailConformance, `HexIntervalTheory.PntTable12Conformance, `HexIntervalTheory.PntTable12OrdinaryConformance, `HexIntervalAlgebraic.PolynomialDispatchConformance, `HexIntervalTheory.PntTable12LogConformance, `HexIntervalTheory.PntFks2ShardConformance, `HexIntervalTheory.LogTablePrecisionConformance, `HexIntervalTheory.IntegralCanaryConformance, `HexIntervalTheory.PntBKLNWExpConformance, `HexIntervalTheory.PntBKLNWPowConformance, `HexIntervalTheory.PntPrimeLogSmallConformance, `HexIntervalTheory.PntDusartExpConformance, `HexIntervalTheory.SinTenConformance, `HexIntervalTheory.SinTenIntervalConformance, `HexIntervalTheory.CosBillionConformance, `HexHermite.Conformance, `HexLLL.Conformance, `HexMatrix.Conformance, `HexRealFormula.Conformance, `HexRealFormulaTheory.Conformance, `HexRealFormulaTheory.Arithmetic, `HexMvPolyFixtures, `HexMvPoly.Conformance, `HexMvPolyTheory.Conformance, `HexSparsePolyFixtures, `HexSparsePoly.Conformance, `HexRowReduce.Conformance, `HexDeterminant.Conformance, `HexDeterminantalIdealFixtures, `HexDeterminantalIdeal.Conformance, `HexDeterminant.Carriers, `HexBareiss.Fixtures, `HexBareiss.Conformance, `HexModularMatrix.Fixtures, `HexModularMatrix.Conformance, `HexDet.Conformance, `HexDet.Carriers, `HexCharPoly.Fixtures, `HexCharPoly.Carriers, `HexCharPoly.Conformance, `HexModArith.Conformance, `HexModArith.FastCheck, `HexModular.Conformance, `HexPolyZGcd.Conformance, `HexMvGcd.Conformance, `HexNumberField.Conformance, `HexNumberFieldTower.Conformance, `HexPoly.Conformance, `HexPrimality.CertificateProducer, `HexPrimality.ConstructionConformance, `HexPrimality.ConstructionRetry, `HexPrimality.ConstructionRegistration, `HexPrimality.Curve25519Replay, `HexPrimality.Curve448Replay, `HexPrimality.SqufofConformance, `HexPrimality.Conformance, `HexECPP.NativeConformance, `HexECPP.Conformance, `HexECPP.Fixture17, `HexECPP.PolicyProbe, `HexECPP.Fixture65, `HexECPP.Fixture256, `HexECPP.Fixture512, `HexECPP.PariFixtures, `HexECPP.ImportConformance, `HexECPPTheory.NativeConformance, `HexECPPTheory.NativeFixtures, `HexECPPTheory.Conformance, `HexECPPTheory.CompactFixtures, `HexECPPTheory.CompactReject, `HexECPPTheory.PariProcess, `HexECPPTheory.Reject, `HexECPPTheory.HasseAudit, `HexECPPTheory.SoundnessAudit, `HexPrimalityTheory.Conformance, `HexPrimalityTheoryConformance.OptIn, `HexPolyFp.Conformance, `HexPolyZ.Conformance, `HexRCF.Conformance, `HexRealRoots.Conformance, `HexRealRootsTheory.Conformance, `HexResultant.Conformance, `HexRoots.Conformance].map Glob.one ++ - #[`HexRCF.SourceIdentityKernel, `HexRCF.SourceIdentityCases, `HexRCF.MaximalCoefficientsKernel, `HexRCF.MaximalCoefficientsConformance, `HexRCF.MaximalCoefficients, `HexRCF.CellReplay.AssembledKernel, `HexRCF.CellReplay.Assembled, `HexRCF.CellReplay.OperationsPublic, `HexRCF.CellReplay.OperationsKernel, `HexRCF.CellReplay.Operations, `HexRCF.CellReplay.Algebraic.Emit, `HexRCF.CellReplay.Algebraic.MutationData0, `HexRCF.CellReplay.Algebraic.Mutations, `HexRCF.CellReplay.Algebraic.Refusals, `HexRCF.CellReplay.Algebraic.Guards, `HexRCF.CellReplay.Algebraic.Meaning, `HexRCF.CellReplay.Algebraic.Boolean, `HexRCF.CellReplay.Algebraic.BooleanSources, `HexRCF.CellReplay.Algebraic.BooleanBinding, `HexRCF.CellReplay.Algebraic.BooleanQuoted, `HexRCF.CellBuildConformance, `HexRCF.CellDiscoverLinear, `HexRCF.CellDiscoverAlgebraic, `HexRCF.CellDiscoverCases, `HexRCF.CellDiscoverProofs, `HexRCF.CellRequestedConformance, `HexRCF.CellDecisionProofs, `HexRCF.CellCodecProofs, `HexRCF.CellExecutionProofs, `HexRCF.NumberFieldCellsConformance, `HexRCF.GatherCellsConformance, `HexRCF.RealModelConformance, `HexRCF.AlgebraicPreparationCases, `HexRCF.AlgebraicPreparationConformance, `HexRCF.AlgebraicCellsConformance, `HexRCF.CellReplay.Algebraic.Canonical, `HexRCF.CellReplay.Algebraic.Check, `HexRCF.CellReplay.Algebraic.Convert, `HexRCF.CellReplay.Algebraic.Inputs, `HexRCF.CellReplay.Algebraic.LiteralData0, `HexRCF.CellReplay.Algebraic.LiteralData1, `HexRCF.CellReplay.Algebraic.Literals, `HexRCF.CellReplay.Algebraic.Quote, `HexRCF.CellReplay.Algebraic.Quoted, `HexRCF.CellReplay.Algebraic.CompleteQuote, `HexRCF.CellReplay.Algebraic.CompleteQuoted, `HexRCF.CellReplay.Algebraic.Radical, `HexRCF.CellReplay.Algebraic.Read, `HexRCF.CellReplay.Algebraic.Records, `HexRCF.CellReplay.Algebraic.ScalarData0, `HexRCF.CellReplay.Algebraic.ScalarData1, `HexRCF.CellReplay.Algebraic.Scalars, `HexRCF.CellReplay.Algebraic.Schema, `HexRCF.CellReplay.Algebraic.Sections, `HexPolyDet.Conformance, `HexRank.Conformance, `HexGenericRank.Conformance, `HexGenericRank.Fixtures, `HexRowReduce.FieldFixtures, `HexRealFormulaTheory.ReifierConformance, `HexRCF.RealFormulaConformance, `HexRCF.RealCoefficientsConformance, `HexRCF.AlgebraicProgress, `HexRCF.IsolationProgress, `HexRCF.RadicalProgress, `HexRCF.ProductionProgress, `HexRCF.FieldRootsConformance, `HexRCF.CertificationInputs, `HexRCF.RationalSources, `HexRCF.ProofEvidence, `HexRCF.CheckedConversions, `HexRCF.ReplayModes, `HexRCF.CarrierModes, `HexRCF.SignIndex, `HexRCF.PreparedCoefficients, `HexRCF.FiniteReplay, `HexRCF.FiniteSignsConformance, `HexRCF.CellReplay.OutsideLiterals, `HexRCF.CellReplay.Zero, `HexRCF.CellReplay.ZeroLiterals, `HexRCF.CellReplay.Valuation, `HexRCF.CellReplay.ModuleCheck, `HexRCF.CellReplay.Schema, `HexRCF.CellReplay.Check, `HexRCF.CellReplay.Ordinary, `HexRCF.CellReplay.Quote, `HexRCF.CellReplay.Controls, `HexRCF.CellReplay.Quoted, `HexRCF.CellReplay.Refusals, `HexRCF.CellReplay.Emit, `HexRCF.CellReplay.LiteralData0, `HexRCF.CellReplay.Literals, `HexRCF.CellReplay.MutationData0, `HexRCF.CellReplay.Mutations, `HexRCF.FiniteMatrix.Binding, `HexRCF.FiniteMatrix.Guards.Binding, `HexRCF.FiniteMatrix.Guards.Quotient.Binding, `HexRCF.FiniteMatrix.Guards.Quotient.Controls, `HexRCF.FiniteMatrix.Guards.Quotient.Emit, `HexRCF.FiniteMatrix.Guards.Quotient.Literals, `HexRCF.FiniteMatrix.Guards.Quotient.Ordinary, `HexRCF.FiniteMatrix.Guards.Quotient.Quote, `HexRCF.FiniteMatrix.Guards.Quotient.Reader, `HexRCF.FiniteMatrix.Guards.Quotient.Records, `HexRCF.FiniteMatrix.Guards.Quotient.Source, `HexRCF.FiniteMatrix.Guards.Controls, `HexRCF.FiniteMatrix.Guards.Data, `HexRCF.FiniteMatrix.Guards.Domains, `HexRCF.FiniteMatrix.Guards.Emit, `HexRCF.FiniteMatrix.Guards.LiteralData0, `HexRCF.FiniteMatrix.Guards.Literals, `HexRCF.FiniteMatrix.Guards.Meaning, `HexRCF.FiniteMatrix.Guards.MutationData0, `HexRCF.FiniteMatrix.Guards.Mutations, `HexRCF.FiniteMatrix.Guards.Ordinary, `HexRCF.FiniteMatrix.Guards.Quote, `HexRCF.FiniteMatrix.Guards.Read, `HexRCF.FiniteMatrix.Guards.Records, `HexRCF.FiniteMatrix.Guards.Refusals, `HexRCF.FiniteMatrix.Guards.Schema, `HexRCF.FiniteMatrix.Data, `HexRCF.FiniteMatrix.Emit, `HexRCF.FiniteMatrix.Inputs, `HexRCF.FiniteMatrix.KernelControls, `HexRCF.FiniteMatrix.LiteralData0, `HexRCF.FiniteMatrix.LiteralData1, `HexRCF.FiniteMatrix.LiteralData2, `HexRCF.FiniteMatrix.LiteralData3, `HexRCF.FiniteMatrix.LiteralData4, `HexRCF.FiniteMatrix.LiteralData5, `HexRCF.FiniteMatrix.Literals, `HexRCF.FiniteMatrix.ModuleCheck, `HexRCF.FiniteMatrix.Ordinary, `HexRCF.FiniteMatrix.Packings, `HexRCF.FiniteMatrix.Quote, `HexRCF.FiniteMatrix.Controls, `HexRCF.FiniteMatrix.Refusals, `HexRCF.FiniteMatrix.Read, `HexRCF.FiniteMatrix.Restore, `HexRCF.FiniteMatrix.Schema, `HexRCF.FiniteMatrix.Selected, `HexRCF.FiniteMatrix.Semantics, `HexRCF.FiniteMatrix.Signs, `HexRCF.TowerSamples, `HexRCF.Samples, `HexRCF.RealizationData, `HexRCF.Realization, `HexRCF.NumberField, `HexRCF.Gather, `HexRCF.GatherCatalog, `HexRCF.RegisteredGatherConformance, `HexRCF.GeneratorWindowInputs, `HexRCF.GeneratorWindow, `HexRCF.CertificationProofs, `HexRCF.SuppliedIrreducible, `HexRCF.SuppliedIrreducibleProofs, `HexRCF.SuppliedBudget, `HexRCF.NativeFormulaConformance, `HexRCF.NativeSpecializeConformance, `HexRCF.NativeSamplesConformance, `HexRCF.NativeSampleModelConformance, `HexRCF.NativeSampleModelLiterals, `HexRCF.NativeSourcesConformance, `HexRCF.NativeSelectionLiterals, `HexRCF.NativeSelectionConformance, `HexRCF.NativeSelectionOrdinaryConformance, `HexRCF.NativeSelectionOrderedConformance, `HexRCF.SectionReplayConformance, `HexRCF.SectionProduceConformance, `HexRCF.SectionOrdinaryConformance, `HexRCF.PointReplayConformance, `HexRCF.PointProduceConformance, `HexRCF.PointOrdinaryConformance, `HexRCF.RootReplayLiterals, `HexRCF.RootReplayConformance, `HexRCF.RootReplayOrdinaryConformance, `HexRCF.NestedRootLiterals, `HexRCF.NestedRootProduceConformance, `HexRCF.NestedRootOrdinaryConformance, `HexRCF.RootTransportData, `HexRCF.RootTransportLiterals, `HexRCF.RootTransportConformance, `HexRCF.RootTransportOrdinaryConformance, `HexRCF.NestedTransport.Frame, `HexRCF.NestedTransport.Context, `HexRCF.NestedTransport.Map, `HexRCF.NestedTransport.Conversion, `HexRCF.NestedTransport.Fields, `HexRCF.NestedTransport.Restore, `HexRCF.NestedTransport.Predecessor, `HexRCF.NestedTransport.Facts, `HexRCF.NestedTransport.Constants, `HexRCF.NestedTransport.Operations, `HexRCF.NestedTransport.RootRead, `HexRCF.NestedTransport.Read, `HexRCF.NestedTransport.Model, `HexRCF.NestedTransport.Source, `HexRCF.NestedTransport.Ordinary, `HexRCF.NestedTransport.Controls, `HexRCF.NestedTransport.Literals, `HexRCF.NestedTransport.EndpointLiterals, `HexRCF.NestedTransport.SignLiterals, `HexRCF.NestedTransport.SignData, `HexRCF.TotalAlgebraicProofs, `HexRCF.AlgebraicDivision, `HexRCF.NormalizedCoefficients, `HexRCF.NormalizedInputs, `HexRCF.RegisteredConstants, `HexRCF.NamedConstants, `HexRCF.MixedConstants, `HexRCF.CoarseConstants, `HexRCF.RealCoefficientTactic, `HexRCF.RealCoefficientCommonField, `HexRCF.CommonFieldPresentation, `HexRCF.RootAliasesConformance, `HexRCF.RationalRoots, `HexRCF.AlgebraicRoots, `HexRCF.FormulaConformance, `HexRCF.LiteralSignConformance, `HexRCF.FieldSpecializeConformance, `HexRCF.SignDetFieldProofs, `HexRCF.AdmissionConformance, `HexRCF.IsolationConformance].map Glob.one + #[`HexRCF.SourceIdentityKernel, `HexRCF.SourceIdentityCases, `HexRCF.MaximalCoefficientsKernel, `HexRCF.MaximalCoefficientsConformance, `HexRCF.MaximalCoefficients, `HexRCF.CellReplay.AssembledKernel, `HexRCF.CellReplay.Assembled, `HexRCF.CellReplay.OperationsPublic, `HexRCF.CellReplay.OperationsKernel, `HexRCF.CellReplay.Operations, `HexRCF.CellReplay.Algebraic.Emit, `HexRCF.CellReplay.Algebraic.MutationData0, `HexRCF.CellReplay.Algebraic.Mutations, `HexRCF.CellReplay.Algebraic.Refusals, `HexRCF.CellReplay.Algebraic.Guards, `HexRCF.CellReplay.Algebraic.Meaning, `HexRCF.CellReplay.Algebraic.Boolean, `HexRCF.CellReplay.Algebraic.BooleanSources, `HexRCF.CellReplay.Algebraic.BooleanBinding, `HexRCF.CellReplay.Algebraic.BooleanQuoted, `HexRCF.CellBuildConformance, `HexRCF.CellDiscoverLinear, `HexRCF.CellDiscoverAlgebraic, `HexRCF.CellDiscoverCases, `HexRCF.CellDiscoverProofs, `HexRCF.CellRequestedConformance, `HexRCF.CellDecisionProofs, `HexRCF.CellCodecProofs, `HexRCF.CellExecutionProofs, `HexRCF.NumberFieldCellsConformance, `HexRCF.GatherCellsConformance, `HexRCF.RealModelConformance, `HexRCF.AlgebraicPreparationCases, `HexRCF.AlgebraicPreparationConformance, `HexRCF.SourceAcceptancePublic, `HexRCF.AlgebraicCellsConformance, `HexRCF.CellReplay.Algebraic.Canonical, `HexRCF.CellReplay.Algebraic.Check, `HexRCF.CellReplay.Algebraic.Convert, `HexRCF.CellReplay.Algebraic.Inputs, `HexRCF.CellReplay.Algebraic.LiteralData0, `HexRCF.CellReplay.Algebraic.LiteralData1, `HexRCF.CellReplay.Algebraic.Literals, `HexRCF.CellReplay.Algebraic.Quote, `HexRCF.CellReplay.Algebraic.Quoted, `HexRCF.CellReplay.Algebraic.CompleteQuote, `HexRCF.CellReplay.Algebraic.CompleteQuoted, `HexRCF.CellReplay.Algebraic.Radical, `HexRCF.CellReplay.Algebraic.Read, `HexRCF.CellReplay.Algebraic.Records, `HexRCF.CellReplay.Algebraic.ScalarData0, `HexRCF.CellReplay.Algebraic.ScalarData1, `HexRCF.CellReplay.Algebraic.Scalars, `HexRCF.CellReplay.Algebraic.Schema, `HexRCF.CellReplay.Algebraic.Sections, `HexPolyDet.Conformance, `HexRank.Conformance, `HexGenericRank.Conformance, `HexGenericRank.Fixtures, `HexRowReduce.FieldFixtures, `HexRealFormulaTheory.ReifierConformance, `HexRCF.RealFormulaConformance, `HexRCF.RealCoefficientsConformance, `HexRCF.AlgebraicProgress, `HexRCF.IsolationProgress, `HexRCF.RadicalProgress, `HexRCF.ProductionProgress, `HexRCF.FieldRootsConformance, `HexRCF.CertificationInputs, `HexRCF.RationalSources, `HexRCF.ProofEvidence, `HexRCF.CheckedConversions, `HexRCF.ReplayModes, `HexRCF.CarrierModes, `HexRCF.SignIndex, `HexRCF.PreparedCoefficients, `HexRCF.FiniteReplay, `HexRCF.FiniteSignsConformance, `HexRCF.CellReplay.OutsideLiterals, `HexRCF.CellReplay.Zero, `HexRCF.CellReplay.ZeroLiterals, `HexRCF.CellReplay.Valuation, `HexRCF.CellReplay.ModuleCheck, `HexRCF.CellReplay.Schema, `HexRCF.CellReplay.Check, `HexRCF.CellReplay.Ordinary, `HexRCF.CellReplay.Quote, `HexRCF.CellReplay.Controls, `HexRCF.CellReplay.Quoted, `HexRCF.CellReplay.Refusals, `HexRCF.CellReplay.Emit, `HexRCF.CellReplay.LiteralData0, `HexRCF.CellReplay.Literals, `HexRCF.CellReplay.MutationData0, `HexRCF.CellReplay.Mutations, `HexRCF.FiniteMatrix.Binding, `HexRCF.FiniteMatrix.Guards.Binding, `HexRCF.FiniteMatrix.Guards.Quotient.Binding, `HexRCF.FiniteMatrix.Guards.Quotient.Controls, `HexRCF.FiniteMatrix.Guards.Quotient.Emit, `HexRCF.FiniteMatrix.Guards.Quotient.Literals, `HexRCF.FiniteMatrix.Guards.Quotient.Ordinary, `HexRCF.FiniteMatrix.Guards.Quotient.Quote, `HexRCF.FiniteMatrix.Guards.Quotient.Reader, `HexRCF.FiniteMatrix.Guards.Quotient.Records, `HexRCF.FiniteMatrix.Guards.Quotient.Source, `HexRCF.FiniteMatrix.Guards.Controls, `HexRCF.FiniteMatrix.Guards.Data, `HexRCF.FiniteMatrix.Guards.Domains, `HexRCF.FiniteMatrix.Guards.Emit, `HexRCF.FiniteMatrix.Guards.LiteralData0, `HexRCF.FiniteMatrix.Guards.Literals, `HexRCF.FiniteMatrix.Guards.Meaning, `HexRCF.FiniteMatrix.Guards.MutationData0, `HexRCF.FiniteMatrix.Guards.Mutations, `HexRCF.FiniteMatrix.Guards.Ordinary, `HexRCF.FiniteMatrix.Guards.Quote, `HexRCF.FiniteMatrix.Guards.Read, `HexRCF.FiniteMatrix.Guards.Records, `HexRCF.FiniteMatrix.Guards.Refusals, `HexRCF.FiniteMatrix.Guards.Schema, `HexRCF.FiniteMatrix.Data, `HexRCF.FiniteMatrix.Emit, `HexRCF.FiniteMatrix.Inputs, `HexRCF.FiniteMatrix.KernelControls, `HexRCF.FiniteMatrix.LiteralData0, `HexRCF.FiniteMatrix.LiteralData1, `HexRCF.FiniteMatrix.LiteralData2, `HexRCF.FiniteMatrix.LiteralData3, `HexRCF.FiniteMatrix.LiteralData4, `HexRCF.FiniteMatrix.LiteralData5, `HexRCF.FiniteMatrix.Literals, `HexRCF.FiniteMatrix.ModuleCheck, `HexRCF.FiniteMatrix.Ordinary, `HexRCF.FiniteMatrix.Packings, `HexRCF.FiniteMatrix.Quote, `HexRCF.FiniteMatrix.Controls, `HexRCF.FiniteMatrix.Refusals, `HexRCF.FiniteMatrix.Read, `HexRCF.FiniteMatrix.Restore, `HexRCF.FiniteMatrix.Schema, `HexRCF.FiniteMatrix.Selected, `HexRCF.FiniteMatrix.Semantics, `HexRCF.FiniteMatrix.Signs, `HexRCF.TowerSamples, `HexRCF.Samples, `HexRCF.RealizationData, `HexRCF.Realization, `HexRCF.NumberField, `HexRCF.Gather, `HexRCF.GatherCatalog, `HexRCF.RegisteredGatherConformance, `HexRCF.GeneratorWindowInputs, `HexRCF.GeneratorWindow, `HexRCF.CertificationProofs, `HexRCF.SuppliedIrreducible, `HexRCF.SuppliedIrreducibleProofs, `HexRCF.SuppliedBudget, `HexRCF.NativeFormulaConformance, `HexRCF.NativeSpecializeConformance, `HexRCF.NativeSamplesConformance, `HexRCF.NativeSampleModelConformance, `HexRCF.NativeSampleModelLiterals, `HexRCF.NativeSourcesConformance, `HexRCF.NativeSelectionLiterals, `HexRCF.NativeSelectionConformance, `HexRCF.NativeSelectionOrdinaryConformance, `HexRCF.NativeSelectionOrderedConformance, `HexRCF.SectionReplayConformance, `HexRCF.SectionProduceConformance, `HexRCF.SectionOrdinaryConformance, `HexRCF.PointReplayConformance, `HexRCF.PointProduceConformance, `HexRCF.PointOrdinaryConformance, `HexRCF.RootReplayLiterals, `HexRCF.RootReplayConformance, `HexRCF.RootReplayOrdinaryConformance, `HexRCF.NestedRootLiterals, `HexRCF.NestedRootProduceConformance, `HexRCF.NestedRootOrdinaryConformance, `HexRCF.RootTransportData, `HexRCF.RootTransportLiterals, `HexRCF.RootTransportConformance, `HexRCF.RootTransportOrdinaryConformance, `HexRCF.NestedTransport.Frame, `HexRCF.NestedTransport.Context, `HexRCF.NestedTransport.Map, `HexRCF.NestedTransport.Conversion, `HexRCF.NestedTransport.Fields, `HexRCF.NestedTransport.Restore, `HexRCF.NestedTransport.Predecessor, `HexRCF.NestedTransport.Facts, `HexRCF.NestedTransport.Constants, `HexRCF.NestedTransport.Operations, `HexRCF.NestedTransport.RootRead, `HexRCF.NestedTransport.Read, `HexRCF.NestedTransport.Model, `HexRCF.NestedTransport.Source, `HexRCF.NestedTransport.Ordinary, `HexRCF.NestedTransport.Controls, `HexRCF.NestedTransport.Literals, `HexRCF.NestedTransport.EndpointLiterals, `HexRCF.NestedTransport.SignLiterals, `HexRCF.NestedTransport.SignData, `HexRCF.TotalAlgebraicProofs, `HexRCF.AlgebraicDivision, `HexRCF.NormalizedCoefficients, `HexRCF.NormalizedInputs, `HexRCF.RegisteredConstants, `HexRCF.NamedConstants, `HexRCF.MixedConstants, `HexRCF.CoarseConstants, `HexRCF.RealCoefficientTactic, `HexRCF.RealCoefficientCommonField, `HexRCF.CommonFieldPresentation, `HexRCF.RootAliasesConformance, `HexRCF.RationalRoots, `HexRCF.AlgebraicRoots, `HexRCF.FormulaConformance, `HexRCF.LiteralSignConformance, `HexRCF.FieldSpecializeConformance, `HexRCF.SignDetFieldProofs, `HexRCF.AdmissionConformance, `HexRCF.IsolationConformance].map Glob.one ++ #[ `HexRCF.SelectedRoot.Packing, `HexRCF.SelectedRoot.PackingData, diff --git a/reports/data/hexrcf-source-acceptance/AuditImportProbe.lean.txt b/reports/data/hexrcf-source-acceptance/AuditImportProbe.lean.txt new file mode 100644 index 0000000000..20d1c11c9d --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/AuditImportProbe.lean.txt @@ -0,0 +1,2 @@ +import HexRCF.AlgebraicPreparationConformance +import HexManual diff --git a/reports/data/hexrcf-source-acceptance/SourceAcceptanceRender.lean.txt b/reports/data/hexrcf-source-acceptance/SourceAcceptanceRender.lean.txt new file mode 100644 index 0000000000..a8eba84746 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/SourceAcceptanceRender.lean.txt @@ -0,0 +1,5 @@ +import HexManual +import VersoManual +#eval Verso.Genre.Manual.manualMain (%doc HexManual) + (options := ["--output", "source-acceptance-html", + "--without-tex", "--with-html-single", "--without-html-multi"]) diff --git a/reports/data/hexrcf-source-acceptance/context.json b/reports/data/hexrcf-source-acceptance/context.json new file mode 100644 index 0000000000..3ce09298fb --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/context.json @@ -0,0 +1,778 @@ +{ + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "scope": "Original-source mathematical algebraic acceptance and budgeted proof construction. No frozen proposal identity, provider-history reconstruction, strict compiled missing-record coverage or general tactic completeness claim.", + "limits": { + "memory_max_bytes": 34359738368, + "swap_max_bytes": 0, + "lean_threads": 2, + "own_build_concurrency": 1 + }, + "sources": { + "adapters/HexRCF/RealCoefficients/AlgebraicCells.lean": "0c24e1bdb338cb6f6ef8fda7e652018db78b4dd4536edaaf4c1ab0d934d8da79", + "adapters/HexRCF/RealCoefficients/AlgebraicPreparation.lean": "b8486b2d14c85449fe5ee7e004e0828487458cc5e7e3a06f9cd78f36f155cf91", + "conformance/HexRCF/AlgebraicPreparationCases.lean": "f63238615beb41948e087bcfc399877e0254a8710ab6c68c550e5088b1fdaa98", + "conformance/HexRCF/AlgebraicPreparationConformance.lean": "043c60b76152e23a5d8a6c7c9a0122b0e88986492b62d5d8d36e77b189b00d59", + "conformance/HexRCF/SourceAcceptancePublic.lean": "8bb6befdbdea2db7e980f3346e350785f0c6bed9570d56e25e9338ff20dba857", + "HexManual/Chapters/HexRCF/AlgebraicCells.lean": "5cbbc0e0169b6632e832b1af75249f6adbee84674edafac30558f97d4d4494cb", + "lakefile.lean": "6b036d82ac71039b70cd5e8c4a6e3ed920afcd3922ddae86c450ecd05fd943c0", + "lake-manifest.json": "fd2dc4df30cd44e4d30568489d616e7bcc8a78747500139134be56f35ae746a4" + }, + "artifacts": { + "reports/data/hexrcf-source-acceptance/source-retention-budget-consumers-1.log.gz": "1645d7841d1abf8c947dfb5b327a5fcd8f9b36b69d36ccb770bc3a7d169d3edb", + "reports/data/hexrcf-source-acceptance/source-acceptance-consumer-review-10.log.gz": "4f17fe55d7c0f9a2d008fcee65beeed5b24a162a3664095e85182ef10472add3", + "reports/data/hexrcf-source-acceptance/source-acceptance-manual-2.log.gz": "4c6d46ff7302cdedcdd8e6b0cc083111dfad035e446d4d0506309089154af6ec", + "reports/data/hexrcf-source-acceptance/source-acceptance-render-3.log.gz": "9203d53e34207da2fb485af43bb45cd0a1f5e96e9babd93f798926498761021c", + "reports/data/hexrcf-source-acceptance/source-acceptance-manual-naming-1.log.gz": "71693bcf9f933af2936ba2e1b6c336e2b95430ec15d6df392050bf149447820b", + "reports/data/hexrcf-source-acceptance/source-acceptance-manual-narrow-2.log.gz": "88d2c155f7d2d1c130d2c9c19a7365ebd7b98d13ea960accedc70e6416cfa47e", + "reports/data/hexrcf-source-acceptance/source-acceptance-audit-import-1.log.gz": "d9a2a77f5b2bab8c0c5dfb9c3d666ba3cbac7a3a7296200817b0d804725d41f3", + "reports/data/hexrcf-source-acceptance/source-acceptance-browser-3.log.gz": "996bbc4658d39f76d3276bfd0f9ce5eac56e43a69da0df43eb13023ee6f475fc", + "reports/data/hexrcf-source-acceptance/source-acceptance-all-1.log.gz": "eead3b962e68f0d6ac9bece194c40fdfa8a4dce5ac1d076d1d5ff8b13f87509c", + "reports/data/hexrcf-source-acceptance/source-acceptance-render-1.log.gz": "8fdaf345ea2dba6fa32f5489494682be676ab39fdcba37f987eff3f6ef20eb40", + "reports/data/hexrcf-source-acceptance/source-acceptance-dag-4.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "reports/data/hexrcf-source-acceptance/source-acceptance-copyright-4.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "reports/data/hexrcf-source-acceptance/source-acceptance-lines-4.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "reports/data/hexrcf-source-acceptance/source-acceptance-admissions-4.log": "e43ea625a5bd76ee270c4f04f155c2ed77ed259c673904377f0e30645bca03ca", + "reports/data/hexrcf-source-acceptance/source-acceptance-all-selection-1.json": "63a0d8bac1cb24d93e2394f23166250216f8ab7c95847ce75bfb4faab6e341af", + "reports/data/hexrcf-source-acceptance/source-acceptance-browser.mjs": "ba772a7b3a4609c57ba96f0a7c58764afef1a1fd19c13a0a9b807928e09b0eb2", + "reports/data/hexrcf-source-acceptance/SourceAcceptanceRender.lean.txt": "da36bfd84c03a98ce69e2b6aab65a1ae1bcf822b2ffa90d2ce496d80ba044c3f", + "reports/data/hexrcf-source-acceptance/AuditImportProbe.lean.txt": "8b06d6f4caec334258ac12fdaaf1918cf4284aed6795b4b402c607d1fc19f878", + "reports/data/hexrcf-source-acceptance/source-acceptance-inspection.json": "1eb521f462fc8c85c03a4df5b215aa5b81d6f4f97019932a6c9f608aa3f1d267", + "reports/data/hexrcf-source-acceptance/source-acceptance-viewed.json": "26876b62de92b3dd0cd7ce45a2c19be80ad0dbc289946ab85de7a4e62de95baa", + "reports/data/hexrcf-source-acceptance/source-acceptance-overflow-inspection.json": "d6b716dda20c0c60f3e8d2e822650aa685cbaef5e32b43fc89fed739e2ade4ce", + "reports/data/hexrcf-source-acceptance/source-acceptance-desktop-equivalence.png": "ab908b0f7750cd0dd7b2c19b7524b4e25d55195392a02faa8ec7a4f0d6421d96", + "reports/data/hexrcf-source-acceptance/source-acceptance-desktop-example.png": "7b92d6b08398fc1a6cafac43d5e2685ba4fcf2c1b6ac645439f7ff54f8f20358", + "reports/data/hexrcf-source-acceptance/source-acceptance-desktop-boundary.png": "8bea2d8b09f2eafccad229a7a521694697fd434601c80a2d8b857ed569a6095e", + "reports/data/hexrcf-source-acceptance/source-acceptance-narrow-equivalence.png": "23ea2c920fd93f200e5212e1507f76c0f07025e8d1c4cde7790748b2c4ef8bc9", + "reports/data/hexrcf-source-acceptance/source-acceptance-narrow-example.png": "a96343e32d592909b6033808d3fbc0a83fff97948cd634d8040a58de6100f0f6", + "reports/data/hexrcf-source-acceptance/source-acceptance-narrow-boundary.png": "cc21ac16dbc75a1522bdeade9a1b7f0ac33df8e9d42b6d35c72a9231b190a25e", + "reports/data/hexrcf-source-acceptance/hexrcf-source-acceptance.md.txt": "42944a5e732b94f49654799d9fb9669837777d1337298856cd93e91c73d60758" + }, + "builds": [ + { + "source_commit": "466e3990451ba4c4b1494d0c6e1949e121a5ad73", + "source_tree": "9a011003725dcd51bf68bf6f1236903deed46df9", + "scope": "Final core, source cases, fresh body and axiom audit, public-import consumer and revised manual chapter.", + "log": "reports/data/hexrcf-source-acceptance/source-retention-budget-consumers-1.log.gz", + "uncompressed_sha256": "6708516cec87b81079731a28421e79bae2cf74142316b082341133c3133c5a99" + }, + { + "source_commit": "b1f0c80539a19454abae204224e16cd6cc92c65e", + "source_tree": "d80875b3e9b487fa91015c2b630c423bc51c5007", + "scope": "Expanded source cases and public-import consumer before final identity-retention correction.", + "log": "reports/data/hexrcf-source-acceptance/source-acceptance-consumer-review-10.log.gz", + "uncompressed_sha256": "fadd888b9ebcf3ab79ad97891612c528189003fc49b5c723d320c086c676ce42" + }, + { + "source_commit": "b1f0c80539a19454abae204224e16cd6cc92c65e", + "source_tree": "d80875b3e9b487fa91015c2b630c423bc51c5007", + "scope": "Manual/dependency selection before final identity-retention correction.", + "log": "reports/data/hexrcf-source-acceptance/source-acceptance-manual-2.log.gz", + "uncompressed_sha256": "ae30c1cda505d1dc9a2640d65cd9f57ef80928845b58b74910fe4f96b9f56373" + }, + { + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "scope": "Full manual single-page HTML render; dependency rebuilds included.", + "log": "reports/data/hexrcf-source-acceptance/source-acceptance-render-3.log.gz", + "uncompressed_sha256": "05a886aeb005d157de7aa03f659168b125c00cb7003c9fb9c8076886f2e8a84a" + }, + { + "source_commit": "0b9df89b9d4f12878701d4f6200595040fcf518b", + "source_tree": "80c51ba6192a9bbb29eb173714d4c491ce7638ed", + "scope": "Changed chapter and full manual umbrella after module-private auxiliary naming.", + "log": "reports/data/hexrcf-source-acceptance/source-acceptance-manual-naming-1.log.gz", + "uncompressed_sha256": "4e8b3316abead1e0f45270f0eb84a9ec58dc512e0fec515f1fb8c593b42b937d" + }, + { + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "scope": "Final narrow example and full manual umbrella.", + "log": "reports/data/hexrcf-source-acceptance/source-acceptance-manual-narrow-2.log.gz", + "uncompressed_sha256": "24d132241c50b47943ae14882a6dccb87ba472f4727841b9ed6ed1d42a4e24ed" + }, + { + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "scope": "Fresh ordinary import of source acceptance audit together with the complete manual; no collision.", + "log": "reports/data/hexrcf-source-acceptance/source-acceptance-audit-import-1.log.gz", + "uncompressed_sha256": "6bda9e86f9bc126f7525b1994254e23f521672c63c7f04c70076cec669340cd0" + }, + { + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "scope": "Six changed-content captures with local overflow checks, not a whole-book layout assertion.", + "log": "reports/data/hexrcf-source-acceptance/source-acceptance-browser-3.log.gz", + "uncompressed_sha256": "8201b01f1b816d5c1a30af215b34350f7a8b28790bf22aa573670ba89f7bdab9" + }, + { + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "scope": "All 263 RCF conformance roots, all 16 base tests, both libraries, proof probes and manual.", + "log": "reports/data/hexrcf-source-acceptance/source-acceptance-all-1.log.gz", + "uncompressed_sha256": "914df5ed3ee797bd91d703605a5c220cadd123345904b88c337b250b2d2305d0" + } + ], + "metadata": { + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "checks": { + "dag": { + "command": { + "argv": [ + "python3", + "scripts/check_dag.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "script_sha256": "760236cb56f22dd916c677070713146ebd9bd652ba988b3f9427d6a671a4ea10" + }, + "exit_status": 0, + "log": "source-acceptance-dag-4.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "copyright": { + "command": { + "argv": [ + "python3", + "scripts/check_copyright_headers.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "script_sha256": "d7ccfbb8e737c342ff24f7ec875c403a76a678a75f581a8e7dcaf0b654325c84" + }, + "exit_status": 0, + "log": "source-acceptance-copyright-4.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "lines": { + "command": { + "argv": [ + "python3", + "scripts/check_file_line_counts.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "script_sha256": "0c9109c17128a11651f7a5d3784b5b35c859b87e2f58d12c2fbcd5c7562f1229" + }, + "exit_status": 0, + "log": "source-acceptance-lines-4.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "admissions": { + "command": { + "argv": [ + "python3", + "scripts/ci/check_named_admissions.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "script_sha256": "b2a2ceb6ba6422b4a54c8c797907c61574c1f60e6659441e8c1b357ee3c471ce" + }, + "exit_status": 0, + "log": "source-acceptance-admissions-4.log", + "sha256": "e43ea625a5bd76ee270c4f04f155c2ed77ed259c673904377f0e30645bca03ca" + } + } + }, + "selection": { + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "rcf_conformance_roots": [ + "HexRCF.Conformance", + "HexRCF.SourceIdentityKernel", + "HexRCF.SourceIdentityCases", + "HexRCF.MaximalCoefficientsKernel", + "HexRCF.MaximalCoefficientsConformance", + "HexRCF.MaximalCoefficients", + "HexRCF.CellReplay.AssembledKernel", + "HexRCF.CellReplay.Assembled", + "HexRCF.CellReplay.OperationsPublic", + "HexRCF.CellReplay.OperationsKernel", + "HexRCF.CellReplay.Operations", + "HexRCF.CellReplay.Algebraic.Emit", + "HexRCF.CellReplay.Algebraic.MutationData0", + "HexRCF.CellReplay.Algebraic.Mutations", + "HexRCF.CellReplay.Algebraic.Refusals", + "HexRCF.CellReplay.Algebraic.Guards", + "HexRCF.CellReplay.Algebraic.Meaning", + "HexRCF.CellReplay.Algebraic.Boolean", + "HexRCF.CellReplay.Algebraic.BooleanSources", + "HexRCF.CellReplay.Algebraic.BooleanBinding", + "HexRCF.CellReplay.Algebraic.BooleanQuoted", + "HexRCF.CellBuildConformance", + "HexRCF.CellDiscoverLinear", + "HexRCF.CellDiscoverAlgebraic", + "HexRCF.CellDiscoverCases", + "HexRCF.CellDiscoverProofs", + "HexRCF.CellRequestedConformance", + "HexRCF.CellDecisionProofs", + "HexRCF.CellCodecProofs", + "HexRCF.CellExecutionProofs", + "HexRCF.NumberFieldCellsConformance", + "HexRCF.GatherCellsConformance", + "HexRCF.RealModelConformance", + "HexRCF.AlgebraicPreparationCases", + "HexRCF.AlgebraicPreparationConformance", + "HexRCF.SourceAcceptancePublic", + "HexRCF.AlgebraicCellsConformance", + "HexRCF.CellReplay.Algebraic.Canonical", + "HexRCF.CellReplay.Algebraic.Check", + "HexRCF.CellReplay.Algebraic.Convert", + "HexRCF.CellReplay.Algebraic.Inputs", + "HexRCF.CellReplay.Algebraic.LiteralData0", + "HexRCF.CellReplay.Algebraic.LiteralData1", + "HexRCF.CellReplay.Algebraic.Literals", + "HexRCF.CellReplay.Algebraic.Quote", + "HexRCF.CellReplay.Algebraic.Quoted", + "HexRCF.CellReplay.Algebraic.CompleteQuote", + "HexRCF.CellReplay.Algebraic.CompleteQuoted", + "HexRCF.CellReplay.Algebraic.Radical", + "HexRCF.CellReplay.Algebraic.Read", + "HexRCF.CellReplay.Algebraic.Records", + "HexRCF.CellReplay.Algebraic.ScalarData0", + "HexRCF.CellReplay.Algebraic.ScalarData1", + "HexRCF.CellReplay.Algebraic.Scalars", + "HexRCF.CellReplay.Algebraic.Schema", + "HexRCF.CellReplay.Algebraic.Sections", + "HexRCF.RealFormulaConformance", + "HexRCF.RealCoefficientsConformance", + "HexRCF.AlgebraicProgress", + "HexRCF.IsolationProgress", + "HexRCF.RadicalProgress", + "HexRCF.ProductionProgress", + "HexRCF.FieldRootsConformance", + "HexRCF.CertificationInputs", + "HexRCF.RationalSources", + "HexRCF.ProofEvidence", + "HexRCF.CheckedConversions", + "HexRCF.ReplayModes", + "HexRCF.CarrierModes", + "HexRCF.SignIndex", + "HexRCF.PreparedCoefficients", + "HexRCF.FiniteReplay", + "HexRCF.FiniteSignsConformance", + "HexRCF.CellReplay.OutsideLiterals", + "HexRCF.CellReplay.Zero", + "HexRCF.CellReplay.ZeroLiterals", + "HexRCF.CellReplay.Valuation", + "HexRCF.CellReplay.ModuleCheck", + "HexRCF.CellReplay.Schema", + "HexRCF.CellReplay.Check", + "HexRCF.CellReplay.Ordinary", + "HexRCF.CellReplay.Quote", + "HexRCF.CellReplay.Controls", + "HexRCF.CellReplay.Quoted", + "HexRCF.CellReplay.Refusals", + "HexRCF.CellReplay.Emit", + "HexRCF.CellReplay.LiteralData0", + "HexRCF.CellReplay.Literals", + "HexRCF.CellReplay.MutationData0", + "HexRCF.CellReplay.Mutations", + "HexRCF.FiniteMatrix.Binding", + "HexRCF.FiniteMatrix.Guards.Binding", + "HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "HexRCF.FiniteMatrix.Guards.Quotient.Records", + "HexRCF.FiniteMatrix.Guards.Quotient.Source", + "HexRCF.FiniteMatrix.Guards.Controls", + "HexRCF.FiniteMatrix.Guards.Data", + "HexRCF.FiniteMatrix.Guards.Domains", + "HexRCF.FiniteMatrix.Guards.Emit", + "HexRCF.FiniteMatrix.Guards.LiteralData0", + "HexRCF.FiniteMatrix.Guards.Literals", + "HexRCF.FiniteMatrix.Guards.Meaning", + "HexRCF.FiniteMatrix.Guards.MutationData0", + "HexRCF.FiniteMatrix.Guards.Mutations", + "HexRCF.FiniteMatrix.Guards.Ordinary", + "HexRCF.FiniteMatrix.Guards.Quote", + "HexRCF.FiniteMatrix.Guards.Read", + "HexRCF.FiniteMatrix.Guards.Records", + "HexRCF.FiniteMatrix.Guards.Refusals", + "HexRCF.FiniteMatrix.Guards.Schema", + "HexRCF.FiniteMatrix.Data", + "HexRCF.FiniteMatrix.Emit", + "HexRCF.FiniteMatrix.Inputs", + "HexRCF.FiniteMatrix.KernelControls", + "HexRCF.FiniteMatrix.LiteralData0", + "HexRCF.FiniteMatrix.LiteralData1", + "HexRCF.FiniteMatrix.LiteralData2", + "HexRCF.FiniteMatrix.LiteralData3", + "HexRCF.FiniteMatrix.LiteralData4", + "HexRCF.FiniteMatrix.LiteralData5", + "HexRCF.FiniteMatrix.Literals", + "HexRCF.FiniteMatrix.ModuleCheck", + "HexRCF.FiniteMatrix.Ordinary", + "HexRCF.FiniteMatrix.Packings", + "HexRCF.FiniteMatrix.Quote", + "HexRCF.FiniteMatrix.Controls", + "HexRCF.FiniteMatrix.Refusals", + "HexRCF.FiniteMatrix.Read", + "HexRCF.FiniteMatrix.Restore", + "HexRCF.FiniteMatrix.Schema", + "HexRCF.FiniteMatrix.Selected", + "HexRCF.FiniteMatrix.Semantics", + "HexRCF.FiniteMatrix.Signs", + "HexRCF.TowerSamples", + "HexRCF.Samples", + "HexRCF.RealizationData", + "HexRCF.Realization", + "HexRCF.NumberField", + "HexRCF.Gather", + "HexRCF.GatherCatalog", + "HexRCF.RegisteredGatherConformance", + "HexRCF.GeneratorWindowInputs", + "HexRCF.GeneratorWindow", + "HexRCF.CertificationProofs", + "HexRCF.SuppliedIrreducible", + "HexRCF.SuppliedIrreducibleProofs", + "HexRCF.SuppliedBudget", + "HexRCF.NativeFormulaConformance", + "HexRCF.NativeSpecializeConformance", + "HexRCF.NativeSamplesConformance", + "HexRCF.NativeSampleModelConformance", + "HexRCF.NativeSampleModelLiterals", + "HexRCF.NativeSourcesConformance", + "HexRCF.NativeSelectionLiterals", + "HexRCF.NativeSelectionConformance", + "HexRCF.NativeSelectionOrdinaryConformance", + "HexRCF.NativeSelectionOrderedConformance", + "HexRCF.SectionReplayConformance", + "HexRCF.SectionProduceConformance", + "HexRCF.SectionOrdinaryConformance", + "HexRCF.PointReplayConformance", + "HexRCF.PointProduceConformance", + "HexRCF.PointOrdinaryConformance", + "HexRCF.RootReplayLiterals", + "HexRCF.RootReplayConformance", + "HexRCF.RootReplayOrdinaryConformance", + "HexRCF.NestedRootLiterals", + "HexRCF.NestedRootProduceConformance", + "HexRCF.NestedRootOrdinaryConformance", + "HexRCF.RootTransportData", + "HexRCF.RootTransportLiterals", + "HexRCF.RootTransportConformance", + "HexRCF.RootTransportOrdinaryConformance", + "HexRCF.NestedTransport.Frame", + "HexRCF.NestedTransport.Context", + "HexRCF.NestedTransport.Map", + "HexRCF.NestedTransport.Conversion", + "HexRCF.NestedTransport.Fields", + "HexRCF.NestedTransport.Restore", + "HexRCF.NestedTransport.Predecessor", + "HexRCF.NestedTransport.Facts", + "HexRCF.NestedTransport.Constants", + "HexRCF.NestedTransport.Operations", + "HexRCF.NestedTransport.RootRead", + "HexRCF.NestedTransport.Read", + "HexRCF.NestedTransport.Model", + "HexRCF.NestedTransport.Source", + "HexRCF.NestedTransport.Ordinary", + "HexRCF.NestedTransport.Controls", + "HexRCF.NestedTransport.Literals", + "HexRCF.NestedTransport.EndpointLiterals", + "HexRCF.NestedTransport.SignLiterals", + "HexRCF.NestedTransport.SignData", + "HexRCF.TotalAlgebraicProofs", + "HexRCF.AlgebraicDivision", + "HexRCF.NormalizedCoefficients", + "HexRCF.NormalizedInputs", + "HexRCF.RegisteredConstants", + "HexRCF.NamedConstants", + "HexRCF.MixedConstants", + "HexRCF.CoarseConstants", + "HexRCF.RealCoefficientTactic", + "HexRCF.RealCoefficientCommonField", + "HexRCF.CommonFieldPresentation", + "HexRCF.RootAliasesConformance", + "HexRCF.RationalRoots", + "HexRCF.AlgebraicRoots", + "HexRCF.FormulaConformance", + "HexRCF.LiteralSignConformance", + "HexRCF.FieldSpecializeConformance", + "HexRCF.SignDetFieldProofs", + "HexRCF.AdmissionConformance", + "HexRCF.IsolationConformance", + "HexRCF.SelectedRoot.Packing", + "HexRCF.SelectedRoot.PackingData", + "HexRCF.SelectedRoot.InverseData", + "HexRCF.SelectedRoot.InverseReplay", + "HexRCF.SelectedRoot.InverseControls", + "HexRCF.InverseFixture", + "HexRCF.SelectedRoot.PackingReplay", + "HexRCF.SelectedRoot.PackingMissing", + "HexRCF.SelectedRoot.PackingAudit", + "HexRCF.SelectedRoot.CatalogData", + "HexRCF.SelectedRoot.CatalogByteData", + "HexRCF.SelectedRoot.CatalogSource", + "HexRCF.SelectedRoot.Catalog", + "HexRCF.SelectedRoot.CatalogBytes", + "HexRCF.SelectedRoot.CatalogControls", + "HexRCF.SelectedRoot.CatalogAudit", + "HexRCF.SelectedRoot.ByteAudit", + "HexRCF.SelectedRoot.ByteBounds", + "HexRCF.SelectedRoot.ByteChecks", + "HexRCF.SelectedRoot.ByteData", + "HexRCF.SelectedRoot.ByteProofs", + "HexRCF.SelectedRoot.Audit", + "HexRCF.SelectedRoot.Checks", + "HexRCF.SelectedRoot.Collect", + "HexRCF.SelectedRoot.Controls", + "HexRCF.SelectedRoot.Data", + "HexRCF.SelectedRoot.Frozen", + "HexRCF.SelectedRoot.FrozenCollect", + "HexRCF.SelectedRoot.KernelCheck", + "HexRCF.SelectedRoot.Intermediates", + "HexRCF.SelectedRoot.Literals", + "HexRCF.SelectedRoot.PacketFields", + "HexRCF.SelectedRoot.Packets", + "HexRCF.SelectedRoot.Proofs", + "HexRCF.SelectedRoot.Read", + "HexRCF.SelectedRoot.Refusals", + "HexRCF.SelectedRoot.ReplayTools", + "HexRCF.SelectedRoot.Row", + "HexRCF.SelectedRoot.RowCollect", + "HexRCF.SelectedRoot.RowIntermediates", + "HexRCF.SelectedRoot.RowTools", + "HexRCF.SelectedRoot.Source", + "HexRCF.SelectedRoot.Upper", + "HexRCF.PublicGraphCodec" + ], + "base_test_roots": [ + "HexRCF.LanguageTests", + "HexRCF.SturmBuilderTests", + "HexRCF.CarrierTests", + "HexRCF.IsolationsTests", + "HexRCF.SeparationTests", + "HexRCF.CellsTests", + "HexRCF.CommonRootTests", + "HexRCF.SignMatrixTests", + "HexRCF.BuilderTests", + "HexRCF.CertificateTests", + "HexRCF.DecisionTests", + "HexRCF.ReifyTests", + "HexRCF.HandlerTests.Support", + "HexRCF.HandlerTests.Async", + "HexRCF.HandlerTests", + "HexRCF.LintTests" + ], + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/lake-bounded", + "build", + "HexRCF", + "HexRCFRealCoefficients", + "+HexRCF.Conformance", + "+HexRCF.SourceIdentityKernel", + "+HexRCF.SourceIdentityCases", + "+HexRCF.MaximalCoefficientsKernel", + "+HexRCF.MaximalCoefficientsConformance", + "+HexRCF.MaximalCoefficients", + "+HexRCF.CellReplay.AssembledKernel", + "+HexRCF.CellReplay.Assembled", + "+HexRCF.CellReplay.OperationsPublic", + "+HexRCF.CellReplay.OperationsKernel", + "+HexRCF.CellReplay.Operations", + "+HexRCF.CellReplay.Algebraic.Emit", + "+HexRCF.CellReplay.Algebraic.MutationData0", + "+HexRCF.CellReplay.Algebraic.Mutations", + "+HexRCF.CellReplay.Algebraic.Refusals", + "+HexRCF.CellReplay.Algebraic.Guards", + "+HexRCF.CellReplay.Algebraic.Meaning", + "+HexRCF.CellReplay.Algebraic.Boolean", + "+HexRCF.CellReplay.Algebraic.BooleanSources", + "+HexRCF.CellReplay.Algebraic.BooleanBinding", + "+HexRCF.CellReplay.Algebraic.BooleanQuoted", + "+HexRCF.CellBuildConformance", + "+HexRCF.CellDiscoverLinear", + "+HexRCF.CellDiscoverAlgebraic", + "+HexRCF.CellDiscoverCases", + "+HexRCF.CellDiscoverProofs", + "+HexRCF.CellRequestedConformance", + "+HexRCF.CellDecisionProofs", + "+HexRCF.CellCodecProofs", + "+HexRCF.CellExecutionProofs", + "+HexRCF.NumberFieldCellsConformance", + "+HexRCF.GatherCellsConformance", + "+HexRCF.RealModelConformance", + "+HexRCF.AlgebraicPreparationCases", + "+HexRCF.AlgebraicPreparationConformance", + "+HexRCF.SourceAcceptancePublic", + "+HexRCF.AlgebraicCellsConformance", + "+HexRCF.CellReplay.Algebraic.Canonical", + "+HexRCF.CellReplay.Algebraic.Check", + "+HexRCF.CellReplay.Algebraic.Convert", + "+HexRCF.CellReplay.Algebraic.Inputs", + "+HexRCF.CellReplay.Algebraic.LiteralData0", + "+HexRCF.CellReplay.Algebraic.LiteralData1", + "+HexRCF.CellReplay.Algebraic.Literals", + "+HexRCF.CellReplay.Algebraic.Quote", + "+HexRCF.CellReplay.Algebraic.Quoted", + "+HexRCF.CellReplay.Algebraic.CompleteQuote", + "+HexRCF.CellReplay.Algebraic.CompleteQuoted", + "+HexRCF.CellReplay.Algebraic.Radical", + "+HexRCF.CellReplay.Algebraic.Read", + "+HexRCF.CellReplay.Algebraic.Records", + "+HexRCF.CellReplay.Algebraic.ScalarData0", + "+HexRCF.CellReplay.Algebraic.ScalarData1", + "+HexRCF.CellReplay.Algebraic.Scalars", + "+HexRCF.CellReplay.Algebraic.Schema", + "+HexRCF.CellReplay.Algebraic.Sections", + "+HexRCF.RealFormulaConformance", + "+HexRCF.RealCoefficientsConformance", + "+HexRCF.AlgebraicProgress", + "+HexRCF.IsolationProgress", + "+HexRCF.RadicalProgress", + "+HexRCF.ProductionProgress", + "+HexRCF.FieldRootsConformance", + "+HexRCF.CertificationInputs", + "+HexRCF.RationalSources", + "+HexRCF.ProofEvidence", + "+HexRCF.CheckedConversions", + "+HexRCF.ReplayModes", + "+HexRCF.CarrierModes", + "+HexRCF.SignIndex", + "+HexRCF.PreparedCoefficients", + "+HexRCF.FiniteReplay", + "+HexRCF.FiniteSignsConformance", + "+HexRCF.CellReplay.OutsideLiterals", + "+HexRCF.CellReplay.Zero", + "+HexRCF.CellReplay.ZeroLiterals", + "+HexRCF.CellReplay.Valuation", + "+HexRCF.CellReplay.ModuleCheck", + "+HexRCF.CellReplay.Schema", + "+HexRCF.CellReplay.Check", + "+HexRCF.CellReplay.Ordinary", + "+HexRCF.CellReplay.Quote", + "+HexRCF.CellReplay.Controls", + "+HexRCF.CellReplay.Quoted", + "+HexRCF.CellReplay.Refusals", + "+HexRCF.CellReplay.Emit", + "+HexRCF.CellReplay.LiteralData0", + "+HexRCF.CellReplay.Literals", + "+HexRCF.CellReplay.MutationData0", + "+HexRCF.CellReplay.Mutations", + "+HexRCF.FiniteMatrix.Binding", + "+HexRCF.FiniteMatrix.Guards.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "+HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "+HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "+HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "+HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "+HexRCF.FiniteMatrix.Guards.Quotient.Records", + "+HexRCF.FiniteMatrix.Guards.Quotient.Source", + "+HexRCF.FiniteMatrix.Guards.Controls", + "+HexRCF.FiniteMatrix.Guards.Data", + "+HexRCF.FiniteMatrix.Guards.Domains", + "+HexRCF.FiniteMatrix.Guards.Emit", + "+HexRCF.FiniteMatrix.Guards.LiteralData0", + "+HexRCF.FiniteMatrix.Guards.Literals", + "+HexRCF.FiniteMatrix.Guards.Meaning", + "+HexRCF.FiniteMatrix.Guards.MutationData0", + "+HexRCF.FiniteMatrix.Guards.Mutations", + "+HexRCF.FiniteMatrix.Guards.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quote", + "+HexRCF.FiniteMatrix.Guards.Read", + "+HexRCF.FiniteMatrix.Guards.Records", + "+HexRCF.FiniteMatrix.Guards.Refusals", + "+HexRCF.FiniteMatrix.Guards.Schema", + "+HexRCF.FiniteMatrix.Data", + "+HexRCF.FiniteMatrix.Emit", + "+HexRCF.FiniteMatrix.Inputs", + "+HexRCF.FiniteMatrix.KernelControls", + "+HexRCF.FiniteMatrix.LiteralData0", + "+HexRCF.FiniteMatrix.LiteralData1", + "+HexRCF.FiniteMatrix.LiteralData2", + "+HexRCF.FiniteMatrix.LiteralData3", + "+HexRCF.FiniteMatrix.LiteralData4", + "+HexRCF.FiniteMatrix.LiteralData5", + "+HexRCF.FiniteMatrix.Literals", + "+HexRCF.FiniteMatrix.ModuleCheck", + "+HexRCF.FiniteMatrix.Ordinary", + "+HexRCF.FiniteMatrix.Packings", + "+HexRCF.FiniteMatrix.Quote", + "+HexRCF.FiniteMatrix.Controls", + "+HexRCF.FiniteMatrix.Refusals", + "+HexRCF.FiniteMatrix.Read", + "+HexRCF.FiniteMatrix.Restore", + "+HexRCF.FiniteMatrix.Schema", + "+HexRCF.FiniteMatrix.Selected", + "+HexRCF.FiniteMatrix.Semantics", + "+HexRCF.FiniteMatrix.Signs", + "+HexRCF.TowerSamples", + "+HexRCF.Samples", + "+HexRCF.RealizationData", + "+HexRCF.Realization", + "+HexRCF.NumberField", + "+HexRCF.Gather", + "+HexRCF.GatherCatalog", + "+HexRCF.RegisteredGatherConformance", + "+HexRCF.GeneratorWindowInputs", + "+HexRCF.GeneratorWindow", + "+HexRCF.CertificationProofs", + "+HexRCF.SuppliedIrreducible", + "+HexRCF.SuppliedIrreducibleProofs", + "+HexRCF.SuppliedBudget", + "+HexRCF.NativeFormulaConformance", + "+HexRCF.NativeSpecializeConformance", + "+HexRCF.NativeSamplesConformance", + "+HexRCF.NativeSampleModelConformance", + "+HexRCF.NativeSampleModelLiterals", + "+HexRCF.NativeSourcesConformance", + "+HexRCF.NativeSelectionLiterals", + "+HexRCF.NativeSelectionConformance", + "+HexRCF.NativeSelectionOrdinaryConformance", + "+HexRCF.NativeSelectionOrderedConformance", + "+HexRCF.SectionReplayConformance", + "+HexRCF.SectionProduceConformance", + "+HexRCF.SectionOrdinaryConformance", + "+HexRCF.PointReplayConformance", + "+HexRCF.PointProduceConformance", + "+HexRCF.PointOrdinaryConformance", + "+HexRCF.RootReplayLiterals", + "+HexRCF.RootReplayConformance", + "+HexRCF.RootReplayOrdinaryConformance", + "+HexRCF.NestedRootLiterals", + "+HexRCF.NestedRootProduceConformance", + "+HexRCF.NestedRootOrdinaryConformance", + "+HexRCF.RootTransportData", + "+HexRCF.RootTransportLiterals", + "+HexRCF.RootTransportConformance", + "+HexRCF.RootTransportOrdinaryConformance", + "+HexRCF.NestedTransport.Frame", + "+HexRCF.NestedTransport.Context", + "+HexRCF.NestedTransport.Map", + "+HexRCF.NestedTransport.Conversion", + "+HexRCF.NestedTransport.Fields", + "+HexRCF.NestedTransport.Restore", + "+HexRCF.NestedTransport.Predecessor", + "+HexRCF.NestedTransport.Facts", + "+HexRCF.NestedTransport.Constants", + "+HexRCF.NestedTransport.Operations", + "+HexRCF.NestedTransport.RootRead", + "+HexRCF.NestedTransport.Read", + "+HexRCF.NestedTransport.Model", + "+HexRCF.NestedTransport.Source", + "+HexRCF.NestedTransport.Ordinary", + "+HexRCF.NestedTransport.Controls", + "+HexRCF.NestedTransport.Literals", + "+HexRCF.NestedTransport.EndpointLiterals", + "+HexRCF.NestedTransport.SignLiterals", + "+HexRCF.NestedTransport.SignData", + "+HexRCF.TotalAlgebraicProofs", + "+HexRCF.AlgebraicDivision", + "+HexRCF.NormalizedCoefficients", + "+HexRCF.NormalizedInputs", + "+HexRCF.RegisteredConstants", + "+HexRCF.NamedConstants", + "+HexRCF.MixedConstants", + "+HexRCF.CoarseConstants", + "+HexRCF.RealCoefficientTactic", + "+HexRCF.RealCoefficientCommonField", + "+HexRCF.CommonFieldPresentation", + "+HexRCF.RootAliasesConformance", + "+HexRCF.RationalRoots", + "+HexRCF.AlgebraicRoots", + "+HexRCF.FormulaConformance", + "+HexRCF.LiteralSignConformance", + "+HexRCF.FieldSpecializeConformance", + "+HexRCF.SignDetFieldProofs", + "+HexRCF.AdmissionConformance", + "+HexRCF.IsolationConformance", + "+HexRCF.SelectedRoot.Packing", + "+HexRCF.SelectedRoot.PackingData", + "+HexRCF.SelectedRoot.InverseData", + "+HexRCF.SelectedRoot.InverseReplay", + "+HexRCF.SelectedRoot.InverseControls", + "+HexRCF.InverseFixture", + "+HexRCF.SelectedRoot.PackingReplay", + "+HexRCF.SelectedRoot.PackingMissing", + "+HexRCF.SelectedRoot.PackingAudit", + "+HexRCF.SelectedRoot.CatalogData", + "+HexRCF.SelectedRoot.CatalogByteData", + "+HexRCF.SelectedRoot.CatalogSource", + "+HexRCF.SelectedRoot.Catalog", + "+HexRCF.SelectedRoot.CatalogBytes", + "+HexRCF.SelectedRoot.CatalogControls", + "+HexRCF.SelectedRoot.CatalogAudit", + "+HexRCF.SelectedRoot.ByteAudit", + "+HexRCF.SelectedRoot.ByteBounds", + "+HexRCF.SelectedRoot.ByteChecks", + "+HexRCF.SelectedRoot.ByteData", + "+HexRCF.SelectedRoot.ByteProofs", + "+HexRCF.SelectedRoot.Audit", + "+HexRCF.SelectedRoot.Checks", + "+HexRCF.SelectedRoot.Collect", + "+HexRCF.SelectedRoot.Controls", + "+HexRCF.SelectedRoot.Data", + "+HexRCF.SelectedRoot.Frozen", + "+HexRCF.SelectedRoot.FrozenCollect", + "+HexRCF.SelectedRoot.KernelCheck", + "+HexRCF.SelectedRoot.Intermediates", + "+HexRCF.SelectedRoot.Literals", + "+HexRCF.SelectedRoot.PacketFields", + "+HexRCF.SelectedRoot.Packets", + "+HexRCF.SelectedRoot.Proofs", + "+HexRCF.SelectedRoot.Read", + "+HexRCF.SelectedRoot.Refusals", + "+HexRCF.SelectedRoot.ReplayTools", + "+HexRCF.SelectedRoot.Row", + "+HexRCF.SelectedRoot.RowCollect", + "+HexRCF.SelectedRoot.RowIntermediates", + "+HexRCF.SelectedRoot.RowTools", + "+HexRCF.SelectedRoot.Source", + "+HexRCF.SelectedRoot.Upper", + "+HexRCF.PublicGraphCodec", + "+HexRCF.LanguageTests", + "+HexRCF.SturmBuilderTests", + "+HexRCF.CarrierTests", + "+HexRCF.IsolationsTests", + "+HexRCF.SeparationTests", + "+HexRCF.CellsTests", + "+HexRCF.CommonRootTests", + "+HexRCF.SignMatrixTests", + "+HexRCF.BuilderTests", + "+HexRCF.CertificateTests", + "+HexRCF.DecisionTests", + "+HexRCF.ReifyTests", + "+HexRCF.HandlerTests.Support", + "+HexRCF.HandlerTests.Async", + "+HexRCF.HandlerTests", + "+HexRCF.LintTests", + "HexRCFProofProbe", + "HexManual" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "scope": "All 263 actual HexRCF HexConformance roots, all 16 base HexReleaseTests roots, both libraries, registered-constant proof probes and full manual." + }, + "diagnostics": [ + { + "source_commit": "466e3990451ba4c4b1494d0c6e1949e121a5ad73", + "log": "reports/data/hexrcf-source-acceptance/source-acceptance-render-1.log.gz", + "uncompressed_sha256": "643efda547e2bbec81ecde439754bf809f17ddf8c74553ce802d5e28c41d4215", + "result": "FAILED: cross-chapter auxiliary declaration collision; not a passing render." + } + ], + "inspection": { + "opened_images": [ + "reports/data/hexrcf-source-acceptance/source-acceptance-desktop-equivalence.png", + "reports/data/hexrcf-source-acceptance/source-acceptance-desktop-example.png", + "reports/data/hexrcf-source-acceptance/source-acceptance-desktop-boundary.png", + "reports/data/hexrcf-source-acceptance/source-acceptance-narrow-equivalence.png", + "reports/data/hexrcf-source-acceptance/source-acceptance-narrow-example.png", + "reports/data/hexrcf-source-acceptance/source-acceptance-narrow-boundary.png" + ], + "scope": "Changed acceptance paragraph, runnable example, and limitation paragraph at 1440 and 390 pixels. Earlier book layout is excluded." + }, + "report_snapshot": "reports/data/hexrcf-source-acceptance/hexrcf-source-acceptance.md.txt" +} diff --git a/reports/data/hexrcf-source-acceptance/hexrcf-source-acceptance.md.txt b/reports/data/hexrcf-source-acceptance/hexrcf-source-acceptance.md.txt new file mode 100644 index 0000000000..3c336a61a0 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/hexrcf-source-acceptance.md.txt @@ -0,0 +1,103 @@ +# Acceptance at original algebraic sources + +`AlgebraicCells.accepts` states two concrete facts: the existing algebraic +producer returns a packet, and the complete packet checker returns accepted +true. Its source tuple, coefficient indices, original-divisor indices, shared +matrix and quantifier are fixed arguments. This is mathematical acceptance +of the actual total producer and checker, not a new certificate format. + +`accepts_iff` proves that acceptance is equivalent to every original real +divisor being nonzero and the shared sentence holding at its original fixed +algebraic values. It composes the existing `build_complete`, `build_sound` +and `build_domains` laws. It assumes no successful child calculation, supplied +root table or sector function. `accepts_tuple` separates ordered coefficient +and divisor coordinates. `accepts_source` transports that result through +checked source identities and the shared frontend's exact original-goal +equivalence. A semantically trivial source does not remove its divisor +conjuncts: an empty domain with an original zero divisor remains invalid. + +`AlgebraicPreparation.Inputs.acceptanceIff` constructs this proof from the +retained kernel algebraic expressions. It checks each expression and its exact +`toReal` equality, constructs the ordered finite functions, reads the quantifier +and matrix from the checked source formula, and checks the source equivalence. +It does not use the separately evaluated runtime proposals or the editable +runtime formula/quantifier fields as proof evidence. The result's right side +is exactly the original real target together with all original nonzero guards. + +The helper continues the preparation's aggregate proof budget. It charges +proofs before checking them, returns the updated aggregate usage for later +stages, preserves caller metavariables on success and +restores the complete state after exhaustion or failure. Successful private +proof auxiliaries remain available for the returned ordinary proof. + +Source-specific consumers cover rational zero-coordinate input, an +irrational positive source, a false source, both original quotient/inverse +occurrences, a cancelled semantically zero divisor, reversed intervals with +and without a zero divisor, and a local real alias with its equality hypothesis. +They compare the exact original target and ordered source-expression tuple. +Editing runtime proposals, the runtime matrix and the runtime quantifier must +leave the returned theorem type unchanged. Continued usage must increase; +one node below the measured cumulative proof limit refuses, and the exact +limit succeeds. Heartbeat, recursion and interruption entry checks remain +terminal, with state/declaration rollback. Those resource tests do not force +a failure halfway through kernel checking. Edited identity and exhausted-budget +cases separately exercise rollback after auxiliary proof work. + +A fresh importing module checks the actual theorem bodies and their transitive +axiom closure, requiring the real producer completeness and domain laws. An +ordinary-public-import consumer unfolds `accepts` and constructs an accepted +empty-input packet from `build_complete`, without an acceptance premise. +Its body is included in the fresh audit. The only axioms are `propext`, +`Classical.choice` and `Quot.sound`. + +The expanded consumer selection at `b1f0c80539` has 11,036 jobs, takes +3m14.332s and peaks at 4 GiB with no swap. Its manual/dependency selection +passes 11,681 jobs in 6m19.764s at 13.1 GiB; the actual revised chapter rebuilds +in 5.9s. The final identity-retention correction puts every retained identity +inside the same cumulative preparation budget and preserves a caller's lowered +recursion limit through the options wrapper. Its combined consumer, fresh +body-audit, public-import and manual selection passes 11,681 jobs in 2m44.798s +at 3.6 GiB. The chapter takes 5.2s. These observations include incremental +dependency work and different test scopes; they are not matched performance +comparisons or isolated replay/scaling measurements. + +All own local builds remain serial under 32 GiB aggregate memory, no swap and +two Lean threads. Successful calls retain private proof auxiliaries for the +returned evidence. Repeated retention and guard-only algebraic inputs contribute +to the remaining depth, memory and expanded-work measurements. + +This does not prove a computed proposal equal to a frozen literal or reconstruct +provider/predecessor histories. It does not install a generic tactic handler, +authenticate a compiled complete packet, establish strict rejection of missing +intermediate records, or close #10358. General literal-source quotation, +resource-scheduled acceptance, realization and remaining stress/performance +work retain their own obligations. The manual explains the distinction and +runs the meta helper on an original irrational-coefficient statement. + +At `25c5f7afac`, the complete selection of all 263 RCF conformance roots, +all 16 base-test roots, both libraries, the actual caller-supplied π/e proof +probes and the full manual passes 14,610 jobs in 51m21.530s, with a 12.8 GiB +peak and no swap. This is a build observation with dependency work included, +not an isolated algorithm measurement or a matched comparison. + +The complete-manual import check requires a module-private auxiliary name for +the runnable example's extra kernel check. Without that scope it collides +with a generated theorem in another chapter; the failed render is retained +as a diagnostic, not a pass. The corrected full manual passes 14,311 jobs in +2m36.421s at 2.1 GiB. The final single-page HTML render passes 14,313 jobs in +11.503s at 1.4 GiB. All six desktop and narrow captures of the acceptance +paragraph, runnable example and limitation paragraph were opened. Their local +overflow checks pass after shortening the example's lines. This does not +assert that the rest of the book has no horizontal overflow. + +A fresh ordinary-import probe also imports the source-acceptance audit and +the complete manual together. It passes 14,317 jobs in 15.473s at 3.3 GiB, +so the retained audit is composable with the corrected manual. + +The [source-bound record](data/hexrcf-source-acceptance/context.json) retains +the exact selection, code and script hashes, scoped proof/build logs, +metadata commands and captures. The +[complete selection log](data/hexrcf-source-acceptance/source-acceptance-all-1.log.gz) +and [final render log](data/hexrcf-source-acceptance/source-acceptance-render-3.log.gz) +are separate from the +[failed import diagnostic](data/hexrcf-source-acceptance/source-acceptance-render-1.log.gz). diff --git a/reports/data/hexrcf-source-acceptance/integration/record.json b/reports/data/hexrcf-source-acceptance/integration/record.json new file mode 100644 index 0000000000..29f9dcc88e --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/integration/record.json @@ -0,0 +1,106 @@ +{ + "source_commit": "dd32822835407d53a2aff7006ebe2f80ef5d9ae5", + "source_tree": "374ec7bc3d81194f80a480d9c7afb6aed5798e6f", + "integrated_parent": "2bde7905ed4afe6d7460e39752381e210192a60c", + "code_unchanged_from": "25c5f7afac", + "unchanged_paths": [ + "*.lean", + "lake-manifest.json", + "lean-toolchain", + "libraries.yml" + ], + "base_record": { + "path": "reports/data/hexrcf-source-acceptance/context.json", + "sha256": "1f19ebdf23823dd10f3d73dbf05e573acb8e658a95ce321d9f9ac122a5cd11bf" + }, + "metadata": { + "source_commit": "dd32822835407d53a2aff7006ebe2f80ef5d9ae5", + "source_tree": "374ec7bc3d81194f80a480d9c7afb6aed5798e6f", + "checks": { + "dag": { + "command": { + "argv": [ + "python3", + "scripts/check_dag.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "dd32822835407d53a2aff7006ebe2f80ef5d9ae5", + "source_tree": "374ec7bc3d81194f80a480d9c7afb6aed5798e6f", + "script_sha256": "760236cb56f22dd916c677070713146ebd9bd652ba988b3f9427d6a671a4ea10" + }, + "exit_status": 0, + "log": "source-acceptance-dag-5.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "copyright": { + "command": { + "argv": [ + "python3", + "scripts/check_copyright_headers.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "dd32822835407d53a2aff7006ebe2f80ef5d9ae5", + "source_tree": "374ec7bc3d81194f80a480d9c7afb6aed5798e6f", + "script_sha256": "d7ccfbb8e737c342ff24f7ec875c403a76a678a75f581a8e7dcaf0b654325c84" + }, + "exit_status": 0, + "log": "source-acceptance-copyright-5.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "lines": { + "command": { + "argv": [ + "python3", + "scripts/check_file_line_counts.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "dd32822835407d53a2aff7006ebe2f80ef5d9ae5", + "source_tree": "374ec7bc3d81194f80a480d9c7afb6aed5798e6f", + "script_sha256": "0c9109c17128a11651f7a5d3784b5b35c859b87e2f58d12c2fbcd5c7562f1229" + }, + "exit_status": 0, + "log": "source-acceptance-lines-5.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "admissions": { + "command": { + "argv": [ + "python3", + "scripts/ci/check_named_admissions.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "dd32822835407d53a2aff7006ebe2f80ef5d9ae5", + "source_tree": "374ec7bc3d81194f80a480d9c7afb6aed5798e6f", + "script_sha256": "b2a2ceb6ba6422b4a54c8c797907c61574c1f60e6659441e8c1b357ee3c471ce" + }, + "exit_status": 0, + "log": "source-acceptance-admissions-5.log", + "sha256": "e43ea625a5bd76ee270c4f04f155c2ed77ed259c673904377f0e30645bca03ca" + } + } + }, + "artifacts": { + "reports/data/hexrcf-source-acceptance/integration/source-acceptance-dag-5.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "reports/data/hexrcf-source-acceptance/integration/source-acceptance-copyright-5.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "reports/data/hexrcf-source-acceptance/integration/source-acceptance-lines-5.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "reports/data/hexrcf-source-acceptance/integration/source-acceptance-admissions-5.log": "e43ea625a5bd76ee270c4f04f155c2ed77ed259c673904377f0e30645bca03ca", + "reports/data/hexrcf-source-acceptance/integration/source-acceptance-integration-1.log.gz": "fcebba1e705c192feddc3c39888038b0343219909bf3dc745b20199dac150e5e" + }, + "scope": "Focused integration after actual parent squash merge; Lean/manifest/toolchain/library metadata inputs are unchanged from the complete263+16 selection. No repeated cold-run or isolated performance claim.", + "build": { + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/lake-bounded", + "build", + "HexRCF", + "HexRCFRealCoefficients", + "+HexRCF.AlgebraicPreparationCases", + "+HexRCF.AlgebraicPreparationConformance", + "+HexRCF.SourceAcceptancePublic", + "HexRCFProofProbe", + "HexManual" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "log": "reports/data/hexrcf-source-acceptance/integration/source-acceptance-integration-1.log.gz", + "uncompressed_sha256": "b6437cc0486521e1fc832d73db479e038d47cb1ab36529545b026f65a7633e82" + } +} diff --git a/reports/data/hexrcf-source-acceptance/integration/source-acceptance-admissions-5.log b/reports/data/hexrcf-source-acceptance/integration/source-acceptance-admissions-5.log new file mode 100644 index 0000000000..cc19aa52d9 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/integration/source-acceptance-admissions-5.log @@ -0,0 +1 @@ +670 scanned adapter/conformance import cones: 1578 local modules, no admissions in these cones diff --git a/reports/data/hexrcf-source-acceptance/integration/source-acceptance-copyright-5.log b/reports/data/hexrcf-source-acceptance/integration/source-acceptance-copyright-5.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/integration/source-acceptance-dag-5.log b/reports/data/hexrcf-source-acceptance/integration/source-acceptance-dag-5.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/integration/source-acceptance-integration-1.log.gz b/reports/data/hexrcf-source-acceptance/integration/source-acceptance-integration-1.log.gz new file mode 100644 index 0000000000..568345ac26 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/integration/source-acceptance-integration-1.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/integration/source-acceptance-lines-5.log b/reports/data/hexrcf-source-acceptance/integration/source-acceptance-lines-5.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-admissions-4.log b/reports/data/hexrcf-source-acceptance/source-acceptance-admissions-4.log new file mode 100644 index 0000000000..cc19aa52d9 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/source-acceptance-admissions-4.log @@ -0,0 +1 @@ +670 scanned adapter/conformance import cones: 1578 local modules, no admissions in these cones diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-all-1.log.gz b/reports/data/hexrcf-source-acceptance/source-acceptance-all-1.log.gz new file mode 100644 index 0000000000..f1660f9411 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-all-1.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-all-selection-1.json b/reports/data/hexrcf-source-acceptance/source-acceptance-all-selection-1.json new file mode 100644 index 0000000000..5cbf6609c5 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/source-acceptance-all-selection-1.json @@ -0,0 +1,576 @@ +{ + "source_commit": "25c5f7afaca586847686ae1009c554ae04f69cd5", + "source_tree": "e4941e7a93d606c43deec2b006293ab82a4b07ab", + "rcf_conformance_roots": [ + "HexRCF.Conformance", + "HexRCF.SourceIdentityKernel", + "HexRCF.SourceIdentityCases", + "HexRCF.MaximalCoefficientsKernel", + "HexRCF.MaximalCoefficientsConformance", + "HexRCF.MaximalCoefficients", + "HexRCF.CellReplay.AssembledKernel", + "HexRCF.CellReplay.Assembled", + "HexRCF.CellReplay.OperationsPublic", + "HexRCF.CellReplay.OperationsKernel", + "HexRCF.CellReplay.Operations", + "HexRCF.CellReplay.Algebraic.Emit", + "HexRCF.CellReplay.Algebraic.MutationData0", + "HexRCF.CellReplay.Algebraic.Mutations", + "HexRCF.CellReplay.Algebraic.Refusals", + "HexRCF.CellReplay.Algebraic.Guards", + "HexRCF.CellReplay.Algebraic.Meaning", + "HexRCF.CellReplay.Algebraic.Boolean", + "HexRCF.CellReplay.Algebraic.BooleanSources", + "HexRCF.CellReplay.Algebraic.BooleanBinding", + "HexRCF.CellReplay.Algebraic.BooleanQuoted", + "HexRCF.CellBuildConformance", + "HexRCF.CellDiscoverLinear", + "HexRCF.CellDiscoverAlgebraic", + "HexRCF.CellDiscoverCases", + "HexRCF.CellDiscoverProofs", + "HexRCF.CellRequestedConformance", + "HexRCF.CellDecisionProofs", + "HexRCF.CellCodecProofs", + "HexRCF.CellExecutionProofs", + "HexRCF.NumberFieldCellsConformance", + "HexRCF.GatherCellsConformance", + "HexRCF.RealModelConformance", + "HexRCF.AlgebraicPreparationCases", + "HexRCF.AlgebraicPreparationConformance", + "HexRCF.SourceAcceptancePublic", + "HexRCF.AlgebraicCellsConformance", + "HexRCF.CellReplay.Algebraic.Canonical", + "HexRCF.CellReplay.Algebraic.Check", + "HexRCF.CellReplay.Algebraic.Convert", + "HexRCF.CellReplay.Algebraic.Inputs", + "HexRCF.CellReplay.Algebraic.LiteralData0", + "HexRCF.CellReplay.Algebraic.LiteralData1", + "HexRCF.CellReplay.Algebraic.Literals", + "HexRCF.CellReplay.Algebraic.Quote", + "HexRCF.CellReplay.Algebraic.Quoted", + "HexRCF.CellReplay.Algebraic.CompleteQuote", + "HexRCF.CellReplay.Algebraic.CompleteQuoted", + "HexRCF.CellReplay.Algebraic.Radical", + "HexRCF.CellReplay.Algebraic.Read", + "HexRCF.CellReplay.Algebraic.Records", + "HexRCF.CellReplay.Algebraic.ScalarData0", + "HexRCF.CellReplay.Algebraic.ScalarData1", + "HexRCF.CellReplay.Algebraic.Scalars", + "HexRCF.CellReplay.Algebraic.Schema", + "HexRCF.CellReplay.Algebraic.Sections", + "HexRCF.RealFormulaConformance", + "HexRCF.RealCoefficientsConformance", + "HexRCF.AlgebraicProgress", + "HexRCF.IsolationProgress", + "HexRCF.RadicalProgress", + "HexRCF.ProductionProgress", + "HexRCF.FieldRootsConformance", + "HexRCF.CertificationInputs", + "HexRCF.RationalSources", + "HexRCF.ProofEvidence", + "HexRCF.CheckedConversions", + "HexRCF.ReplayModes", + "HexRCF.CarrierModes", + "HexRCF.SignIndex", + "HexRCF.PreparedCoefficients", + "HexRCF.FiniteReplay", + "HexRCF.FiniteSignsConformance", + "HexRCF.CellReplay.OutsideLiterals", + "HexRCF.CellReplay.Zero", + "HexRCF.CellReplay.ZeroLiterals", + "HexRCF.CellReplay.Valuation", + "HexRCF.CellReplay.ModuleCheck", + "HexRCF.CellReplay.Schema", + "HexRCF.CellReplay.Check", + "HexRCF.CellReplay.Ordinary", + "HexRCF.CellReplay.Quote", + "HexRCF.CellReplay.Controls", + "HexRCF.CellReplay.Quoted", + "HexRCF.CellReplay.Refusals", + "HexRCF.CellReplay.Emit", + "HexRCF.CellReplay.LiteralData0", + "HexRCF.CellReplay.Literals", + "HexRCF.CellReplay.MutationData0", + "HexRCF.CellReplay.Mutations", + "HexRCF.FiniteMatrix.Binding", + "HexRCF.FiniteMatrix.Guards.Binding", + "HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "HexRCF.FiniteMatrix.Guards.Quotient.Records", + "HexRCF.FiniteMatrix.Guards.Quotient.Source", + "HexRCF.FiniteMatrix.Guards.Controls", + "HexRCF.FiniteMatrix.Guards.Data", + "HexRCF.FiniteMatrix.Guards.Domains", + "HexRCF.FiniteMatrix.Guards.Emit", + "HexRCF.FiniteMatrix.Guards.LiteralData0", + "HexRCF.FiniteMatrix.Guards.Literals", + "HexRCF.FiniteMatrix.Guards.Meaning", + "HexRCF.FiniteMatrix.Guards.MutationData0", + "HexRCF.FiniteMatrix.Guards.Mutations", + "HexRCF.FiniteMatrix.Guards.Ordinary", + "HexRCF.FiniteMatrix.Guards.Quote", + "HexRCF.FiniteMatrix.Guards.Read", + "HexRCF.FiniteMatrix.Guards.Records", + "HexRCF.FiniteMatrix.Guards.Refusals", + "HexRCF.FiniteMatrix.Guards.Schema", + "HexRCF.FiniteMatrix.Data", + "HexRCF.FiniteMatrix.Emit", + "HexRCF.FiniteMatrix.Inputs", + "HexRCF.FiniteMatrix.KernelControls", + "HexRCF.FiniteMatrix.LiteralData0", + "HexRCF.FiniteMatrix.LiteralData1", + "HexRCF.FiniteMatrix.LiteralData2", + "HexRCF.FiniteMatrix.LiteralData3", + "HexRCF.FiniteMatrix.LiteralData4", + "HexRCF.FiniteMatrix.LiteralData5", + "HexRCF.FiniteMatrix.Literals", + "HexRCF.FiniteMatrix.ModuleCheck", + "HexRCF.FiniteMatrix.Ordinary", + "HexRCF.FiniteMatrix.Packings", + "HexRCF.FiniteMatrix.Quote", + "HexRCF.FiniteMatrix.Controls", + "HexRCF.FiniteMatrix.Refusals", + "HexRCF.FiniteMatrix.Read", + "HexRCF.FiniteMatrix.Restore", + "HexRCF.FiniteMatrix.Schema", + "HexRCF.FiniteMatrix.Selected", + "HexRCF.FiniteMatrix.Semantics", + "HexRCF.FiniteMatrix.Signs", + "HexRCF.TowerSamples", + "HexRCF.Samples", + "HexRCF.RealizationData", + "HexRCF.Realization", + "HexRCF.NumberField", + "HexRCF.Gather", + "HexRCF.GatherCatalog", + "HexRCF.RegisteredGatherConformance", + "HexRCF.GeneratorWindowInputs", + "HexRCF.GeneratorWindow", + "HexRCF.CertificationProofs", + "HexRCF.SuppliedIrreducible", + "HexRCF.SuppliedIrreducibleProofs", + "HexRCF.SuppliedBudget", + "HexRCF.NativeFormulaConformance", + "HexRCF.NativeSpecializeConformance", + "HexRCF.NativeSamplesConformance", + "HexRCF.NativeSampleModelConformance", + "HexRCF.NativeSampleModelLiterals", + "HexRCF.NativeSourcesConformance", + "HexRCF.NativeSelectionLiterals", + "HexRCF.NativeSelectionConformance", + "HexRCF.NativeSelectionOrdinaryConformance", + "HexRCF.NativeSelectionOrderedConformance", + "HexRCF.SectionReplayConformance", + "HexRCF.SectionProduceConformance", + "HexRCF.SectionOrdinaryConformance", + "HexRCF.PointReplayConformance", + "HexRCF.PointProduceConformance", + "HexRCF.PointOrdinaryConformance", + "HexRCF.RootReplayLiterals", + "HexRCF.RootReplayConformance", + "HexRCF.RootReplayOrdinaryConformance", + "HexRCF.NestedRootLiterals", + "HexRCF.NestedRootProduceConformance", + "HexRCF.NestedRootOrdinaryConformance", + "HexRCF.RootTransportData", + "HexRCF.RootTransportLiterals", + "HexRCF.RootTransportConformance", + "HexRCF.RootTransportOrdinaryConformance", + "HexRCF.NestedTransport.Frame", + "HexRCF.NestedTransport.Context", + "HexRCF.NestedTransport.Map", + "HexRCF.NestedTransport.Conversion", + "HexRCF.NestedTransport.Fields", + "HexRCF.NestedTransport.Restore", + "HexRCF.NestedTransport.Predecessor", + "HexRCF.NestedTransport.Facts", + "HexRCF.NestedTransport.Constants", + "HexRCF.NestedTransport.Operations", + "HexRCF.NestedTransport.RootRead", + "HexRCF.NestedTransport.Read", + "HexRCF.NestedTransport.Model", + "HexRCF.NestedTransport.Source", + "HexRCF.NestedTransport.Ordinary", + "HexRCF.NestedTransport.Controls", + "HexRCF.NestedTransport.Literals", + "HexRCF.NestedTransport.EndpointLiterals", + "HexRCF.NestedTransport.SignLiterals", + "HexRCF.NestedTransport.SignData", + "HexRCF.TotalAlgebraicProofs", + "HexRCF.AlgebraicDivision", + "HexRCF.NormalizedCoefficients", + "HexRCF.NormalizedInputs", + "HexRCF.RegisteredConstants", + "HexRCF.NamedConstants", + "HexRCF.MixedConstants", + "HexRCF.CoarseConstants", + "HexRCF.RealCoefficientTactic", + "HexRCF.RealCoefficientCommonField", + "HexRCF.CommonFieldPresentation", + "HexRCF.RootAliasesConformance", + "HexRCF.RationalRoots", + "HexRCF.AlgebraicRoots", + "HexRCF.FormulaConformance", + "HexRCF.LiteralSignConformance", + "HexRCF.FieldSpecializeConformance", + "HexRCF.SignDetFieldProofs", + "HexRCF.AdmissionConformance", + "HexRCF.IsolationConformance", + "HexRCF.SelectedRoot.Packing", + "HexRCF.SelectedRoot.PackingData", + "HexRCF.SelectedRoot.InverseData", + "HexRCF.SelectedRoot.InverseReplay", + "HexRCF.SelectedRoot.InverseControls", + "HexRCF.InverseFixture", + "HexRCF.SelectedRoot.PackingReplay", + "HexRCF.SelectedRoot.PackingMissing", + "HexRCF.SelectedRoot.PackingAudit", + "HexRCF.SelectedRoot.CatalogData", + "HexRCF.SelectedRoot.CatalogByteData", + "HexRCF.SelectedRoot.CatalogSource", + "HexRCF.SelectedRoot.Catalog", + "HexRCF.SelectedRoot.CatalogBytes", + "HexRCF.SelectedRoot.CatalogControls", + "HexRCF.SelectedRoot.CatalogAudit", + "HexRCF.SelectedRoot.ByteAudit", + "HexRCF.SelectedRoot.ByteBounds", + "HexRCF.SelectedRoot.ByteChecks", + "HexRCF.SelectedRoot.ByteData", + "HexRCF.SelectedRoot.ByteProofs", + "HexRCF.SelectedRoot.Audit", + "HexRCF.SelectedRoot.Checks", + "HexRCF.SelectedRoot.Collect", + "HexRCF.SelectedRoot.Controls", + "HexRCF.SelectedRoot.Data", + "HexRCF.SelectedRoot.Frozen", + "HexRCF.SelectedRoot.FrozenCollect", + "HexRCF.SelectedRoot.KernelCheck", + "HexRCF.SelectedRoot.Intermediates", + "HexRCF.SelectedRoot.Literals", + "HexRCF.SelectedRoot.PacketFields", + "HexRCF.SelectedRoot.Packets", + "HexRCF.SelectedRoot.Proofs", + "HexRCF.SelectedRoot.Read", + "HexRCF.SelectedRoot.Refusals", + "HexRCF.SelectedRoot.ReplayTools", + "HexRCF.SelectedRoot.Row", + "HexRCF.SelectedRoot.RowCollect", + "HexRCF.SelectedRoot.RowIntermediates", + "HexRCF.SelectedRoot.RowTools", + "HexRCF.SelectedRoot.Source", + "HexRCF.SelectedRoot.Upper", + "HexRCF.PublicGraphCodec" + ], + "base_test_roots": [ + "HexRCF.LanguageTests", + "HexRCF.SturmBuilderTests", + "HexRCF.CarrierTests", + "HexRCF.IsolationsTests", + "HexRCF.SeparationTests", + "HexRCF.CellsTests", + "HexRCF.CommonRootTests", + "HexRCF.SignMatrixTests", + "HexRCF.BuilderTests", + "HexRCF.CertificateTests", + "HexRCF.DecisionTests", + "HexRCF.ReifyTests", + "HexRCF.HandlerTests.Support", + "HexRCF.HandlerTests.Async", + "HexRCF.HandlerTests", + "HexRCF.LintTests" + ], + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/lake-bounded", + "build", + "HexRCF", + "HexRCFRealCoefficients", + "+HexRCF.Conformance", + "+HexRCF.SourceIdentityKernel", + "+HexRCF.SourceIdentityCases", + "+HexRCF.MaximalCoefficientsKernel", + "+HexRCF.MaximalCoefficientsConformance", + "+HexRCF.MaximalCoefficients", + "+HexRCF.CellReplay.AssembledKernel", + "+HexRCF.CellReplay.Assembled", + "+HexRCF.CellReplay.OperationsPublic", + "+HexRCF.CellReplay.OperationsKernel", + "+HexRCF.CellReplay.Operations", + "+HexRCF.CellReplay.Algebraic.Emit", + "+HexRCF.CellReplay.Algebraic.MutationData0", + "+HexRCF.CellReplay.Algebraic.Mutations", + "+HexRCF.CellReplay.Algebraic.Refusals", + "+HexRCF.CellReplay.Algebraic.Guards", + "+HexRCF.CellReplay.Algebraic.Meaning", + "+HexRCF.CellReplay.Algebraic.Boolean", + "+HexRCF.CellReplay.Algebraic.BooleanSources", + "+HexRCF.CellReplay.Algebraic.BooleanBinding", + "+HexRCF.CellReplay.Algebraic.BooleanQuoted", + "+HexRCF.CellBuildConformance", + "+HexRCF.CellDiscoverLinear", + "+HexRCF.CellDiscoverAlgebraic", + "+HexRCF.CellDiscoverCases", + "+HexRCF.CellDiscoverProofs", + "+HexRCF.CellRequestedConformance", + "+HexRCF.CellDecisionProofs", + "+HexRCF.CellCodecProofs", + "+HexRCF.CellExecutionProofs", + "+HexRCF.NumberFieldCellsConformance", + "+HexRCF.GatherCellsConformance", + "+HexRCF.RealModelConformance", + "+HexRCF.AlgebraicPreparationCases", + "+HexRCF.AlgebraicPreparationConformance", + "+HexRCF.SourceAcceptancePublic", + "+HexRCF.AlgebraicCellsConformance", + "+HexRCF.CellReplay.Algebraic.Canonical", + "+HexRCF.CellReplay.Algebraic.Check", + "+HexRCF.CellReplay.Algebraic.Convert", + "+HexRCF.CellReplay.Algebraic.Inputs", + "+HexRCF.CellReplay.Algebraic.LiteralData0", + "+HexRCF.CellReplay.Algebraic.LiteralData1", + "+HexRCF.CellReplay.Algebraic.Literals", + "+HexRCF.CellReplay.Algebraic.Quote", + "+HexRCF.CellReplay.Algebraic.Quoted", + "+HexRCF.CellReplay.Algebraic.CompleteQuote", + "+HexRCF.CellReplay.Algebraic.CompleteQuoted", + "+HexRCF.CellReplay.Algebraic.Radical", + "+HexRCF.CellReplay.Algebraic.Read", + "+HexRCF.CellReplay.Algebraic.Records", + "+HexRCF.CellReplay.Algebraic.ScalarData0", + "+HexRCF.CellReplay.Algebraic.ScalarData1", + "+HexRCF.CellReplay.Algebraic.Scalars", + "+HexRCF.CellReplay.Algebraic.Schema", + "+HexRCF.CellReplay.Algebraic.Sections", + "+HexRCF.RealFormulaConformance", + "+HexRCF.RealCoefficientsConformance", + "+HexRCF.AlgebraicProgress", + "+HexRCF.IsolationProgress", + "+HexRCF.RadicalProgress", + "+HexRCF.ProductionProgress", + "+HexRCF.FieldRootsConformance", + "+HexRCF.CertificationInputs", + "+HexRCF.RationalSources", + "+HexRCF.ProofEvidence", + "+HexRCF.CheckedConversions", + "+HexRCF.ReplayModes", + "+HexRCF.CarrierModes", + "+HexRCF.SignIndex", + "+HexRCF.PreparedCoefficients", + "+HexRCF.FiniteReplay", + "+HexRCF.FiniteSignsConformance", + "+HexRCF.CellReplay.OutsideLiterals", + "+HexRCF.CellReplay.Zero", + "+HexRCF.CellReplay.ZeroLiterals", + "+HexRCF.CellReplay.Valuation", + "+HexRCF.CellReplay.ModuleCheck", + "+HexRCF.CellReplay.Schema", + "+HexRCF.CellReplay.Check", + "+HexRCF.CellReplay.Ordinary", + "+HexRCF.CellReplay.Quote", + "+HexRCF.CellReplay.Controls", + "+HexRCF.CellReplay.Quoted", + "+HexRCF.CellReplay.Refusals", + "+HexRCF.CellReplay.Emit", + "+HexRCF.CellReplay.LiteralData0", + "+HexRCF.CellReplay.Literals", + "+HexRCF.CellReplay.MutationData0", + "+HexRCF.CellReplay.Mutations", + "+HexRCF.FiniteMatrix.Binding", + "+HexRCF.FiniteMatrix.Guards.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "+HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "+HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "+HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "+HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "+HexRCF.FiniteMatrix.Guards.Quotient.Records", + "+HexRCF.FiniteMatrix.Guards.Quotient.Source", + "+HexRCF.FiniteMatrix.Guards.Controls", + "+HexRCF.FiniteMatrix.Guards.Data", + "+HexRCF.FiniteMatrix.Guards.Domains", + "+HexRCF.FiniteMatrix.Guards.Emit", + "+HexRCF.FiniteMatrix.Guards.LiteralData0", + "+HexRCF.FiniteMatrix.Guards.Literals", + "+HexRCF.FiniteMatrix.Guards.Meaning", + "+HexRCF.FiniteMatrix.Guards.MutationData0", + "+HexRCF.FiniteMatrix.Guards.Mutations", + "+HexRCF.FiniteMatrix.Guards.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quote", + "+HexRCF.FiniteMatrix.Guards.Read", + "+HexRCF.FiniteMatrix.Guards.Records", + "+HexRCF.FiniteMatrix.Guards.Refusals", + "+HexRCF.FiniteMatrix.Guards.Schema", + "+HexRCF.FiniteMatrix.Data", + "+HexRCF.FiniteMatrix.Emit", + "+HexRCF.FiniteMatrix.Inputs", + "+HexRCF.FiniteMatrix.KernelControls", + "+HexRCF.FiniteMatrix.LiteralData0", + "+HexRCF.FiniteMatrix.LiteralData1", + "+HexRCF.FiniteMatrix.LiteralData2", + "+HexRCF.FiniteMatrix.LiteralData3", + "+HexRCF.FiniteMatrix.LiteralData4", + "+HexRCF.FiniteMatrix.LiteralData5", + "+HexRCF.FiniteMatrix.Literals", + "+HexRCF.FiniteMatrix.ModuleCheck", + "+HexRCF.FiniteMatrix.Ordinary", + "+HexRCF.FiniteMatrix.Packings", + "+HexRCF.FiniteMatrix.Quote", + "+HexRCF.FiniteMatrix.Controls", + "+HexRCF.FiniteMatrix.Refusals", + "+HexRCF.FiniteMatrix.Read", + "+HexRCF.FiniteMatrix.Restore", + "+HexRCF.FiniteMatrix.Schema", + "+HexRCF.FiniteMatrix.Selected", + "+HexRCF.FiniteMatrix.Semantics", + "+HexRCF.FiniteMatrix.Signs", + "+HexRCF.TowerSamples", + "+HexRCF.Samples", + "+HexRCF.RealizationData", + "+HexRCF.Realization", + "+HexRCF.NumberField", + "+HexRCF.Gather", + "+HexRCF.GatherCatalog", + "+HexRCF.RegisteredGatherConformance", + "+HexRCF.GeneratorWindowInputs", + "+HexRCF.GeneratorWindow", + "+HexRCF.CertificationProofs", + "+HexRCF.SuppliedIrreducible", + "+HexRCF.SuppliedIrreducibleProofs", + "+HexRCF.SuppliedBudget", + "+HexRCF.NativeFormulaConformance", + "+HexRCF.NativeSpecializeConformance", + "+HexRCF.NativeSamplesConformance", + "+HexRCF.NativeSampleModelConformance", + "+HexRCF.NativeSampleModelLiterals", + "+HexRCF.NativeSourcesConformance", + "+HexRCF.NativeSelectionLiterals", + "+HexRCF.NativeSelectionConformance", + "+HexRCF.NativeSelectionOrdinaryConformance", + "+HexRCF.NativeSelectionOrderedConformance", + "+HexRCF.SectionReplayConformance", + "+HexRCF.SectionProduceConformance", + "+HexRCF.SectionOrdinaryConformance", + "+HexRCF.PointReplayConformance", + "+HexRCF.PointProduceConformance", + "+HexRCF.PointOrdinaryConformance", + "+HexRCF.RootReplayLiterals", + "+HexRCF.RootReplayConformance", + "+HexRCF.RootReplayOrdinaryConformance", + "+HexRCF.NestedRootLiterals", + "+HexRCF.NestedRootProduceConformance", + "+HexRCF.NestedRootOrdinaryConformance", + "+HexRCF.RootTransportData", + "+HexRCF.RootTransportLiterals", + "+HexRCF.RootTransportConformance", + "+HexRCF.RootTransportOrdinaryConformance", + "+HexRCF.NestedTransport.Frame", + "+HexRCF.NestedTransport.Context", + "+HexRCF.NestedTransport.Map", + "+HexRCF.NestedTransport.Conversion", + "+HexRCF.NestedTransport.Fields", + "+HexRCF.NestedTransport.Restore", + "+HexRCF.NestedTransport.Predecessor", + "+HexRCF.NestedTransport.Facts", + "+HexRCF.NestedTransport.Constants", + "+HexRCF.NestedTransport.Operations", + "+HexRCF.NestedTransport.RootRead", + "+HexRCF.NestedTransport.Read", + "+HexRCF.NestedTransport.Model", + "+HexRCF.NestedTransport.Source", + "+HexRCF.NestedTransport.Ordinary", + "+HexRCF.NestedTransport.Controls", + "+HexRCF.NestedTransport.Literals", + "+HexRCF.NestedTransport.EndpointLiterals", + "+HexRCF.NestedTransport.SignLiterals", + "+HexRCF.NestedTransport.SignData", + "+HexRCF.TotalAlgebraicProofs", + "+HexRCF.AlgebraicDivision", + "+HexRCF.NormalizedCoefficients", + "+HexRCF.NormalizedInputs", + "+HexRCF.RegisteredConstants", + "+HexRCF.NamedConstants", + "+HexRCF.MixedConstants", + "+HexRCF.CoarseConstants", + "+HexRCF.RealCoefficientTactic", + "+HexRCF.RealCoefficientCommonField", + "+HexRCF.CommonFieldPresentation", + "+HexRCF.RootAliasesConformance", + "+HexRCF.RationalRoots", + "+HexRCF.AlgebraicRoots", + "+HexRCF.FormulaConformance", + "+HexRCF.LiteralSignConformance", + "+HexRCF.FieldSpecializeConformance", + "+HexRCF.SignDetFieldProofs", + "+HexRCF.AdmissionConformance", + "+HexRCF.IsolationConformance", + "+HexRCF.SelectedRoot.Packing", + "+HexRCF.SelectedRoot.PackingData", + "+HexRCF.SelectedRoot.InverseData", + "+HexRCF.SelectedRoot.InverseReplay", + "+HexRCF.SelectedRoot.InverseControls", + "+HexRCF.InverseFixture", + "+HexRCF.SelectedRoot.PackingReplay", + "+HexRCF.SelectedRoot.PackingMissing", + "+HexRCF.SelectedRoot.PackingAudit", + "+HexRCF.SelectedRoot.CatalogData", + "+HexRCF.SelectedRoot.CatalogByteData", + "+HexRCF.SelectedRoot.CatalogSource", + "+HexRCF.SelectedRoot.Catalog", + "+HexRCF.SelectedRoot.CatalogBytes", + "+HexRCF.SelectedRoot.CatalogControls", + "+HexRCF.SelectedRoot.CatalogAudit", + "+HexRCF.SelectedRoot.ByteAudit", + "+HexRCF.SelectedRoot.ByteBounds", + "+HexRCF.SelectedRoot.ByteChecks", + "+HexRCF.SelectedRoot.ByteData", + "+HexRCF.SelectedRoot.ByteProofs", + "+HexRCF.SelectedRoot.Audit", + "+HexRCF.SelectedRoot.Checks", + "+HexRCF.SelectedRoot.Collect", + "+HexRCF.SelectedRoot.Controls", + "+HexRCF.SelectedRoot.Data", + "+HexRCF.SelectedRoot.Frozen", + "+HexRCF.SelectedRoot.FrozenCollect", + "+HexRCF.SelectedRoot.KernelCheck", + "+HexRCF.SelectedRoot.Intermediates", + "+HexRCF.SelectedRoot.Literals", + "+HexRCF.SelectedRoot.PacketFields", + "+HexRCF.SelectedRoot.Packets", + "+HexRCF.SelectedRoot.Proofs", + "+HexRCF.SelectedRoot.Read", + "+HexRCF.SelectedRoot.Refusals", + "+HexRCF.SelectedRoot.ReplayTools", + "+HexRCF.SelectedRoot.Row", + "+HexRCF.SelectedRoot.RowCollect", + "+HexRCF.SelectedRoot.RowIntermediates", + "+HexRCF.SelectedRoot.RowTools", + "+HexRCF.SelectedRoot.Source", + "+HexRCF.SelectedRoot.Upper", + "+HexRCF.PublicGraphCodec", + "+HexRCF.LanguageTests", + "+HexRCF.SturmBuilderTests", + "+HexRCF.CarrierTests", + "+HexRCF.IsolationsTests", + "+HexRCF.SeparationTests", + "+HexRCF.CellsTests", + "+HexRCF.CommonRootTests", + "+HexRCF.SignMatrixTests", + "+HexRCF.BuilderTests", + "+HexRCF.CertificateTests", + "+HexRCF.DecisionTests", + "+HexRCF.ReifyTests", + "+HexRCF.HandlerTests.Support", + "+HexRCF.HandlerTests.Async", + "+HexRCF.HandlerTests", + "+HexRCF.LintTests", + "HexRCFProofProbe", + "HexManual" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "scope": "All 263 actual HexRCF HexConformance roots, all 16 base HexReleaseTests roots, both libraries, registered-constant proof probes and full manual." +} diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-audit-import-1.log.gz b/reports/data/hexrcf-source-acceptance/source-acceptance-audit-import-1.log.gz new file mode 100644 index 0000000000..8e0bb5e94f Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-audit-import-1.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-browser-3.log.gz b/reports/data/hexrcf-source-acceptance/source-acceptance-browser-3.log.gz new file mode 100644 index 0000000000..3c4822457d Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-browser-3.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-browser.mjs b/reports/data/hexrcf-source-acceptance/source-acceptance-browser.mjs new file mode 100644 index 0000000000..e4cddba948 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/source-acceptance-browser.mjs @@ -0,0 +1,50 @@ +import fs from 'node:fs'; +import {spawn} from 'node:child_process'; +const root=process.argv[2]; +if(!root) throw new Error('Pass the scratch render directory'); +const profile=root+'/source-acceptance-profile'; +fs.mkdirSync(profile,{recursive:true}); +fs.rmSync(profile+'/DevToolsActivePort',{force:true}); +const chrome=spawn(process.env.CHROME_BIN || '/home/kim/.cache/ms-playwright/chromium-1243/chrome-linux64/chrome',[ + '--headless=new','--no-sandbox','--disable-gpu','--allow-file-access-from-files', + '--remote-debugging-port=0','--remote-allow-origins=*','--user-data-dir='+profile,'about:blank'], + {env:{...process.env,LD_LIBRARY_PATH:fs.readFileSync(root+'/browser-lib-paths.txt','utf8').trim()},stdio:'ignore'}); +let socket; +try { + const portFile=profile+'/DevToolsActivePort'; + for(let i=0;!fs.existsSync(portFile);i++) { + if(i>200||chrome.exitCode!==null) throw new Error('Chrome did not expose CDP'); + await new Promise(r=>setTimeout(r,100)); + } + const port=fs.readFileSync(portFile,'utf8').split('\n')[0]; + const tabs=await (await fetch('http://127.0.0.1:'+port+'/json')).json(); + socket=new WebSocket(tabs.find(t=>t.type==='page').webSocketDebuggerUrl); + await new Promise((r,j)=>{socket.onopen=r;socket.onerror=j}); + let sequence=0;const pending=new Map();let loaded; + socket.onmessage=e=>{ + const msg=JSON.parse(e.data); + if(msg.id){const p=pending.get(msg.id);pending.delete(msg.id);msg.error?p.reject(msg.error):p.resolve(msg.result);} + if(msg.method==='Page.loadEventFired'&&loaded){loaded();loaded=undefined;} + }; + const call=(method,params={})=>new Promise((resolve,reject)=>{const id=++sequence;pending.set(id,{resolve,reject});socket.send(JSON.stringify({id,method,params}));}); + await call('Page.enable'); + const load=new Promise(r=>loaded=r); + await call('Page.navigate',{url:'file://'+root+'/source-acceptance-html/html-single/index.html'}); + await load; + const evaluate=async expression=>{const r=await call('Runtime.evaluate',{expression,returnByValue:true});if(r.exceptionDetails)throw new Error(JSON.stringify(r.exceptionDetails));return r.result.value;}; + const metadata=[]; + for(const [label,width] of [['desktop',1440],['narrow',390]]) { + await call('Emulation.setDeviceMetricsOverride',{width,height:1000,deviceScaleFactor:1,mobile:false}); + for(const [kind,phrase] of [['equivalence','For the retained algebraic expressions,'],['example','no successful child calculation is assumed.'],['boundary','This proof uses the checked algebraic expressions']] ) { + const exact=await evaluate(`(() => {const p=Array.from(document.querySelectorAll('p')).find(e=>e.textContent.includes(${JSON.stringify(phrase)}));if(!p)throw new Error('missing paragraph');const target=${JSON.stringify(kind)}==='example'?p.nextElementSibling:p;if(${JSON.stringify(kind)}==='example'&&!target.matches('.hl.lean.block, pre, div:has(code)'))throw new Error('target is not a Lean code block');target.scrollIntoView({block:${JSON.stringify('center')}});return {text:p.textContent,viewport:innerWidth,scrollY,paragraphWidth:p.getBoundingClientRect().width,scrollWidth:p.scrollWidth,targetTag:target.tagName,targetWidth:target.getBoundingClientRect().width,targetScrollWidth:target.scrollWidth,descendantOverflow:Math.max(0,...[target,...target.querySelectorAll('*')].map(e=>e.scrollWidth-e.clientWidth)),overflowElements:[target,...target.querySelectorAll('*')].filter(e=>e.scrollWidth-e.clientWidth>1).map(e=>({tag:e.tagName,classes:e.className,width:e.clientWidth,scroll:e.scrollWidth,text:e.textContent.slice(0,100)})).slice(0,8)};})()`); + if(!exact)throw new Error('missing visual target '+kind); + await evaluate('new Promise(resolve=>requestAnimationFrame(()=>requestAnimationFrame(resolve)))'); + const shot=await call('Page.captureScreenshot',{format:'png'}); + fs.writeFileSync(root+'/'+'source-acceptance-'+label+'-'+kind+'.png',Buffer.from(shot.data,'base64')); + metadata.push({label,kind,...exact}); + } + } + fs.writeFileSync(root+'/source-acceptance-inspection.json',JSON.stringify(metadata,null,2)); + if(metadata.some(e=>e.targetScrollWidth>e.targetWidth+1 || e.descendantOverflow>1)) throw new Error('Changed content overflows; retained captures and metrics identify the affected block.'); + process.stdout.write('Saved source acceptance desktop/narrow screenshots\n'); +} finally {if(socket)socket.close();chrome.kill('SIGTERM');} diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-consumer-review-10.log.gz b/reports/data/hexrcf-source-acceptance/source-acceptance-consumer-review-10.log.gz new file mode 100644 index 0000000000..0131da6b74 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-consumer-review-10.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-copyright-4.log b/reports/data/hexrcf-source-acceptance/source-acceptance-copyright-4.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-dag-4.log b/reports/data/hexrcf-source-acceptance/source-acceptance-dag-4.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-desktop-boundary.png b/reports/data/hexrcf-source-acceptance/source-acceptance-desktop-boundary.png new file mode 100644 index 0000000000..b40354e823 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-desktop-boundary.png differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-desktop-equivalence.png b/reports/data/hexrcf-source-acceptance/source-acceptance-desktop-equivalence.png new file mode 100644 index 0000000000..4429292c0d Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-desktop-equivalence.png differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-desktop-example.png b/reports/data/hexrcf-source-acceptance/source-acceptance-desktop-example.png new file mode 100644 index 0000000000..a012fa90f6 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-desktop-example.png differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-inspection.json b/reports/data/hexrcf-source-acceptance/source-acceptance-inspection.json new file mode 100644 index 0000000000..8a4199a20e --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/source-acceptance-inspection.json @@ -0,0 +1,86 @@ +[ + { + "label": "desktop", + "kind": "equivalence", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 1440, + "scrollY": 272671, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "P", + "targetWidth": 752, + "targetScrollWidth": 752, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "desktop", + "kind": "example", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 1440, + "scrollY": 273072, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "CODE", + "targetWidth": 740, + "targetScrollWidth": 740, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "desktop", + "kind": "boundary", + "text": "\n This proof uses the checked algebraic expressions and their source identities.\nIt does not identify separately computed proposals with frozen literals,\nreconstruct provider histories, or add a tactic handler. Those authentication\nand quotation obligations remain separate. The helper continues the same\naggregate reflection budget, returns its updated usage for later stages, and\nrestores caller state on exhaustion or failure.\nFresh importing regressions check its actual theorem bodies, true and false\nsources, retained zero guards and reversed intervals, with exactly the standard\nthree axioms.", + "viewport": 1440, + "scrollY": 273473, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "P", + "targetWidth": 752, + "targetScrollWidth": 752, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "equivalence", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 390, + "scrollY": 436826, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "P", + "targetWidth": 343, + "targetScrollWidth": 343, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "example", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 390, + "scrollY": 437320, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "CODE", + "targetWidth": 331, + "targetScrollWidth": 331, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "boundary", + "text": "\n This proof uses the checked algebraic expressions and their source identities.\nIt does not identify separately computed proposals with frozen literals,\nreconstruct provider histories, or add a tactic handler. Those authentication\nand quotation obligations remain separate. The helper continues the same\naggregate reflection budget, returns its updated usage for later stages, and\nrestores caller state on exhaustion or failure.\nFresh importing regressions check its actual theorem bodies, true and false\nsources, retained zero guards and reversed intervals, with exactly the standard\nthree axioms.", + "viewport": 390, + "scrollY": 437814, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "P", + "targetWidth": 343, + "targetScrollWidth": 343, + "descendantOverflow": 0, + "overflowElements": [] + } +] \ No newline at end of file diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-lines-4.log b/reports/data/hexrcf-source-acceptance/source-acceptance-lines-4.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-manual-2.log.gz b/reports/data/hexrcf-source-acceptance/source-acceptance-manual-2.log.gz new file mode 100644 index 0000000000..34156ceabb Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-manual-2.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-manual-naming-1.log.gz b/reports/data/hexrcf-source-acceptance/source-acceptance-manual-naming-1.log.gz new file mode 100644 index 0000000000..2c2870c56c Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-manual-naming-1.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-manual-narrow-2.log.gz b/reports/data/hexrcf-source-acceptance/source-acceptance-manual-narrow-2.log.gz new file mode 100644 index 0000000000..fdaaf2009e Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-manual-narrow-2.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-narrow-boundary.png b/reports/data/hexrcf-source-acceptance/source-acceptance-narrow-boundary.png new file mode 100644 index 0000000000..2a8924c74a Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-narrow-boundary.png differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-narrow-equivalence.png b/reports/data/hexrcf-source-acceptance/source-acceptance-narrow-equivalence.png new file mode 100644 index 0000000000..99403db6db Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-narrow-equivalence.png differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-narrow-example.png b/reports/data/hexrcf-source-acceptance/source-acceptance-narrow-example.png new file mode 100644 index 0000000000..5fda8839b5 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-narrow-example.png differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-overflow-inspection.json b/reports/data/hexrcf-source-acceptance/source-acceptance-overflow-inspection.json new file mode 100644 index 0000000000..2eba51efdc --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/source-acceptance-overflow-inspection.json @@ -0,0 +1,94 @@ +[ + { + "label": "desktop", + "kind": "equivalence", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 1440, + "scrollY": 272671, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "P", + "targetWidth": 752, + "targetScrollWidth": 752, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "desktop", + "kind": "example", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 1440, + "scrollY": 272958, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "CODE", + "targetWidth": 740, + "targetScrollWidth": 740, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "desktop", + "kind": "boundary", + "text": "\n This proof uses the checked algebraic expressions and their source identities.\nIt does not identify separately computed proposals with frozen literals,\nreconstruct provider histories, or add a tactic handler. Those authentication\nand quotation obligations remain separate. The helper continues the same\naggregate reflection budget, returns its updated usage for later stages, and\nrestores caller state on exhaustion or failure.\nFresh importing regressions check its actual theorem bodies, true and false\nsources, retained zero guards and reversed intervals, with exactly the standard\nthree axioms.", + "viewport": 1440, + "scrollY": 273245, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "P", + "targetWidth": 752, + "targetScrollWidth": 752, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "equivalence", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 390, + "scrollY": 436826, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "P", + "targetWidth": 343, + "targetScrollWidth": 343, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "example", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 390, + "scrollY": 437213, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "CODE", + "targetWidth": 331, + "targetScrollWidth": 483, + "descendantOverflow": 152, + "overflowElements": [ + { + "tag": "CODE", + "classes": "hl lean block", + "width": 331, + "scroll": 483, + "text": "open Hex Lean Meta Qq\nopen Hex.RCF.RealCoefficients\nrun_meta do\n let target : Q(Prop) :=\n q(∀ x " + } + ] + }, + { + "label": "narrow", + "kind": "boundary", + "text": "\n This proof uses the checked algebraic expressions and their source identities.\nIt does not identify separately computed proposals with frozen literals,\nreconstruct provider histories, or add a tactic handler. Those authentication\nand quotation obligations remain separate. The helper continues the same\naggregate reflection budget, returns its updated usage for later stages, and\nrestores caller state on exhaustion or failure.\nFresh importing regressions check its actual theorem bodies, true and false\nsources, retained zero guards and reversed intervals, with exactly the standard\nthree axioms.", + "viewport": 390, + "scrollY": 437601, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "P", + "targetWidth": 343, + "targetScrollWidth": 343, + "descendantOverflow": 0, + "overflowElements": [] + } +] \ No newline at end of file diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-render-1.log.gz b/reports/data/hexrcf-source-acceptance/source-acceptance-render-1.log.gz new file mode 100644 index 0000000000..65f16b36d6 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-render-1.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-render-3.log.gz b/reports/data/hexrcf-source-acceptance/source-acceptance-render-3.log.gz new file mode 100644 index 0000000000..cca7ce3455 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-acceptance-render-3.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/source-acceptance-viewed.json b/reports/data/hexrcf-source-acceptance/source-acceptance-viewed.json new file mode 100644 index 0000000000..19470f518d --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/source-acceptance-viewed.json @@ -0,0 +1,29 @@ +{ + "opened_images": [ + { + "file": "source-acceptance-desktop-equivalence.png", + "sha256": "ab908b0f7750cd0dd7b2c19b7524b4e25d55195392a02faa8ec7a4f0d6421d96" + }, + { + "file": "source-acceptance-desktop-example.png", + "sha256": "7b92d6b08398fc1a6cafac43d5e2685ba4fcf2c1b6ac645439f7ff54f8f20358" + }, + { + "file": "source-acceptance-desktop-boundary.png", + "sha256": "8bea2d8b09f2eafccad229a7a521694697fd434601c80a2d8b857ed569a6095e" + }, + { + "file": "source-acceptance-narrow-equivalence.png", + "sha256": "23ea2c920fd93f200e5212e1507f76c0f07025e8d1c4cde7790748b2c4ef8bc9" + }, + { + "file": "source-acceptance-narrow-example.png", + "sha256": "a96343e32d592909b6033808d3fbc0a83fff97948cd634d8040a58de6100f0f6" + }, + { + "file": "source-acceptance-narrow-boundary.png", + "sha256": "cc21ac16dbc75a1522bdeade9a1b7f0ac33df8e9d42b6d35c72a9231b190a25e" + } + ], + "scope": "All six actual captures opened after the final 25c5f7afac render; changed content only. Historical whole-book horizontal overflow is outside this check." +} diff --git a/reports/data/hexrcf-source-acceptance/source-retention-budget-consumers-1.log.gz b/reports/data/hexrcf-source-acceptance/source-retention-budget-consumers-1.log.gz new file mode 100644 index 0000000000..f84c55c883 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/source-retention-budget-consumers-1.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/validation/opened.json b/reports/data/hexrcf-source-acceptance/validation/opened.json new file mode 100644 index 0000000000..5cde550366 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/opened.json @@ -0,0 +1,20 @@ +{ + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "images": [ + "source-acceptance-desktop-equivalence.png", + "source-acceptance-narrow-equivalence.png", + "source-acceptance-desktop-example.png", + "source-acceptance-narrow-example.png", + "source-acceptance-desktop-boundary.png", + "source-acceptance-narrow-boundary.png" + ], + "sha256": { + "source-acceptance-desktop-equivalence.png": "5c0e6a00eb5918f0fccad1d3a4e2f96d179299887ce812413755edd45e480b52", + "source-acceptance-narrow-equivalence.png": "20ded47220d18e6cb1c96cf152a0855dc47e0d6c5b516023118923b5fa402fd0", + "source-acceptance-desktop-example.png": "5467f0cb1948fde97d276091aa2e645ae5e57665ecefce8c27457621f2a7cf2e", + "source-acceptance-narrow-example.png": "c217ebb80a47c3495064773185660db3e8493c1ad8bd38e27eda0837c1b00f84", + "source-acceptance-desktop-boundary.png": "93f9f6e3d5a70ed9c1b751701866b5a635e014f4f9138ceed3ad7e2b52d46e70", + "source-acceptance-narrow-boundary.png": "b4451859408878ac2e593929484cc4ccd8a1e24cc887d094372dbdb7862eeb78" + }, + "inspection": "All six images opened with view_image. Acceptance paragraph, entire runnable example, and limitation/usage paragraph remain readable at1440 and390 pixels; their local overflow metrics are zero. Existing horizontal overflow elsewhere in the full book is excluded." +} diff --git a/reports/data/hexrcf-source-acceptance/validation/record.json b/reports/data/hexrcf-source-acceptance/validation/record.json new file mode 100644 index 0000000000..993cfd40f6 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/record.json @@ -0,0 +1,1269 @@ +{ + "scope": "Original guard inventory and source-budget/recursion validation; historical records remain separate. No frozen-proposal authentication or full issue completion claim.", + "full_selection": { + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "source_tree": "39df2d90a2e4ce6615c591040eeb953c0d1f4e84", + "rcf_conformance_roots": [ + "HexRCF.Conformance", + "HexRCF.SourceIdentityKernel", + "HexRCF.SourceIdentityCases", + "HexRCF.MaximalCoefficientsKernel", + "HexRCF.MaximalCoefficientsConformance", + "HexRCF.MaximalCoefficients", + "HexRCF.CellReplay.AssembledKernel", + "HexRCF.CellReplay.Assembled", + "HexRCF.CellReplay.OperationsPublic", + "HexRCF.CellReplay.OperationsKernel", + "HexRCF.CellReplay.Operations", + "HexRCF.CellReplay.Algebraic.Emit", + "HexRCF.CellReplay.Algebraic.MutationData0", + "HexRCF.CellReplay.Algebraic.Mutations", + "HexRCF.CellReplay.Algebraic.Refusals", + "HexRCF.CellReplay.Algebraic.Guards", + "HexRCF.CellReplay.Algebraic.Meaning", + "HexRCF.CellReplay.Algebraic.Boolean", + "HexRCF.CellReplay.Algebraic.BooleanSources", + "HexRCF.CellReplay.Algebraic.BooleanBinding", + "HexRCF.CellReplay.Algebraic.BooleanQuoted", + "HexRCF.CellBuildConformance", + "HexRCF.CellDiscoverLinear", + "HexRCF.CellDiscoverAlgebraic", + "HexRCF.CellDiscoverCases", + "HexRCF.CellDiscoverProofs", + "HexRCF.CellRequestedConformance", + "HexRCF.CellDecisionProofs", + "HexRCF.CellCodecProofs", + "HexRCF.CellExecutionProofs", + "HexRCF.NumberFieldCellsConformance", + "HexRCF.GatherCellsConformance", + "HexRCF.RealModelConformance", + "HexRCF.AlgebraicPreparationCases", + "HexRCF.AlgebraicPreparationConformance", + "HexRCF.SourceAcceptancePublic", + "HexRCF.AlgebraicCellsConformance", + "HexRCF.CellReplay.Algebraic.Canonical", + "HexRCF.CellReplay.Algebraic.Check", + "HexRCF.CellReplay.Algebraic.Convert", + "HexRCF.CellReplay.Algebraic.Inputs", + "HexRCF.CellReplay.Algebraic.LiteralData0", + "HexRCF.CellReplay.Algebraic.LiteralData1", + "HexRCF.CellReplay.Algebraic.Literals", + "HexRCF.CellReplay.Algebraic.Quote", + "HexRCF.CellReplay.Algebraic.Quoted", + "HexRCF.CellReplay.Algebraic.CompleteQuote", + "HexRCF.CellReplay.Algebraic.CompleteQuoted", + "HexRCF.CellReplay.Algebraic.Radical", + "HexRCF.CellReplay.Algebraic.Read", + "HexRCF.CellReplay.Algebraic.Records", + "HexRCF.CellReplay.Algebraic.ScalarData0", + "HexRCF.CellReplay.Algebraic.ScalarData1", + "HexRCF.CellReplay.Algebraic.Scalars", + "HexRCF.CellReplay.Algebraic.Schema", + "HexRCF.CellReplay.Algebraic.Sections", + "HexRCF.RealFormulaConformance", + "HexRCF.RealCoefficientsConformance", + "HexRCF.AlgebraicProgress", + "HexRCF.IsolationProgress", + "HexRCF.RadicalProgress", + "HexRCF.ProductionProgress", + "HexRCF.FieldRootsConformance", + "HexRCF.CertificationInputs", + "HexRCF.RationalSources", + "HexRCF.ProofEvidence", + "HexRCF.CheckedConversions", + "HexRCF.ReplayModes", + "HexRCF.CarrierModes", + "HexRCF.SignIndex", + "HexRCF.PreparedCoefficients", + "HexRCF.FiniteReplay", + "HexRCF.FiniteSignsConformance", + "HexRCF.CellReplay.OutsideLiterals", + "HexRCF.CellReplay.Zero", + "HexRCF.CellReplay.ZeroLiterals", + "HexRCF.CellReplay.Valuation", + "HexRCF.CellReplay.ModuleCheck", + "HexRCF.CellReplay.Schema", + "HexRCF.CellReplay.Check", + "HexRCF.CellReplay.Ordinary", + "HexRCF.CellReplay.Quote", + "HexRCF.CellReplay.Controls", + "HexRCF.CellReplay.Quoted", + "HexRCF.CellReplay.Refusals", + "HexRCF.CellReplay.Emit", + "HexRCF.CellReplay.LiteralData0", + "HexRCF.CellReplay.Literals", + "HexRCF.CellReplay.MutationData0", + "HexRCF.CellReplay.Mutations", + "HexRCF.FiniteMatrix.Binding", + "HexRCF.FiniteMatrix.Guards.Binding", + "HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "HexRCF.FiniteMatrix.Guards.Quotient.Records", + "HexRCF.FiniteMatrix.Guards.Quotient.Source", + "HexRCF.FiniteMatrix.Guards.Controls", + "HexRCF.FiniteMatrix.Guards.Data", + "HexRCF.FiniteMatrix.Guards.Domains", + "HexRCF.FiniteMatrix.Guards.Emit", + "HexRCF.FiniteMatrix.Guards.LiteralData0", + "HexRCF.FiniteMatrix.Guards.Literals", + "HexRCF.FiniteMatrix.Guards.Meaning", + "HexRCF.FiniteMatrix.Guards.MutationData0", + "HexRCF.FiniteMatrix.Guards.Mutations", + "HexRCF.FiniteMatrix.Guards.Ordinary", + "HexRCF.FiniteMatrix.Guards.Quote", + "HexRCF.FiniteMatrix.Guards.Read", + "HexRCF.FiniteMatrix.Guards.Records", + "HexRCF.FiniteMatrix.Guards.Refusals", + "HexRCF.FiniteMatrix.Guards.Schema", + "HexRCF.FiniteMatrix.Data", + "HexRCF.FiniteMatrix.Emit", + "HexRCF.FiniteMatrix.Inputs", + "HexRCF.FiniteMatrix.KernelControls", + "HexRCF.FiniteMatrix.LiteralData0", + "HexRCF.FiniteMatrix.LiteralData1", + "HexRCF.FiniteMatrix.LiteralData2", + "HexRCF.FiniteMatrix.LiteralData3", + "HexRCF.FiniteMatrix.LiteralData4", + "HexRCF.FiniteMatrix.LiteralData5", + "HexRCF.FiniteMatrix.Literals", + "HexRCF.FiniteMatrix.ModuleCheck", + "HexRCF.FiniteMatrix.Ordinary", + "HexRCF.FiniteMatrix.Packings", + "HexRCF.FiniteMatrix.Quote", + "HexRCF.FiniteMatrix.Controls", + "HexRCF.FiniteMatrix.Refusals", + "HexRCF.FiniteMatrix.Read", + "HexRCF.FiniteMatrix.Restore", + "HexRCF.FiniteMatrix.Schema", + "HexRCF.FiniteMatrix.Selected", + "HexRCF.FiniteMatrix.Semantics", + "HexRCF.FiniteMatrix.Signs", + "HexRCF.TowerSamples", + "HexRCF.Samples", + "HexRCF.RealizationData", + "HexRCF.Realization", + "HexRCF.NumberField", + "HexRCF.Gather", + "HexRCF.GatherCatalog", + "HexRCF.RegisteredGatherConformance", + "HexRCF.GeneratorWindowInputs", + "HexRCF.GeneratorWindow", + "HexRCF.CertificationProofs", + "HexRCF.SuppliedIrreducible", + "HexRCF.SuppliedIrreducibleProofs", + "HexRCF.SuppliedBudget", + "HexRCF.NativeFormulaConformance", + "HexRCF.NativeSpecializeConformance", + "HexRCF.NativeSamplesConformance", + "HexRCF.NativeSampleModelConformance", + "HexRCF.NativeSampleModelLiterals", + "HexRCF.NativeSourcesConformance", + "HexRCF.NativeSelectionLiterals", + "HexRCF.NativeSelectionConformance", + "HexRCF.NativeSelectionOrdinaryConformance", + "HexRCF.NativeSelectionOrderedConformance", + "HexRCF.SectionReplayConformance", + "HexRCF.SectionProduceConformance", + "HexRCF.SectionOrdinaryConformance", + "HexRCF.PointReplayConformance", + "HexRCF.PointProduceConformance", + "HexRCF.PointOrdinaryConformance", + "HexRCF.RootReplayLiterals", + "HexRCF.RootReplayConformance", + "HexRCF.RootReplayOrdinaryConformance", + "HexRCF.NestedRootLiterals", + "HexRCF.NestedRootProduceConformance", + "HexRCF.NestedRootOrdinaryConformance", + "HexRCF.RootTransportData", + "HexRCF.RootTransportLiterals", + "HexRCF.RootTransportConformance", + "HexRCF.RootTransportOrdinaryConformance", + "HexRCF.NestedTransport.Frame", + "HexRCF.NestedTransport.Context", + "HexRCF.NestedTransport.Map", + "HexRCF.NestedTransport.Conversion", + "HexRCF.NestedTransport.Fields", + "HexRCF.NestedTransport.Restore", + "HexRCF.NestedTransport.Predecessor", + "HexRCF.NestedTransport.Facts", + "HexRCF.NestedTransport.Constants", + "HexRCF.NestedTransport.Operations", + "HexRCF.NestedTransport.RootRead", + "HexRCF.NestedTransport.Read", + "HexRCF.NestedTransport.Model", + "HexRCF.NestedTransport.Source", + "HexRCF.NestedTransport.Ordinary", + "HexRCF.NestedTransport.Controls", + "HexRCF.NestedTransport.Literals", + "HexRCF.NestedTransport.EndpointLiterals", + "HexRCF.NestedTransport.SignLiterals", + "HexRCF.NestedTransport.SignData", + "HexRCF.TotalAlgebraicProofs", + "HexRCF.AlgebraicDivision", + "HexRCF.NormalizedCoefficients", + "HexRCF.NormalizedInputs", + "HexRCF.RegisteredConstants", + "HexRCF.NamedConstants", + "HexRCF.MixedConstants", + "HexRCF.CoarseConstants", + "HexRCF.RealCoefficientTactic", + "HexRCF.RealCoefficientCommonField", + "HexRCF.CommonFieldPresentation", + "HexRCF.RootAliasesConformance", + "HexRCF.RationalRoots", + "HexRCF.AlgebraicRoots", + "HexRCF.FormulaConformance", + "HexRCF.LiteralSignConformance", + "HexRCF.FieldSpecializeConformance", + "HexRCF.SignDetFieldProofs", + "HexRCF.AdmissionConformance", + "HexRCF.IsolationConformance", + "HexRCF.SelectedRoot.Packing", + "HexRCF.SelectedRoot.PackingData", + "HexRCF.SelectedRoot.InverseData", + "HexRCF.SelectedRoot.InverseReplay", + "HexRCF.SelectedRoot.InverseControls", + "HexRCF.InverseFixture", + "HexRCF.SelectedRoot.PackingReplay", + "HexRCF.SelectedRoot.PackingMissing", + "HexRCF.SelectedRoot.PackingAudit", + "HexRCF.SelectedRoot.CatalogData", + "HexRCF.SelectedRoot.CatalogByteData", + "HexRCF.SelectedRoot.CatalogSource", + "HexRCF.SelectedRoot.Catalog", + "HexRCF.SelectedRoot.CatalogBytes", + "HexRCF.SelectedRoot.CatalogControls", + "HexRCF.SelectedRoot.CatalogAudit", + "HexRCF.SelectedRoot.ByteAudit", + "HexRCF.SelectedRoot.ByteBounds", + "HexRCF.SelectedRoot.ByteChecks", + "HexRCF.SelectedRoot.ByteData", + "HexRCF.SelectedRoot.ByteProofs", + "HexRCF.SelectedRoot.Audit", + "HexRCF.SelectedRoot.Checks", + "HexRCF.SelectedRoot.Collect", + "HexRCF.SelectedRoot.Controls", + "HexRCF.SelectedRoot.Data", + "HexRCF.SelectedRoot.Frozen", + "HexRCF.SelectedRoot.FrozenCollect", + "HexRCF.SelectedRoot.KernelCheck", + "HexRCF.SelectedRoot.Intermediates", + "HexRCF.SelectedRoot.Literals", + "HexRCF.SelectedRoot.PacketFields", + "HexRCF.SelectedRoot.Packets", + "HexRCF.SelectedRoot.Proofs", + "HexRCF.SelectedRoot.Read", + "HexRCF.SelectedRoot.Refusals", + "HexRCF.SelectedRoot.ReplayTools", + "HexRCF.SelectedRoot.Row", + "HexRCF.SelectedRoot.RowCollect", + "HexRCF.SelectedRoot.RowIntermediates", + "HexRCF.SelectedRoot.RowTools", + "HexRCF.SelectedRoot.Source", + "HexRCF.SelectedRoot.Upper", + "HexRCF.PublicGraphCodec" + ], + "base_test_roots": [ + "HexRCF.LanguageTests", + "HexRCF.SturmBuilderTests", + "HexRCF.CarrierTests", + "HexRCF.IsolationsTests", + "HexRCF.SeparationTests", + "HexRCF.CellsTests", + "HexRCF.CommonRootTests", + "HexRCF.SignMatrixTests", + "HexRCF.BuilderTests", + "HexRCF.CertificateTests", + "HexRCF.DecisionTests", + "HexRCF.ReifyTests", + "HexRCF.HandlerTests.Support", + "HexRCF.HandlerTests.Async", + "HexRCF.HandlerTests", + "HexRCF.LintTests" + ], + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/lake-bounded", + "build", + "HexRCF", + "HexRCFRealCoefficients", + "+HexRCF.Conformance", + "+HexRCF.SourceIdentityKernel", + "+HexRCF.SourceIdentityCases", + "+HexRCF.MaximalCoefficientsKernel", + "+HexRCF.MaximalCoefficientsConformance", + "+HexRCF.MaximalCoefficients", + "+HexRCF.CellReplay.AssembledKernel", + "+HexRCF.CellReplay.Assembled", + "+HexRCF.CellReplay.OperationsPublic", + "+HexRCF.CellReplay.OperationsKernel", + "+HexRCF.CellReplay.Operations", + "+HexRCF.CellReplay.Algebraic.Emit", + "+HexRCF.CellReplay.Algebraic.MutationData0", + "+HexRCF.CellReplay.Algebraic.Mutations", + "+HexRCF.CellReplay.Algebraic.Refusals", + "+HexRCF.CellReplay.Algebraic.Guards", + "+HexRCF.CellReplay.Algebraic.Meaning", + "+HexRCF.CellReplay.Algebraic.Boolean", + "+HexRCF.CellReplay.Algebraic.BooleanSources", + "+HexRCF.CellReplay.Algebraic.BooleanBinding", + "+HexRCF.CellReplay.Algebraic.BooleanQuoted", + "+HexRCF.CellBuildConformance", + "+HexRCF.CellDiscoverLinear", + "+HexRCF.CellDiscoverAlgebraic", + "+HexRCF.CellDiscoverCases", + "+HexRCF.CellDiscoverProofs", + "+HexRCF.CellRequestedConformance", + "+HexRCF.CellDecisionProofs", + "+HexRCF.CellCodecProofs", + "+HexRCF.CellExecutionProofs", + "+HexRCF.NumberFieldCellsConformance", + "+HexRCF.GatherCellsConformance", + "+HexRCF.RealModelConformance", + "+HexRCF.AlgebraicPreparationCases", + "+HexRCF.AlgebraicPreparationConformance", + "+HexRCF.SourceAcceptancePublic", + "+HexRCF.AlgebraicCellsConformance", + "+HexRCF.CellReplay.Algebraic.Canonical", + "+HexRCF.CellReplay.Algebraic.Check", + "+HexRCF.CellReplay.Algebraic.Convert", + "+HexRCF.CellReplay.Algebraic.Inputs", + "+HexRCF.CellReplay.Algebraic.LiteralData0", + "+HexRCF.CellReplay.Algebraic.LiteralData1", + "+HexRCF.CellReplay.Algebraic.Literals", + "+HexRCF.CellReplay.Algebraic.Quote", + "+HexRCF.CellReplay.Algebraic.Quoted", + "+HexRCF.CellReplay.Algebraic.CompleteQuote", + "+HexRCF.CellReplay.Algebraic.CompleteQuoted", + "+HexRCF.CellReplay.Algebraic.Radical", + "+HexRCF.CellReplay.Algebraic.Read", + "+HexRCF.CellReplay.Algebraic.Records", + "+HexRCF.CellReplay.Algebraic.ScalarData0", + "+HexRCF.CellReplay.Algebraic.ScalarData1", + "+HexRCF.CellReplay.Algebraic.Scalars", + "+HexRCF.CellReplay.Algebraic.Schema", + "+HexRCF.CellReplay.Algebraic.Sections", + "+HexRCF.RealFormulaConformance", + "+HexRCF.RealCoefficientsConformance", + "+HexRCF.AlgebraicProgress", + "+HexRCF.IsolationProgress", + "+HexRCF.RadicalProgress", + "+HexRCF.ProductionProgress", + "+HexRCF.FieldRootsConformance", + "+HexRCF.CertificationInputs", + "+HexRCF.RationalSources", + "+HexRCF.ProofEvidence", + "+HexRCF.CheckedConversions", + "+HexRCF.ReplayModes", + "+HexRCF.CarrierModes", + "+HexRCF.SignIndex", + "+HexRCF.PreparedCoefficients", + "+HexRCF.FiniteReplay", + "+HexRCF.FiniteSignsConformance", + "+HexRCF.CellReplay.OutsideLiterals", + "+HexRCF.CellReplay.Zero", + "+HexRCF.CellReplay.ZeroLiterals", + "+HexRCF.CellReplay.Valuation", + "+HexRCF.CellReplay.ModuleCheck", + "+HexRCF.CellReplay.Schema", + "+HexRCF.CellReplay.Check", + "+HexRCF.CellReplay.Ordinary", + "+HexRCF.CellReplay.Quote", + "+HexRCF.CellReplay.Controls", + "+HexRCF.CellReplay.Quoted", + "+HexRCF.CellReplay.Refusals", + "+HexRCF.CellReplay.Emit", + "+HexRCF.CellReplay.LiteralData0", + "+HexRCF.CellReplay.Literals", + "+HexRCF.CellReplay.MutationData0", + "+HexRCF.CellReplay.Mutations", + "+HexRCF.FiniteMatrix.Binding", + "+HexRCF.FiniteMatrix.Guards.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "+HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "+HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "+HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "+HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "+HexRCF.FiniteMatrix.Guards.Quotient.Records", + "+HexRCF.FiniteMatrix.Guards.Quotient.Source", + "+HexRCF.FiniteMatrix.Guards.Controls", + "+HexRCF.FiniteMatrix.Guards.Data", + "+HexRCF.FiniteMatrix.Guards.Domains", + "+HexRCF.FiniteMatrix.Guards.Emit", + "+HexRCF.FiniteMatrix.Guards.LiteralData0", + "+HexRCF.FiniteMatrix.Guards.Literals", + "+HexRCF.FiniteMatrix.Guards.Meaning", + "+HexRCF.FiniteMatrix.Guards.MutationData0", + "+HexRCF.FiniteMatrix.Guards.Mutations", + "+HexRCF.FiniteMatrix.Guards.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quote", + "+HexRCF.FiniteMatrix.Guards.Read", + "+HexRCF.FiniteMatrix.Guards.Records", + "+HexRCF.FiniteMatrix.Guards.Refusals", + "+HexRCF.FiniteMatrix.Guards.Schema", + "+HexRCF.FiniteMatrix.Data", + "+HexRCF.FiniteMatrix.Emit", + "+HexRCF.FiniteMatrix.Inputs", + "+HexRCF.FiniteMatrix.KernelControls", + "+HexRCF.FiniteMatrix.LiteralData0", + "+HexRCF.FiniteMatrix.LiteralData1", + "+HexRCF.FiniteMatrix.LiteralData2", + "+HexRCF.FiniteMatrix.LiteralData3", + "+HexRCF.FiniteMatrix.LiteralData4", + "+HexRCF.FiniteMatrix.LiteralData5", + "+HexRCF.FiniteMatrix.Literals", + "+HexRCF.FiniteMatrix.ModuleCheck", + "+HexRCF.FiniteMatrix.Ordinary", + "+HexRCF.FiniteMatrix.Packings", + "+HexRCF.FiniteMatrix.Quote", + "+HexRCF.FiniteMatrix.Controls", + "+HexRCF.FiniteMatrix.Refusals", + "+HexRCF.FiniteMatrix.Read", + "+HexRCF.FiniteMatrix.Restore", + "+HexRCF.FiniteMatrix.Schema", + "+HexRCF.FiniteMatrix.Selected", + "+HexRCF.FiniteMatrix.Semantics", + "+HexRCF.FiniteMatrix.Signs", + "+HexRCF.TowerSamples", + "+HexRCF.Samples", + "+HexRCF.RealizationData", + "+HexRCF.Realization", + "+HexRCF.NumberField", + "+HexRCF.Gather", + "+HexRCF.GatherCatalog", + "+HexRCF.RegisteredGatherConformance", + "+HexRCF.GeneratorWindowInputs", + "+HexRCF.GeneratorWindow", + "+HexRCF.CertificationProofs", + "+HexRCF.SuppliedIrreducible", + "+HexRCF.SuppliedIrreducibleProofs", + "+HexRCF.SuppliedBudget", + "+HexRCF.NativeFormulaConformance", + "+HexRCF.NativeSpecializeConformance", + "+HexRCF.NativeSamplesConformance", + "+HexRCF.NativeSampleModelConformance", + "+HexRCF.NativeSampleModelLiterals", + "+HexRCF.NativeSourcesConformance", + "+HexRCF.NativeSelectionLiterals", + "+HexRCF.NativeSelectionConformance", + "+HexRCF.NativeSelectionOrdinaryConformance", + "+HexRCF.NativeSelectionOrderedConformance", + "+HexRCF.SectionReplayConformance", + "+HexRCF.SectionProduceConformance", + "+HexRCF.SectionOrdinaryConformance", + "+HexRCF.PointReplayConformance", + "+HexRCF.PointProduceConformance", + "+HexRCF.PointOrdinaryConformance", + "+HexRCF.RootReplayLiterals", + "+HexRCF.RootReplayConformance", + "+HexRCF.RootReplayOrdinaryConformance", + "+HexRCF.NestedRootLiterals", + "+HexRCF.NestedRootProduceConformance", + "+HexRCF.NestedRootOrdinaryConformance", + "+HexRCF.RootTransportData", + "+HexRCF.RootTransportLiterals", + "+HexRCF.RootTransportConformance", + "+HexRCF.RootTransportOrdinaryConformance", + "+HexRCF.NestedTransport.Frame", + "+HexRCF.NestedTransport.Context", + "+HexRCF.NestedTransport.Map", + "+HexRCF.NestedTransport.Conversion", + "+HexRCF.NestedTransport.Fields", + "+HexRCF.NestedTransport.Restore", + "+HexRCF.NestedTransport.Predecessor", + "+HexRCF.NestedTransport.Facts", + "+HexRCF.NestedTransport.Constants", + "+HexRCF.NestedTransport.Operations", + "+HexRCF.NestedTransport.RootRead", + "+HexRCF.NestedTransport.Read", + "+HexRCF.NestedTransport.Model", + "+HexRCF.NestedTransport.Source", + "+HexRCF.NestedTransport.Ordinary", + "+HexRCF.NestedTransport.Controls", + "+HexRCF.NestedTransport.Literals", + "+HexRCF.NestedTransport.EndpointLiterals", + "+HexRCF.NestedTransport.SignLiterals", + "+HexRCF.NestedTransport.SignData", + "+HexRCF.TotalAlgebraicProofs", + "+HexRCF.AlgebraicDivision", + "+HexRCF.NormalizedCoefficients", + "+HexRCF.NormalizedInputs", + "+HexRCF.RegisteredConstants", + "+HexRCF.NamedConstants", + "+HexRCF.MixedConstants", + "+HexRCF.CoarseConstants", + "+HexRCF.RealCoefficientTactic", + "+HexRCF.RealCoefficientCommonField", + "+HexRCF.CommonFieldPresentation", + "+HexRCF.RootAliasesConformance", + "+HexRCF.RationalRoots", + "+HexRCF.AlgebraicRoots", + "+HexRCF.FormulaConformance", + "+HexRCF.LiteralSignConformance", + "+HexRCF.FieldSpecializeConformance", + "+HexRCF.SignDetFieldProofs", + "+HexRCF.AdmissionConformance", + "+HexRCF.IsolationConformance", + "+HexRCF.SelectedRoot.Packing", + "+HexRCF.SelectedRoot.PackingData", + "+HexRCF.SelectedRoot.InverseData", + "+HexRCF.SelectedRoot.InverseReplay", + "+HexRCF.SelectedRoot.InverseControls", + "+HexRCF.InverseFixture", + "+HexRCF.SelectedRoot.PackingReplay", + "+HexRCF.SelectedRoot.PackingMissing", + "+HexRCF.SelectedRoot.PackingAudit", + "+HexRCF.SelectedRoot.CatalogData", + "+HexRCF.SelectedRoot.CatalogByteData", + "+HexRCF.SelectedRoot.CatalogSource", + "+HexRCF.SelectedRoot.Catalog", + "+HexRCF.SelectedRoot.CatalogBytes", + "+HexRCF.SelectedRoot.CatalogControls", + "+HexRCF.SelectedRoot.CatalogAudit", + "+HexRCF.SelectedRoot.ByteAudit", + "+HexRCF.SelectedRoot.ByteBounds", + "+HexRCF.SelectedRoot.ByteChecks", + "+HexRCF.SelectedRoot.ByteData", + "+HexRCF.SelectedRoot.ByteProofs", + "+HexRCF.SelectedRoot.Audit", + "+HexRCF.SelectedRoot.Checks", + "+HexRCF.SelectedRoot.Collect", + "+HexRCF.SelectedRoot.Controls", + "+HexRCF.SelectedRoot.Data", + "+HexRCF.SelectedRoot.Frozen", + "+HexRCF.SelectedRoot.FrozenCollect", + "+HexRCF.SelectedRoot.KernelCheck", + "+HexRCF.SelectedRoot.Intermediates", + "+HexRCF.SelectedRoot.Literals", + "+HexRCF.SelectedRoot.PacketFields", + "+HexRCF.SelectedRoot.Packets", + "+HexRCF.SelectedRoot.Proofs", + "+HexRCF.SelectedRoot.Read", + "+HexRCF.SelectedRoot.Refusals", + "+HexRCF.SelectedRoot.ReplayTools", + "+HexRCF.SelectedRoot.Row", + "+HexRCF.SelectedRoot.RowCollect", + "+HexRCF.SelectedRoot.RowIntermediates", + "+HexRCF.SelectedRoot.RowTools", + "+HexRCF.SelectedRoot.Source", + "+HexRCF.SelectedRoot.Upper", + "+HexRCF.PublicGraphCodec", + "+HexRCF.LanguageTests", + "+HexRCF.SturmBuilderTests", + "+HexRCF.CarrierTests", + "+HexRCF.IsolationsTests", + "+HexRCF.SeparationTests", + "+HexRCF.CellsTests", + "+HexRCF.CommonRootTests", + "+HexRCF.SignMatrixTests", + "+HexRCF.BuilderTests", + "+HexRCF.CertificateTests", + "+HexRCF.DecisionTests", + "+HexRCF.ReifyTests", + "+HexRCF.HandlerTests.Support", + "+HexRCF.HandlerTests.Async", + "+HexRCF.HandlerTests", + "+HexRCF.LintTests", + "HexRCFProofProbe", + "HexManual" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "scope": "All 263 actual HexRCF HexConformance roots, all16 base HexReleaseTests roots, both libraries, actual registered-constant proof probes and full manual, after original guard-inventory and recursion fixes." + }, + "focused_selection": { + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "source_tree": "55844661fe0c6670fcee1a397cdb947fac228c98", + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/lake-bounded", + "build", + "HexRCF", + "HexRCFRealCoefficients", + "+HexRCF.AlgebraicPreparationCases", + "+HexRCF.AlgebraicPreparationConformance", + "+HexRCF.SourceAcceptancePublic", + "HexRCFProofProbe", + "HexManual" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "scope": "Focused additional source-budget/alias-scan/control regressions, fresh source acceptance bodies and axiom audit, ordinary public consumer, libraries, caller proof probes and full manual after the complete6f compatibility run. Production source differs only by the guards docstring." + }, + "production_difference": "Only the exact public guards docstring changes between these source snapshots. The conformance consumer adds source-budget and good-record controls.", + "sources": { + "6f0ae423ab25e885118b1e9dbcdd4d464604a173": { + "adapters/HexRCF/RealCoefficients/AlgebraicCells.lean": "0c24e1bdb338cb6f6ef8fda7e652018db78b4dd4536edaaf4c1ab0d934d8da79", + "adapters/HexRCF/RealCoefficients/AlgebraicPreparation.lean": "a9482ff73183e8aeb8c34ba7206c2454ef5810c2fd8813d158dd5c61aea2c7a9", + "conformance/HexRCF/AlgebraicPreparationCases.lean": "d01d76c692be4ed36ded54ff9912dfe415c88212821e773514694512cef9f941", + "conformance/HexRCF/AlgebraicPreparationConformance.lean": "043c60b76152e23a5d8a6c7c9a0122b0e88986492b62d5d8d36e77b189b00d59", + "conformance/HexRCF/SourceAcceptancePublic.lean": "8bb6befdbdea2db7e980f3346e350785f0c6bed9570d56e25e9338ff20dba857", + "HexManual/Chapters/HexRCF/AlgebraicCells.lean": "f053f908c5c3b4169c02edc647d0aebd254b0551ef7f7327b1fef5a5715b8831", + "lakefile.lean": "6b036d82ac71039b70cd5e8c4a6e3ed920afcd3922ddae86c450ecd05fd943c0", + "lake-manifest.json": "fd2dc4df30cd44e4d30568489d616e7bcc8a78747500139134be56f35ae746a4", + "adapters/HexRCF/RealCoefficients/Reify.lean": "7af3cfae52d32d27592c1190fbdee7f292b4924a90e716e2489b6e3b97613af3" + }, + "cdc9b747aafee5970f7e818a28ff89c1ca343ec6": { + "adapters/HexRCF/RealCoefficients/AlgebraicCells.lean": "0c24e1bdb338cb6f6ef8fda7e652018db78b4dd4536edaaf4c1ab0d934d8da79", + "adapters/HexRCF/RealCoefficients/AlgebraicPreparation.lean": "a9482ff73183e8aeb8c34ba7206c2454ef5810c2fd8813d158dd5c61aea2c7a9", + "conformance/HexRCF/AlgebraicPreparationCases.lean": "b1c56c52eb591bab2dd52aa0d650fa5cdb999ad7c5dc1acee6b757133620415e", + "conformance/HexRCF/AlgebraicPreparationConformance.lean": "043c60b76152e23a5d8a6c7c9a0122b0e88986492b62d5d8d36e77b189b00d59", + "conformance/HexRCF/SourceAcceptancePublic.lean": "8bb6befdbdea2db7e980f3346e350785f0c6bed9570d56e25e9338ff20dba857", + "HexManual/Chapters/HexRCF/AlgebraicCells.lean": "f053f908c5c3b4169c02edc647d0aebd254b0551ef7f7327b1fef5a5715b8831", + "lakefile.lean": "6b036d82ac71039b70cd5e8c4a6e3ed920afcd3922ddae86c450ecd05fd943c0", + "lake-manifest.json": "fd2dc4df30cd44e4d30568489d616e7bcc8a78747500139134be56f35ae746a4", + "adapters/HexRCF/RealCoefficients/Reify.lean": "ea8474b9e253f93a1583064ca99ec0bf376dadf5457fd60b57e9e18460cf449c" + } + }, + "limits": { + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "source_tree": "39df2d90a2e4ce6615c591040eeb953c0d1f4e84", + "command": [ + "systemctl", + "--user", + "show", + "hex-10358-lean-build.service", + "--property=ActiveState", + "--property=MainPID", + "--property=MemoryMax", + "--property=MemorySwapMax", + "--property=MemoryCurrent", + "--property=ControlGroup", + "--property=Environment", + "--property=OOMPolicy" + ], + "properties": { + "ActiveState": "active", + "MainPID": "651265", + "OOMPolicy": "kill", + "ControlGroup": "/user.slice/user-1003.slice/user@1003.service/app.slice/hex-10358-lean-build.service", + "MemoryCurrent": "3387232256", + "MemoryMax": "34359738368", + "MemorySwapMax": "0", + "Environment": "PATH=/home/kim/.claude-patched:/home/kim/.local/bin:/home/kim/bin:/home/kim/.npm-global/bin:/run/wrappers/bin:/home/kim/.nix-profile/bin:/nix/profile/bin:/home/kim/.local/state/nix/profile/bin:/etc/profiles/per-user/kim/bin:/nix/var/nix/profiles/default/bin:/run/current-system/sw/bin LEAN_NUM_THREADS=2" + }, + "actual_argv": [ + "/home/kim/.elan/toolchains/leanprover--lean4---v4.35.0-rc3/bin/lake", + "build", + "HexRCF", + "HexRCFRealCoefficients", + "+HexRCF.Conformance", + "+HexRCF.SourceIdentityKernel", + "+HexRCF.SourceIdentityCases", + "+HexRCF.MaximalCoefficientsKernel", + "+HexRCF.MaximalCoefficientsConformance", + "+HexRCF.MaximalCoefficients", + "+HexRCF.CellReplay.AssembledKernel", + "+HexRCF.CellReplay.Assembled", + "+HexRCF.CellReplay.OperationsPublic", + "+HexRCF.CellReplay.OperationsKernel", + "+HexRCF.CellReplay.Operations", + "+HexRCF.CellReplay.Algebraic.Emit", + "+HexRCF.CellReplay.Algebraic.MutationData0", + "+HexRCF.CellReplay.Algebraic.Mutations", + "+HexRCF.CellReplay.Algebraic.Refusals", + "+HexRCF.CellReplay.Algebraic.Guards", + "+HexRCF.CellReplay.Algebraic.Meaning", + "+HexRCF.CellReplay.Algebraic.Boolean", + "+HexRCF.CellReplay.Algebraic.BooleanSources", + "+HexRCF.CellReplay.Algebraic.BooleanBinding", + "+HexRCF.CellReplay.Algebraic.BooleanQuoted", + "+HexRCF.CellBuildConformance", + "+HexRCF.CellDiscoverLinear", + "+HexRCF.CellDiscoverAlgebraic", + "+HexRCF.CellDiscoverCases", + "+HexRCF.CellDiscoverProofs", + "+HexRCF.CellRequestedConformance", + "+HexRCF.CellDecisionProofs", + "+HexRCF.CellCodecProofs", + "+HexRCF.CellExecutionProofs", + "+HexRCF.NumberFieldCellsConformance", + "+HexRCF.GatherCellsConformance", + "+HexRCF.RealModelConformance", + "+HexRCF.AlgebraicPreparationCases", + "+HexRCF.AlgebraicPreparationConformance", + "+HexRCF.SourceAcceptancePublic", + "+HexRCF.AlgebraicCellsConformance", + "+HexRCF.CellReplay.Algebraic.Canonical", + "+HexRCF.CellReplay.Algebraic.Check", + "+HexRCF.CellReplay.Algebraic.Convert", + "+HexRCF.CellReplay.Algebraic.Inputs", + "+HexRCF.CellReplay.Algebraic.LiteralData0", + "+HexRCF.CellReplay.Algebraic.LiteralData1", + "+HexRCF.CellReplay.Algebraic.Literals", + "+HexRCF.CellReplay.Algebraic.Quote", + "+HexRCF.CellReplay.Algebraic.Quoted", + "+HexRCF.CellReplay.Algebraic.CompleteQuote", + "+HexRCF.CellReplay.Algebraic.CompleteQuoted", + "+HexRCF.CellReplay.Algebraic.Radical", + "+HexRCF.CellReplay.Algebraic.Read", + "+HexRCF.CellReplay.Algebraic.Records", + "+HexRCF.CellReplay.Algebraic.ScalarData0", + "+HexRCF.CellReplay.Algebraic.ScalarData1", + "+HexRCF.CellReplay.Algebraic.Scalars", + "+HexRCF.CellReplay.Algebraic.Schema", + "+HexRCF.CellReplay.Algebraic.Sections", + "+HexRCF.RealFormulaConformance", + "+HexRCF.RealCoefficientsConformance", + "+HexRCF.AlgebraicProgress", + "+HexRCF.IsolationProgress", + "+HexRCF.RadicalProgress", + "+HexRCF.ProductionProgress", + "+HexRCF.FieldRootsConformance", + "+HexRCF.CertificationInputs", + "+HexRCF.RationalSources", + "+HexRCF.ProofEvidence", + "+HexRCF.CheckedConversions", + "+HexRCF.ReplayModes", + "+HexRCF.CarrierModes", + "+HexRCF.SignIndex", + "+HexRCF.PreparedCoefficients", + "+HexRCF.FiniteReplay", + "+HexRCF.FiniteSignsConformance", + "+HexRCF.CellReplay.OutsideLiterals", + "+HexRCF.CellReplay.Zero", + "+HexRCF.CellReplay.ZeroLiterals", + "+HexRCF.CellReplay.Valuation", + "+HexRCF.CellReplay.ModuleCheck", + "+HexRCF.CellReplay.Schema", + "+HexRCF.CellReplay.Check", + "+HexRCF.CellReplay.Ordinary", + "+HexRCF.CellReplay.Quote", + "+HexRCF.CellReplay.Controls", + "+HexRCF.CellReplay.Quoted", + "+HexRCF.CellReplay.Refusals", + "+HexRCF.CellReplay.Emit", + "+HexRCF.CellReplay.LiteralData0", + "+HexRCF.CellReplay.Literals", + "+HexRCF.CellReplay.MutationData0", + "+HexRCF.CellReplay.Mutations", + "+HexRCF.FiniteMatrix.Binding", + "+HexRCF.FiniteMatrix.Guards.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "+HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "+HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "+HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "+HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "+HexRCF.FiniteMatrix.Guards.Quotient.Records", + "+HexRCF.FiniteMatrix.Guards.Quotient.Source", + "+HexRCF.FiniteMatrix.Guards.Controls", + "+HexRCF.FiniteMatrix.Guards.Data", + "+HexRCF.FiniteMatrix.Guards.Domains", + "+HexRCF.FiniteMatrix.Guards.Emit", + "+HexRCF.FiniteMatrix.Guards.LiteralData0", + "+HexRCF.FiniteMatrix.Guards.Literals", + "+HexRCF.FiniteMatrix.Guards.Meaning", + "+HexRCF.FiniteMatrix.Guards.MutationData0", + "+HexRCF.FiniteMatrix.Guards.Mutations", + "+HexRCF.FiniteMatrix.Guards.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quote", + "+HexRCF.FiniteMatrix.Guards.Read", + "+HexRCF.FiniteMatrix.Guards.Records", + "+HexRCF.FiniteMatrix.Guards.Refusals", + "+HexRCF.FiniteMatrix.Guards.Schema", + "+HexRCF.FiniteMatrix.Data", + "+HexRCF.FiniteMatrix.Emit", + "+HexRCF.FiniteMatrix.Inputs", + "+HexRCF.FiniteMatrix.KernelControls", + "+HexRCF.FiniteMatrix.LiteralData0", + "+HexRCF.FiniteMatrix.LiteralData1", + "+HexRCF.FiniteMatrix.LiteralData2", + "+HexRCF.FiniteMatrix.LiteralData3", + "+HexRCF.FiniteMatrix.LiteralData4", + "+HexRCF.FiniteMatrix.LiteralData5", + "+HexRCF.FiniteMatrix.Literals", + "+HexRCF.FiniteMatrix.ModuleCheck", + "+HexRCF.FiniteMatrix.Ordinary", + "+HexRCF.FiniteMatrix.Packings", + "+HexRCF.FiniteMatrix.Quote", + "+HexRCF.FiniteMatrix.Controls", + "+HexRCF.FiniteMatrix.Refusals", + "+HexRCF.FiniteMatrix.Read", + "+HexRCF.FiniteMatrix.Restore", + "+HexRCF.FiniteMatrix.Schema", + "+HexRCF.FiniteMatrix.Selected", + "+HexRCF.FiniteMatrix.Semantics", + "+HexRCF.FiniteMatrix.Signs", + "+HexRCF.TowerSamples", + "+HexRCF.Samples", + "+HexRCF.RealizationData", + "+HexRCF.Realization", + "+HexRCF.NumberField", + "+HexRCF.Gather", + "+HexRCF.GatherCatalog", + "+HexRCF.RegisteredGatherConformance", + "+HexRCF.GeneratorWindowInputs", + "+HexRCF.GeneratorWindow", + "+HexRCF.CertificationProofs", + "+HexRCF.SuppliedIrreducible", + "+HexRCF.SuppliedIrreducibleProofs", + "+HexRCF.SuppliedBudget", + "+HexRCF.NativeFormulaConformance", + "+HexRCF.NativeSpecializeConformance", + "+HexRCF.NativeSamplesConformance", + "+HexRCF.NativeSampleModelConformance", + "+HexRCF.NativeSampleModelLiterals", + "+HexRCF.NativeSourcesConformance", + "+HexRCF.NativeSelectionLiterals", + "+HexRCF.NativeSelectionConformance", + "+HexRCF.NativeSelectionOrdinaryConformance", + "+HexRCF.NativeSelectionOrderedConformance", + "+HexRCF.SectionReplayConformance", + "+HexRCF.SectionProduceConformance", + "+HexRCF.SectionOrdinaryConformance", + "+HexRCF.PointReplayConformance", + "+HexRCF.PointProduceConformance", + "+HexRCF.PointOrdinaryConformance", + "+HexRCF.RootReplayLiterals", + "+HexRCF.RootReplayConformance", + "+HexRCF.RootReplayOrdinaryConformance", + "+HexRCF.NestedRootLiterals", + "+HexRCF.NestedRootProduceConformance", + "+HexRCF.NestedRootOrdinaryConformance", + "+HexRCF.RootTransportData", + "+HexRCF.RootTransportLiterals", + "+HexRCF.RootTransportConformance", + "+HexRCF.RootTransportOrdinaryConformance", + "+HexRCF.NestedTransport.Frame", + "+HexRCF.NestedTransport.Context", + "+HexRCF.NestedTransport.Map", + "+HexRCF.NestedTransport.Conversion", + "+HexRCF.NestedTransport.Fields", + "+HexRCF.NestedTransport.Restore", + "+HexRCF.NestedTransport.Predecessor", + "+HexRCF.NestedTransport.Facts", + "+HexRCF.NestedTransport.Constants", + "+HexRCF.NestedTransport.Operations", + "+HexRCF.NestedTransport.RootRead", + "+HexRCF.NestedTransport.Read", + "+HexRCF.NestedTransport.Model", + "+HexRCF.NestedTransport.Source", + "+HexRCF.NestedTransport.Ordinary", + "+HexRCF.NestedTransport.Controls", + "+HexRCF.NestedTransport.Literals", + "+HexRCF.NestedTransport.EndpointLiterals", + "+HexRCF.NestedTransport.SignLiterals", + "+HexRCF.NestedTransport.SignData", + "+HexRCF.TotalAlgebraicProofs", + "+HexRCF.AlgebraicDivision", + "+HexRCF.NormalizedCoefficients", + "+HexRCF.NormalizedInputs", + "+HexRCF.RegisteredConstants", + "+HexRCF.NamedConstants", + "+HexRCF.MixedConstants", + "+HexRCF.CoarseConstants", + "+HexRCF.RealCoefficientTactic", + "+HexRCF.RealCoefficientCommonField", + "+HexRCF.CommonFieldPresentation", + "+HexRCF.RootAliasesConformance", + "+HexRCF.RationalRoots", + "+HexRCF.AlgebraicRoots", + "+HexRCF.FormulaConformance", + "+HexRCF.LiteralSignConformance", + "+HexRCF.FieldSpecializeConformance", + "+HexRCF.SignDetFieldProofs", + "+HexRCF.AdmissionConformance", + "+HexRCF.IsolationConformance", + "+HexRCF.SelectedRoot.Packing", + "+HexRCF.SelectedRoot.PackingData", + "+HexRCF.SelectedRoot.InverseData", + "+HexRCF.SelectedRoot.InverseReplay", + "+HexRCF.SelectedRoot.InverseControls", + "+HexRCF.InverseFixture", + "+HexRCF.SelectedRoot.PackingReplay", + "+HexRCF.SelectedRoot.PackingMissing", + "+HexRCF.SelectedRoot.PackingAudit", + "+HexRCF.SelectedRoot.CatalogData", + "+HexRCF.SelectedRoot.CatalogByteData", + "+HexRCF.SelectedRoot.CatalogSource", + "+HexRCF.SelectedRoot.Catalog", + "+HexRCF.SelectedRoot.CatalogBytes", + "+HexRCF.SelectedRoot.CatalogControls", + "+HexRCF.SelectedRoot.CatalogAudit", + "+HexRCF.SelectedRoot.ByteAudit", + "+HexRCF.SelectedRoot.ByteBounds", + "+HexRCF.SelectedRoot.ByteChecks", + "+HexRCF.SelectedRoot.ByteData", + "+HexRCF.SelectedRoot.ByteProofs", + "+HexRCF.SelectedRoot.Audit", + "+HexRCF.SelectedRoot.Checks", + "+HexRCF.SelectedRoot.Collect", + "+HexRCF.SelectedRoot.Controls", + "+HexRCF.SelectedRoot.Data", + "+HexRCF.SelectedRoot.Frozen", + "+HexRCF.SelectedRoot.FrozenCollect", + "+HexRCF.SelectedRoot.KernelCheck", + "+HexRCF.SelectedRoot.Intermediates", + "+HexRCF.SelectedRoot.Literals", + "+HexRCF.SelectedRoot.PacketFields", + "+HexRCF.SelectedRoot.Packets", + "+HexRCF.SelectedRoot.Proofs", + "+HexRCF.SelectedRoot.Read", + "+HexRCF.SelectedRoot.Refusals", + "+HexRCF.SelectedRoot.ReplayTools", + "+HexRCF.SelectedRoot.Row", + "+HexRCF.SelectedRoot.RowCollect", + "+HexRCF.SelectedRoot.RowIntermediates", + "+HexRCF.SelectedRoot.RowTools", + "+HexRCF.SelectedRoot.Source", + "+HexRCF.SelectedRoot.Upper", + "+HexRCF.PublicGraphCodec", + "+HexRCF.LanguageTests", + "+HexRCF.SturmBuilderTests", + "+HexRCF.CarrierTests", + "+HexRCF.IsolationsTests", + "+HexRCF.SeparationTests", + "+HexRCF.CellsTests", + "+HexRCF.CommonRootTests", + "+HexRCF.SignMatrixTests", + "+HexRCF.BuilderTests", + "+HexRCF.CertificateTests", + "+HexRCF.DecisionTests", + "+HexRCF.ReifyTests", + "+HexRCF.HandlerTests.Support", + "+HexRCF.HandlerTests.Async", + "+HexRCF.HandlerTests", + "+HexRCF.LintTests", + "HexRCFProofProbe", + "HexManual" + ], + "actual_cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "wrappers": { + "lake-bounded": { + "content": "#!/usr/bin/env bash\nset -euo pipefail\nhex_build_environment=(--setenv=\"PATH=$PATH\" --setenv=LEAN_NUM_THREADS=2)\nfor hex_build_key in HEX_RCF_CELL_OUTPUT HEX_RCF_ZERO_OUTPUT HEX_RCF_ALGEBRAIC_CELL_OUTPUT HEX_NATIVE_ASSEMBLY_TRACE; do\n if [[ -v \"$hex_build_key\" ]]; then\n hex_build_environment+=(\"--setenv=$hex_build_key=${!hex_build_key}\")\n fi\ndone\nexec systemd-run --user --wait --pipe --collect \\\n --unit=hex-10358-lean-build \\\n --property=MemoryMax=32G \\\n --property=MemorySwapMax=0 \\\n --property=OOMPolicy=kill \\\n --working-directory=\"$PWD\" \\\n \"${hex_build_environment[@]}\" \\\n /run/current-system/sw/bin/lake \"$@\"\n", + "sha256": "03a8bbc1379af330832475148342b00de642c7342e8e8842f24aead7d1500e41" + }, + "run-bounded": { + "content": "#!/usr/bin/env bash\nset -euo pipefail\nexec systemd-run --user --wait --pipe --collect \\\n --unit=hex-10358-lean-build \\\n --property=MemoryMax=32G \\\n --property=MemorySwapMax=0 \\\n --property=OOMPolicy=kill \\\n --working-directory=\"$PWD\" \\\n --setenv=\"PATH=$PATH\" --setenv=LEAN_NUM_THREADS=2 \\\n \"$@\"\n", + "sha256": "63bc5f97337e6b039bb3a9b1ba2a500be96fd1c2a2f73b43dae284aa9b18dda8" + } + } + }, + "builds": [ + { + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "log": "source-acceptance-all-2.log.gz", + "uncompressed_sha256": "2cb5bebc447dddbc77b404edca59c413709db7f72df113a8db21bc341f7098e5", + "summary": "code=exited, status=0/SUCCESS\n Service runtime: 25min 29.596s\n CPU time consumed: 48min 41.548s\n Memory peak: 10.7G (swap: 0B)" + }, + { + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "log": "source-acceptance-budget-followup-1.log.gz", + "uncompressed_sha256": "8607f89e531a20c911e1ff70844c382549e210951b060bad5e283e3ee1b79359", + "summary": "code=exited, status=0/SUCCESS\n Service runtime: 7min 53.580s\n CPU time consumed: 13min 26.676s\n Memory peak: 7.8G (swap: 0B)" + }, + { + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "log": "source-acceptance-render-4.log.gz", + "uncompressed_sha256": "802108af1e2b86b97471a15a3c7fe52e5e59298588c9cf8b8bb97b403b441ecb", + "summary": "code=exited, status=0/SUCCESS\n Service runtime: 11.803s\n CPU time consumed: 17.059s\n Memory peak: 2G (swap: 0B)" + }, + { + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "log": "source-acceptance-browser-4.log.gz", + "uncompressed_sha256": "ff17af8a2be9fb67879f85b21867cbf25653ab0a4704f95421cfc90132d3c361", + "summary": "code=exited, status=0/SUCCESS\n Service runtime: 10.733s\n CPU time consumed: 47.876s\n Memory peak: 8G (swap: 0B)" + } + ], + "metadata": [ + { + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "source_tree": "39df2d90a2e4ce6615c591040eeb953c0d1f4e84", + "checks": { + "dag": { + "command": { + "argv": [ + "python3", + "scripts/check_dag.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "source_tree": "39df2d90a2e4ce6615c591040eeb953c0d1f4e84", + "script_sha256": "760236cb56f22dd916c677070713146ebd9bd652ba988b3f9427d6a671a4ea10" + }, + "exit_status": 0, + "log": "source-acceptance-dag-6.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "copyright": { + "command": { + "argv": [ + "python3", + "scripts/check_copyright_headers.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "source_tree": "39df2d90a2e4ce6615c591040eeb953c0d1f4e84", + "script_sha256": "d7ccfbb8e737c342ff24f7ec875c403a76a678a75f581a8e7dcaf0b654325c84" + }, + "exit_status": 0, + "log": "source-acceptance-copyright-6.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "lines": { + "command": { + "argv": [ + "python3", + "scripts/check_file_line_counts.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "source_tree": "39df2d90a2e4ce6615c591040eeb953c0d1f4e84", + "script_sha256": "0c9109c17128a11651f7a5d3784b5b35c859b87e2f58d12c2fbcd5c7562f1229" + }, + "exit_status": 0, + "log": "source-acceptance-lines-6.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "admissions": { + "command": { + "argv": [ + "python3", + "scripts/ci/check_named_admissions.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "source_tree": "39df2d90a2e4ce6615c591040eeb953c0d1f4e84", + "script_sha256": "b2a2ceb6ba6422b4a54c8c797907c61574c1f60e6659441e8c1b357ee3c471ce" + }, + "exit_status": 0, + "log": "source-acceptance-admissions-6.log", + "sha256": "e43ea625a5bd76ee270c4f04f155c2ed77ed259c673904377f0e30645bca03ca" + } + } + }, + { + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "source_tree": "55844661fe0c6670fcee1a397cdb947fac228c98", + "checks": { + "dag": { + "command": { + "argv": [ + "python3", + "scripts/check_dag.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "source_tree": "55844661fe0c6670fcee1a397cdb947fac228c98", + "script_sha256": "760236cb56f22dd916c677070713146ebd9bd652ba988b3f9427d6a671a4ea10" + }, + "exit_status": 0, + "log": "source-acceptance-dag-7.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "copyright": { + "command": { + "argv": [ + "python3", + "scripts/check_copyright_headers.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "source_tree": "55844661fe0c6670fcee1a397cdb947fac228c98", + "script_sha256": "d7ccfbb8e737c342ff24f7ec875c403a76a678a75f581a8e7dcaf0b654325c84" + }, + "exit_status": 0, + "log": "source-acceptance-copyright-7.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "lines": { + "command": { + "argv": [ + "python3", + "scripts/check_file_line_counts.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "source_tree": "55844661fe0c6670fcee1a397cdb947fac228c98", + "script_sha256": "0c9109c17128a11651f7a5d3784b5b35c859b87e2f58d12c2fbcd5c7562f1229" + }, + "exit_status": 0, + "log": "source-acceptance-lines-7.log", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "admissions": { + "command": { + "argv": [ + "python3", + "scripts/ci/check_named_admissions.py" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "source_tree": "55844661fe0c6670fcee1a397cdb947fac228c98", + "script_sha256": "b2a2ceb6ba6422b4a54c8c797907c61574c1f60e6659441e8c1b357ee3c471ce" + }, + "exit_status": 0, + "log": "source-acceptance-admissions-7.log", + "sha256": "e43ea625a5bd76ee270c4f04f155c2ed77ed259c673904377f0e30645bca03ca" + } + } + } + ], + "inspection": [ + { + "label": "desktop", + "kind": "equivalence", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe helper reconstructs the ordered original guard inventory from the target;\nediting both stored guard arrays cannot remove or replace an obligation.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 1440, + "scrollY": 272729, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "P", + "targetWidth": 752, + "targetScrollWidth": 752, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "desktop", + "kind": "example", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe helper reconstructs the ordered original guard inventory from the target;\nediting both stored guard arrays cannot remove or replace an obligation.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 1440, + "scrollY": 273142, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "CODE", + "targetWidth": 740, + "targetScrollWidth": 740, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "desktop", + "kind": "boundary", + "text": "\n This proof uses the checked algebraic expressions and their source identities.\nIt does not identify separately computed proposals with frozen literals,\nreconstruct provider histories, or add a tactic handler. Those authentication\nand quotation obligations remain separate. The helper continues the same\naggregate reflection budget, returns its updated usage for later stages, and\nrestores caller state on exhaustion or failure.\nCallers continue with {prepared with usage} when constructing further proofs.\nBoth preparation and acceptance preserve a caller's lowered recursion limit.\nFresh importing regressions check its actual theorem bodies, true and false\nsources, retained zero guards and reversed intervals, with exactly the standard\nthree axioms.", + "viewport": 1440, + "scrollY": 273566, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "P", + "targetWidth": 752, + "targetScrollWidth": 752, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "equivalence", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe helper reconstructs the ordered original guard inventory from the target;\nediting both stored guard arrays cannot remove or replace an obligation.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 390, + "scrollY": 436942, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "P", + "targetWidth": 343, + "targetScrollWidth": 343, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "example", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe helper reconstructs the ordered original guard inventory from the target;\nediting both stored guard arrays cannot remove or replace an obligation.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 390, + "scrollY": 437482, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "CODE", + "targetWidth": 331, + "targetScrollWidth": 331, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "boundary", + "text": "\n This proof uses the checked algebraic expressions and their source identities.\nIt does not identify separately computed proposals with frozen literals,\nreconstruct provider histories, or add a tactic handler. Those authentication\nand quotation obligations remain separate. The helper continues the same\naggregate reflection budget, returns its updated usage for later stages, and\nrestores caller state on exhaustion or failure.\nCallers continue with {prepared with usage} when constructing further proofs.\nBoth preparation and acceptance preserve a caller's lowered recursion limit.\nFresh importing regressions check its actual theorem bodies, true and false\nsources, retained zero guards and reversed intervals, with exactly the standard\nthree axioms.", + "viewport": 390, + "scrollY": 438034, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "P", + "targetWidth": 343, + "targetScrollWidth": 343, + "descendantOverflow": 0, + "overflowElements": [] + } + ], + "opened": { + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "images": [ + "source-acceptance-desktop-equivalence.png", + "source-acceptance-narrow-equivalence.png", + "source-acceptance-desktop-example.png", + "source-acceptance-narrow-example.png", + "source-acceptance-desktop-boundary.png", + "source-acceptance-narrow-boundary.png" + ], + "sha256": { + "source-acceptance-desktop-equivalence.png": "5c0e6a00eb5918f0fccad1d3a4e2f96d179299887ce812413755edd45e480b52", + "source-acceptance-narrow-equivalence.png": "20ded47220d18e6cb1c96cf152a0855dc47e0d6c5b516023118923b5fa402fd0", + "source-acceptance-desktop-example.png": "5467f0cb1948fde97d276091aa2e645ae5e57665ecefce8c27457621f2a7cf2e", + "source-acceptance-narrow-example.png": "c217ebb80a47c3495064773185660db3e8493c1ad8bd38e27eda0837c1b00f84", + "source-acceptance-desktop-boundary.png": "93f9f6e3d5a70ed9c1b751701866b5a635e014f4f9138ceed3ad7e2b52d46e70", + "source-acceptance-narrow-boundary.png": "b4451859408878ac2e593929484cc4ccd8a1e24cc887d094372dbdb7862eeb78" + }, + "inspection": "All six images opened with view_image. Acceptance paragraph, entire runnable example, and limitation/usage paragraph remain readable at1440 and390 pixels; their local overflow metrics are zero. Existing horizontal overflow elsewhere in the full book is excluded." + }, + "artifacts": { + "source-acceptance-all-2.log.gz": "4868552f283f85ae9aa15419690c615ba3ebd6b494b111146b715c97c70b00e4", + "source-acceptance-budget-followup-1.log.gz": "d6365ffa1f2554cae76223dcc9f294f24c3c2aec441e273313997d0f8a1f8157", + "source-acceptance-render-4.log.gz": "8a383748cc5c7f1e539a87ebe5f4a63d265d6485f546d22ce60242f986037ba2", + "source-acceptance-browser-4.log.gz": "ed3343368aabf7043320b6c184dc703f257bc3d053a5ffb973df069f45c00edf", + "source-acceptance-dag-6.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "source-acceptance-copyright-6.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "source-acceptance-lines-6.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "source-acceptance-admissions-6.log": "e43ea625a5bd76ee270c4f04f155c2ed77ed259c673904377f0e30645bca03ca", + "source-acceptance-dag-7.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "source-acceptance-copyright-7.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "source-acceptance-lines-7.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "source-acceptance-admissions-7.log": "e43ea625a5bd76ee270c4f04f155c2ed77ed259c673904377f0e30645bca03ca", + "source-acceptance-all-selection-2.json": "3d56f4016d48bd6889137b54bea98808cb7b71d72bb7689e40d3f5cbff189032", + "source-acceptance-budget-followup-selection-1.json": "c0fb0c79d6177336f093d3fc4388f8e135d2d5599bf4d3a967382d9925281641", + "source-acceptance-all-2-limits.json": "364996a31a7c3e60420fd5e6e2386e1308f01f2d12019d868081cb1bd641970c", + "source-acceptance-browser.mjs": "ba772a7b3a4609c57ba96f0a7c58764afef1a1fd19c13a0a9b807928e09b0eb2", + "source-acceptance-inspection.json": "4e8583662f3f8ac4aa983f8c678ddf021b142439e553b458033657218433dc34", + "opened.json": "fe4f98f7b44f1dff17a2503edee6df4cb15e0e883f681201cede0a40735d6212", + "source-acceptance-desktop-equivalence.png": "5c0e6a00eb5918f0fccad1d3a4e2f96d179299887ce812413755edd45e480b52", + "source-acceptance-narrow-equivalence.png": "20ded47220d18e6cb1c96cf152a0855dc47e0d6c5b516023118923b5fa402fd0", + "source-acceptance-desktop-example.png": "5467f0cb1948fde97d276091aa2e645ae5e57665ecefce8c27457621f2a7cf2e", + "source-acceptance-narrow-example.png": "c217ebb80a47c3495064773185660db3e8493c1ad8bd38e27eda0837c1b00f84", + "source-acceptance-desktop-boundary.png": "93f9f6e3d5a70ed9c1b751701866b5a635e014f4f9138ceed3ad7e2b52d46e70", + "source-acceptance-narrow-boundary.png": "b4451859408878ac2e593929484cc4ccd8a1e24cc887d094372dbdb7862eeb78", + "source-acceptance-render-selection-4.json": "164d6b30b4bed576b70f081efcb424bc538ef1123a8b31a47429f491450f538b", + "source-acceptance-browser-selection-4.json": "2d752b972bddf0ad2fa77715357b472b15520aa16990134993a63ba4bf44e5bb", + "render/SourceAcceptanceRender4.lean.txt": "da36bfd84c03a98ce69e2b6aab65a1ae1bcf822b2ffa90d2ce496d80ba044c3f", + "render/lakefile.lean.txt": "058ff20cb7913e7b371934ed92633c7528c9e9da03ab1b687c1c731fc7bfade8" + }, + "render_selection": { + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/run-bounded", + "env", + "LAKE_NO_CACHE=true", + "lake", + "build", + "+AuditImportProbe", + "+SourceAcceptanceRender4" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/atomic-public-current", + "scope": "Fresh manual render and joint fresh source-body-audit plus complete-manual import." + }, + "browser_selection": { + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/run-bounded", + "node", + "/home/kim/.codex/tasks/hex-10358/source-acceptance-browser.mjs", + "/home/kim/.codex/tasks/hex-10358/atomic-public-current" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/atomic-public-current", + "script_sha256": "ba772a7b3a4609c57ba96f0a7c58764afef1a1fd19c13a0a9b807928e09b0eb2", + "scope": "Six actual desktop/narrow captures and local changed-content overflow checks after fresh full manual render." + } +} diff --git a/reports/data/hexrcf-source-acceptance/validation/render/SourceAcceptanceRender4.lean.txt b/reports/data/hexrcf-source-acceptance/validation/render/SourceAcceptanceRender4.lean.txt new file mode 100644 index 0000000000..a8eba84746 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/render/SourceAcceptanceRender4.lean.txt @@ -0,0 +1,5 @@ +import HexManual +import VersoManual +#eval Verso.Genre.Manual.manualMain (%doc HexManual) + (options := ["--output", "source-acceptance-html", + "--without-tex", "--with-html-single", "--without-html-multi"]) diff --git a/reports/data/hexrcf-source-acceptance/validation/render/lakefile.lean.txt b/reports/data/hexrcf-source-acceptance/validation/render/lakefile.lean.txt new file mode 100644 index 0000000000..c42812563f --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/render/lakefile.lean.txt @@ -0,0 +1,19 @@ +import Lake +open Lake DSL +package atomicPublicCurrent +require Hex from "/home/kim/.codex/tasks/hex-10358/boolean-worktree" +lean_lib AtomicRoundtrip + +lean_lib SourceAcceptanceRender + +lean_lib BaseCodecPublic + +lean_lib BaseCodecPrivateControl + +lean_lib BaseSignaturePublic + +lean_lib CodecRewriteProbe + +lean_lib AuditImportProbe + +lean_lib SourceAcceptanceRender4 diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-admissions-6.log b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-admissions-6.log new file mode 100644 index 0000000000..cc19aa52d9 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-admissions-6.log @@ -0,0 +1 @@ +670 scanned adapter/conformance import cones: 1578 local modules, no admissions in these cones diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-admissions-7.log b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-admissions-7.log new file mode 100644 index 0000000000..cc19aa52d9 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-admissions-7.log @@ -0,0 +1 @@ +670 scanned adapter/conformance import cones: 1578 local modules, no admissions in these cones diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-all-2-limits.json b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-all-2-limits.json new file mode 100644 index 0000000000..0886b95105 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-all-2-limits.json @@ -0,0 +1,326 @@ +{ + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "source_tree": "39df2d90a2e4ce6615c591040eeb953c0d1f4e84", + "command": [ + "systemctl", + "--user", + "show", + "hex-10358-lean-build.service", + "--property=ActiveState", + "--property=MainPID", + "--property=MemoryMax", + "--property=MemorySwapMax", + "--property=MemoryCurrent", + "--property=ControlGroup", + "--property=Environment", + "--property=OOMPolicy" + ], + "properties": { + "ActiveState": "active", + "MainPID": "651265", + "OOMPolicy": "kill", + "ControlGroup": "/user.slice/user-1003.slice/user@1003.service/app.slice/hex-10358-lean-build.service", + "MemoryCurrent": "3387232256", + "MemoryMax": "34359738368", + "MemorySwapMax": "0", + "Environment": "PATH=/home/kim/.claude-patched:/home/kim/.local/bin:/home/kim/bin:/home/kim/.npm-global/bin:/run/wrappers/bin:/home/kim/.nix-profile/bin:/nix/profile/bin:/home/kim/.local/state/nix/profile/bin:/etc/profiles/per-user/kim/bin:/nix/var/nix/profiles/default/bin:/run/current-system/sw/bin LEAN_NUM_THREADS=2" + }, + "actual_argv": [ + "/home/kim/.elan/toolchains/leanprover--lean4---v4.35.0-rc3/bin/lake", + "build", + "HexRCF", + "HexRCFRealCoefficients", + "+HexRCF.Conformance", + "+HexRCF.SourceIdentityKernel", + "+HexRCF.SourceIdentityCases", + "+HexRCF.MaximalCoefficientsKernel", + "+HexRCF.MaximalCoefficientsConformance", + "+HexRCF.MaximalCoefficients", + "+HexRCF.CellReplay.AssembledKernel", + "+HexRCF.CellReplay.Assembled", + "+HexRCF.CellReplay.OperationsPublic", + "+HexRCF.CellReplay.OperationsKernel", + "+HexRCF.CellReplay.Operations", + "+HexRCF.CellReplay.Algebraic.Emit", + "+HexRCF.CellReplay.Algebraic.MutationData0", + "+HexRCF.CellReplay.Algebraic.Mutations", + "+HexRCF.CellReplay.Algebraic.Refusals", + "+HexRCF.CellReplay.Algebraic.Guards", + "+HexRCF.CellReplay.Algebraic.Meaning", + "+HexRCF.CellReplay.Algebraic.Boolean", + "+HexRCF.CellReplay.Algebraic.BooleanSources", + "+HexRCF.CellReplay.Algebraic.BooleanBinding", + "+HexRCF.CellReplay.Algebraic.BooleanQuoted", + "+HexRCF.CellBuildConformance", + "+HexRCF.CellDiscoverLinear", + "+HexRCF.CellDiscoverAlgebraic", + "+HexRCF.CellDiscoverCases", + "+HexRCF.CellDiscoverProofs", + "+HexRCF.CellRequestedConformance", + "+HexRCF.CellDecisionProofs", + "+HexRCF.CellCodecProofs", + "+HexRCF.CellExecutionProofs", + "+HexRCF.NumberFieldCellsConformance", + "+HexRCF.GatherCellsConformance", + "+HexRCF.RealModelConformance", + "+HexRCF.AlgebraicPreparationCases", + "+HexRCF.AlgebraicPreparationConformance", + "+HexRCF.SourceAcceptancePublic", + "+HexRCF.AlgebraicCellsConformance", + "+HexRCF.CellReplay.Algebraic.Canonical", + "+HexRCF.CellReplay.Algebraic.Check", + "+HexRCF.CellReplay.Algebraic.Convert", + "+HexRCF.CellReplay.Algebraic.Inputs", + "+HexRCF.CellReplay.Algebraic.LiteralData0", + "+HexRCF.CellReplay.Algebraic.LiteralData1", + "+HexRCF.CellReplay.Algebraic.Literals", + "+HexRCF.CellReplay.Algebraic.Quote", + "+HexRCF.CellReplay.Algebraic.Quoted", + "+HexRCF.CellReplay.Algebraic.CompleteQuote", + "+HexRCF.CellReplay.Algebraic.CompleteQuoted", + "+HexRCF.CellReplay.Algebraic.Radical", + "+HexRCF.CellReplay.Algebraic.Read", + "+HexRCF.CellReplay.Algebraic.Records", + "+HexRCF.CellReplay.Algebraic.ScalarData0", + "+HexRCF.CellReplay.Algebraic.ScalarData1", + "+HexRCF.CellReplay.Algebraic.Scalars", + "+HexRCF.CellReplay.Algebraic.Schema", + "+HexRCF.CellReplay.Algebraic.Sections", + "+HexRCF.RealFormulaConformance", + "+HexRCF.RealCoefficientsConformance", + "+HexRCF.AlgebraicProgress", + "+HexRCF.IsolationProgress", + "+HexRCF.RadicalProgress", + "+HexRCF.ProductionProgress", + "+HexRCF.FieldRootsConformance", + "+HexRCF.CertificationInputs", + "+HexRCF.RationalSources", + "+HexRCF.ProofEvidence", + "+HexRCF.CheckedConversions", + "+HexRCF.ReplayModes", + "+HexRCF.CarrierModes", + "+HexRCF.SignIndex", + "+HexRCF.PreparedCoefficients", + "+HexRCF.FiniteReplay", + "+HexRCF.FiniteSignsConformance", + "+HexRCF.CellReplay.OutsideLiterals", + "+HexRCF.CellReplay.Zero", + "+HexRCF.CellReplay.ZeroLiterals", + "+HexRCF.CellReplay.Valuation", + "+HexRCF.CellReplay.ModuleCheck", + "+HexRCF.CellReplay.Schema", + "+HexRCF.CellReplay.Check", + "+HexRCF.CellReplay.Ordinary", + "+HexRCF.CellReplay.Quote", + "+HexRCF.CellReplay.Controls", + "+HexRCF.CellReplay.Quoted", + "+HexRCF.CellReplay.Refusals", + "+HexRCF.CellReplay.Emit", + "+HexRCF.CellReplay.LiteralData0", + "+HexRCF.CellReplay.Literals", + "+HexRCF.CellReplay.MutationData0", + "+HexRCF.CellReplay.Mutations", + "+HexRCF.FiniteMatrix.Binding", + "+HexRCF.FiniteMatrix.Guards.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "+HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "+HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "+HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "+HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "+HexRCF.FiniteMatrix.Guards.Quotient.Records", + "+HexRCF.FiniteMatrix.Guards.Quotient.Source", + "+HexRCF.FiniteMatrix.Guards.Controls", + "+HexRCF.FiniteMatrix.Guards.Data", + "+HexRCF.FiniteMatrix.Guards.Domains", + "+HexRCF.FiniteMatrix.Guards.Emit", + "+HexRCF.FiniteMatrix.Guards.LiteralData0", + "+HexRCF.FiniteMatrix.Guards.Literals", + "+HexRCF.FiniteMatrix.Guards.Meaning", + "+HexRCF.FiniteMatrix.Guards.MutationData0", + "+HexRCF.FiniteMatrix.Guards.Mutations", + "+HexRCF.FiniteMatrix.Guards.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quote", + "+HexRCF.FiniteMatrix.Guards.Read", + "+HexRCF.FiniteMatrix.Guards.Records", + "+HexRCF.FiniteMatrix.Guards.Refusals", + "+HexRCF.FiniteMatrix.Guards.Schema", + "+HexRCF.FiniteMatrix.Data", + "+HexRCF.FiniteMatrix.Emit", + "+HexRCF.FiniteMatrix.Inputs", + "+HexRCF.FiniteMatrix.KernelControls", + "+HexRCF.FiniteMatrix.LiteralData0", + "+HexRCF.FiniteMatrix.LiteralData1", + "+HexRCF.FiniteMatrix.LiteralData2", + "+HexRCF.FiniteMatrix.LiteralData3", + "+HexRCF.FiniteMatrix.LiteralData4", + "+HexRCF.FiniteMatrix.LiteralData5", + "+HexRCF.FiniteMatrix.Literals", + "+HexRCF.FiniteMatrix.ModuleCheck", + "+HexRCF.FiniteMatrix.Ordinary", + "+HexRCF.FiniteMatrix.Packings", + "+HexRCF.FiniteMatrix.Quote", + "+HexRCF.FiniteMatrix.Controls", + "+HexRCF.FiniteMatrix.Refusals", + "+HexRCF.FiniteMatrix.Read", + "+HexRCF.FiniteMatrix.Restore", + "+HexRCF.FiniteMatrix.Schema", + "+HexRCF.FiniteMatrix.Selected", + "+HexRCF.FiniteMatrix.Semantics", + "+HexRCF.FiniteMatrix.Signs", + "+HexRCF.TowerSamples", + "+HexRCF.Samples", + "+HexRCF.RealizationData", + "+HexRCF.Realization", + "+HexRCF.NumberField", + "+HexRCF.Gather", + "+HexRCF.GatherCatalog", + "+HexRCF.RegisteredGatherConformance", + "+HexRCF.GeneratorWindowInputs", + "+HexRCF.GeneratorWindow", + "+HexRCF.CertificationProofs", + "+HexRCF.SuppliedIrreducible", + "+HexRCF.SuppliedIrreducibleProofs", + "+HexRCF.SuppliedBudget", + "+HexRCF.NativeFormulaConformance", + "+HexRCF.NativeSpecializeConformance", + "+HexRCF.NativeSamplesConformance", + "+HexRCF.NativeSampleModelConformance", + "+HexRCF.NativeSampleModelLiterals", + "+HexRCF.NativeSourcesConformance", + "+HexRCF.NativeSelectionLiterals", + "+HexRCF.NativeSelectionConformance", + "+HexRCF.NativeSelectionOrdinaryConformance", + "+HexRCF.NativeSelectionOrderedConformance", + "+HexRCF.SectionReplayConformance", + "+HexRCF.SectionProduceConformance", + "+HexRCF.SectionOrdinaryConformance", + "+HexRCF.PointReplayConformance", + "+HexRCF.PointProduceConformance", + "+HexRCF.PointOrdinaryConformance", + "+HexRCF.RootReplayLiterals", + "+HexRCF.RootReplayConformance", + "+HexRCF.RootReplayOrdinaryConformance", + "+HexRCF.NestedRootLiterals", + "+HexRCF.NestedRootProduceConformance", + "+HexRCF.NestedRootOrdinaryConformance", + "+HexRCF.RootTransportData", + "+HexRCF.RootTransportLiterals", + "+HexRCF.RootTransportConformance", + "+HexRCF.RootTransportOrdinaryConformance", + "+HexRCF.NestedTransport.Frame", + "+HexRCF.NestedTransport.Context", + "+HexRCF.NestedTransport.Map", + "+HexRCF.NestedTransport.Conversion", + "+HexRCF.NestedTransport.Fields", + "+HexRCF.NestedTransport.Restore", + "+HexRCF.NestedTransport.Predecessor", + "+HexRCF.NestedTransport.Facts", + "+HexRCF.NestedTransport.Constants", + "+HexRCF.NestedTransport.Operations", + "+HexRCF.NestedTransport.RootRead", + "+HexRCF.NestedTransport.Read", + "+HexRCF.NestedTransport.Model", + "+HexRCF.NestedTransport.Source", + "+HexRCF.NestedTransport.Ordinary", + "+HexRCF.NestedTransport.Controls", + "+HexRCF.NestedTransport.Literals", + "+HexRCF.NestedTransport.EndpointLiterals", + "+HexRCF.NestedTransport.SignLiterals", + "+HexRCF.NestedTransport.SignData", + "+HexRCF.TotalAlgebraicProofs", + "+HexRCF.AlgebraicDivision", + "+HexRCF.NormalizedCoefficients", + "+HexRCF.NormalizedInputs", + "+HexRCF.RegisteredConstants", + "+HexRCF.NamedConstants", + "+HexRCF.MixedConstants", + "+HexRCF.CoarseConstants", + "+HexRCF.RealCoefficientTactic", + "+HexRCF.RealCoefficientCommonField", + "+HexRCF.CommonFieldPresentation", + "+HexRCF.RootAliasesConformance", + "+HexRCF.RationalRoots", + "+HexRCF.AlgebraicRoots", + "+HexRCF.FormulaConformance", + "+HexRCF.LiteralSignConformance", + "+HexRCF.FieldSpecializeConformance", + "+HexRCF.SignDetFieldProofs", + "+HexRCF.AdmissionConformance", + "+HexRCF.IsolationConformance", + "+HexRCF.SelectedRoot.Packing", + "+HexRCF.SelectedRoot.PackingData", + "+HexRCF.SelectedRoot.InverseData", + "+HexRCF.SelectedRoot.InverseReplay", + "+HexRCF.SelectedRoot.InverseControls", + "+HexRCF.InverseFixture", + "+HexRCF.SelectedRoot.PackingReplay", + "+HexRCF.SelectedRoot.PackingMissing", + "+HexRCF.SelectedRoot.PackingAudit", + "+HexRCF.SelectedRoot.CatalogData", + "+HexRCF.SelectedRoot.CatalogByteData", + "+HexRCF.SelectedRoot.CatalogSource", + "+HexRCF.SelectedRoot.Catalog", + "+HexRCF.SelectedRoot.CatalogBytes", + "+HexRCF.SelectedRoot.CatalogControls", + "+HexRCF.SelectedRoot.CatalogAudit", + "+HexRCF.SelectedRoot.ByteAudit", + "+HexRCF.SelectedRoot.ByteBounds", + "+HexRCF.SelectedRoot.ByteChecks", + "+HexRCF.SelectedRoot.ByteData", + "+HexRCF.SelectedRoot.ByteProofs", + "+HexRCF.SelectedRoot.Audit", + "+HexRCF.SelectedRoot.Checks", + "+HexRCF.SelectedRoot.Collect", + "+HexRCF.SelectedRoot.Controls", + "+HexRCF.SelectedRoot.Data", + "+HexRCF.SelectedRoot.Frozen", + "+HexRCF.SelectedRoot.FrozenCollect", + "+HexRCF.SelectedRoot.KernelCheck", + "+HexRCF.SelectedRoot.Intermediates", + "+HexRCF.SelectedRoot.Literals", + "+HexRCF.SelectedRoot.PacketFields", + "+HexRCF.SelectedRoot.Packets", + "+HexRCF.SelectedRoot.Proofs", + "+HexRCF.SelectedRoot.Read", + "+HexRCF.SelectedRoot.Refusals", + "+HexRCF.SelectedRoot.ReplayTools", + "+HexRCF.SelectedRoot.Row", + "+HexRCF.SelectedRoot.RowCollect", + "+HexRCF.SelectedRoot.RowIntermediates", + "+HexRCF.SelectedRoot.RowTools", + "+HexRCF.SelectedRoot.Source", + "+HexRCF.SelectedRoot.Upper", + "+HexRCF.PublicGraphCodec", + "+HexRCF.LanguageTests", + "+HexRCF.SturmBuilderTests", + "+HexRCF.CarrierTests", + "+HexRCF.IsolationsTests", + "+HexRCF.SeparationTests", + "+HexRCF.CellsTests", + "+HexRCF.CommonRootTests", + "+HexRCF.SignMatrixTests", + "+HexRCF.BuilderTests", + "+HexRCF.CertificateTests", + "+HexRCF.DecisionTests", + "+HexRCF.ReifyTests", + "+HexRCF.HandlerTests.Support", + "+HexRCF.HandlerTests.Async", + "+HexRCF.HandlerTests", + "+HexRCF.LintTests", + "HexRCFProofProbe", + "HexManual" + ], + "actual_cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "wrappers": { + "lake-bounded": { + "content": "#!/usr/bin/env bash\nset -euo pipefail\nhex_build_environment=(--setenv=\"PATH=$PATH\" --setenv=LEAN_NUM_THREADS=2)\nfor hex_build_key in HEX_RCF_CELL_OUTPUT HEX_RCF_ZERO_OUTPUT HEX_RCF_ALGEBRAIC_CELL_OUTPUT HEX_NATIVE_ASSEMBLY_TRACE; do\n if [[ -v \"$hex_build_key\" ]]; then\n hex_build_environment+=(\"--setenv=$hex_build_key=${!hex_build_key}\")\n fi\ndone\nexec systemd-run --user --wait --pipe --collect \\\n --unit=hex-10358-lean-build \\\n --property=MemoryMax=32G \\\n --property=MemorySwapMax=0 \\\n --property=OOMPolicy=kill \\\n --working-directory=\"$PWD\" \\\n \"${hex_build_environment[@]}\" \\\n /run/current-system/sw/bin/lake \"$@\"\n", + "sha256": "03a8bbc1379af330832475148342b00de642c7342e8e8842f24aead7d1500e41" + }, + "run-bounded": { + "content": "#!/usr/bin/env bash\nset -euo pipefail\nexec systemd-run --user --wait --pipe --collect \\\n --unit=hex-10358-lean-build \\\n --property=MemoryMax=32G \\\n --property=MemorySwapMax=0 \\\n --property=OOMPolicy=kill \\\n --working-directory=\"$PWD\" \\\n --setenv=\"PATH=$PATH\" --setenv=LEAN_NUM_THREADS=2 \\\n \"$@\"\n", + "sha256": "63bc5f97337e6b039bb3a9b1ba2a500be96fd1c2a2f73b43dae284aa9b18dda8" + } + } +} diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-all-2.log.gz b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-all-2.log.gz new file mode 100644 index 0000000000..a77dc442f3 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-all-2.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-all-selection-2.json b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-all-selection-2.json new file mode 100644 index 0000000000..b293c237ff --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-all-selection-2.json @@ -0,0 +1,576 @@ +{ + "source_commit": "6f0ae423ab25e885118b1e9dbcdd4d464604a173", + "source_tree": "39df2d90a2e4ce6615c591040eeb953c0d1f4e84", + "rcf_conformance_roots": [ + "HexRCF.Conformance", + "HexRCF.SourceIdentityKernel", + "HexRCF.SourceIdentityCases", + "HexRCF.MaximalCoefficientsKernel", + "HexRCF.MaximalCoefficientsConformance", + "HexRCF.MaximalCoefficients", + "HexRCF.CellReplay.AssembledKernel", + "HexRCF.CellReplay.Assembled", + "HexRCF.CellReplay.OperationsPublic", + "HexRCF.CellReplay.OperationsKernel", + "HexRCF.CellReplay.Operations", + "HexRCF.CellReplay.Algebraic.Emit", + "HexRCF.CellReplay.Algebraic.MutationData0", + "HexRCF.CellReplay.Algebraic.Mutations", + "HexRCF.CellReplay.Algebraic.Refusals", + "HexRCF.CellReplay.Algebraic.Guards", + "HexRCF.CellReplay.Algebraic.Meaning", + "HexRCF.CellReplay.Algebraic.Boolean", + "HexRCF.CellReplay.Algebraic.BooleanSources", + "HexRCF.CellReplay.Algebraic.BooleanBinding", + "HexRCF.CellReplay.Algebraic.BooleanQuoted", + "HexRCF.CellBuildConformance", + "HexRCF.CellDiscoverLinear", + "HexRCF.CellDiscoverAlgebraic", + "HexRCF.CellDiscoverCases", + "HexRCF.CellDiscoverProofs", + "HexRCF.CellRequestedConformance", + "HexRCF.CellDecisionProofs", + "HexRCF.CellCodecProofs", + "HexRCF.CellExecutionProofs", + "HexRCF.NumberFieldCellsConformance", + "HexRCF.GatherCellsConformance", + "HexRCF.RealModelConformance", + "HexRCF.AlgebraicPreparationCases", + "HexRCF.AlgebraicPreparationConformance", + "HexRCF.SourceAcceptancePublic", + "HexRCF.AlgebraicCellsConformance", + "HexRCF.CellReplay.Algebraic.Canonical", + "HexRCF.CellReplay.Algebraic.Check", + "HexRCF.CellReplay.Algebraic.Convert", + "HexRCF.CellReplay.Algebraic.Inputs", + "HexRCF.CellReplay.Algebraic.LiteralData0", + "HexRCF.CellReplay.Algebraic.LiteralData1", + "HexRCF.CellReplay.Algebraic.Literals", + "HexRCF.CellReplay.Algebraic.Quote", + "HexRCF.CellReplay.Algebraic.Quoted", + "HexRCF.CellReplay.Algebraic.CompleteQuote", + "HexRCF.CellReplay.Algebraic.CompleteQuoted", + "HexRCF.CellReplay.Algebraic.Radical", + "HexRCF.CellReplay.Algebraic.Read", + "HexRCF.CellReplay.Algebraic.Records", + "HexRCF.CellReplay.Algebraic.ScalarData0", + "HexRCF.CellReplay.Algebraic.ScalarData1", + "HexRCF.CellReplay.Algebraic.Scalars", + "HexRCF.CellReplay.Algebraic.Schema", + "HexRCF.CellReplay.Algebraic.Sections", + "HexRCF.RealFormulaConformance", + "HexRCF.RealCoefficientsConformance", + "HexRCF.AlgebraicProgress", + "HexRCF.IsolationProgress", + "HexRCF.RadicalProgress", + "HexRCF.ProductionProgress", + "HexRCF.FieldRootsConformance", + "HexRCF.CertificationInputs", + "HexRCF.RationalSources", + "HexRCF.ProofEvidence", + "HexRCF.CheckedConversions", + "HexRCF.ReplayModes", + "HexRCF.CarrierModes", + "HexRCF.SignIndex", + "HexRCF.PreparedCoefficients", + "HexRCF.FiniteReplay", + "HexRCF.FiniteSignsConformance", + "HexRCF.CellReplay.OutsideLiterals", + "HexRCF.CellReplay.Zero", + "HexRCF.CellReplay.ZeroLiterals", + "HexRCF.CellReplay.Valuation", + "HexRCF.CellReplay.ModuleCheck", + "HexRCF.CellReplay.Schema", + "HexRCF.CellReplay.Check", + "HexRCF.CellReplay.Ordinary", + "HexRCF.CellReplay.Quote", + "HexRCF.CellReplay.Controls", + "HexRCF.CellReplay.Quoted", + "HexRCF.CellReplay.Refusals", + "HexRCF.CellReplay.Emit", + "HexRCF.CellReplay.LiteralData0", + "HexRCF.CellReplay.Literals", + "HexRCF.CellReplay.MutationData0", + "HexRCF.CellReplay.Mutations", + "HexRCF.FiniteMatrix.Binding", + "HexRCF.FiniteMatrix.Guards.Binding", + "HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "HexRCF.FiniteMatrix.Guards.Quotient.Records", + "HexRCF.FiniteMatrix.Guards.Quotient.Source", + "HexRCF.FiniteMatrix.Guards.Controls", + "HexRCF.FiniteMatrix.Guards.Data", + "HexRCF.FiniteMatrix.Guards.Domains", + "HexRCF.FiniteMatrix.Guards.Emit", + "HexRCF.FiniteMatrix.Guards.LiteralData0", + "HexRCF.FiniteMatrix.Guards.Literals", + "HexRCF.FiniteMatrix.Guards.Meaning", + "HexRCF.FiniteMatrix.Guards.MutationData0", + "HexRCF.FiniteMatrix.Guards.Mutations", + "HexRCF.FiniteMatrix.Guards.Ordinary", + "HexRCF.FiniteMatrix.Guards.Quote", + "HexRCF.FiniteMatrix.Guards.Read", + "HexRCF.FiniteMatrix.Guards.Records", + "HexRCF.FiniteMatrix.Guards.Refusals", + "HexRCF.FiniteMatrix.Guards.Schema", + "HexRCF.FiniteMatrix.Data", + "HexRCF.FiniteMatrix.Emit", + "HexRCF.FiniteMatrix.Inputs", + "HexRCF.FiniteMatrix.KernelControls", + "HexRCF.FiniteMatrix.LiteralData0", + "HexRCF.FiniteMatrix.LiteralData1", + "HexRCF.FiniteMatrix.LiteralData2", + "HexRCF.FiniteMatrix.LiteralData3", + "HexRCF.FiniteMatrix.LiteralData4", + "HexRCF.FiniteMatrix.LiteralData5", + "HexRCF.FiniteMatrix.Literals", + "HexRCF.FiniteMatrix.ModuleCheck", + "HexRCF.FiniteMatrix.Ordinary", + "HexRCF.FiniteMatrix.Packings", + "HexRCF.FiniteMatrix.Quote", + "HexRCF.FiniteMatrix.Controls", + "HexRCF.FiniteMatrix.Refusals", + "HexRCF.FiniteMatrix.Read", + "HexRCF.FiniteMatrix.Restore", + "HexRCF.FiniteMatrix.Schema", + "HexRCF.FiniteMatrix.Selected", + "HexRCF.FiniteMatrix.Semantics", + "HexRCF.FiniteMatrix.Signs", + "HexRCF.TowerSamples", + "HexRCF.Samples", + "HexRCF.RealizationData", + "HexRCF.Realization", + "HexRCF.NumberField", + "HexRCF.Gather", + "HexRCF.GatherCatalog", + "HexRCF.RegisteredGatherConformance", + "HexRCF.GeneratorWindowInputs", + "HexRCF.GeneratorWindow", + "HexRCF.CertificationProofs", + "HexRCF.SuppliedIrreducible", + "HexRCF.SuppliedIrreducibleProofs", + "HexRCF.SuppliedBudget", + "HexRCF.NativeFormulaConformance", + "HexRCF.NativeSpecializeConformance", + "HexRCF.NativeSamplesConformance", + "HexRCF.NativeSampleModelConformance", + "HexRCF.NativeSampleModelLiterals", + "HexRCF.NativeSourcesConformance", + "HexRCF.NativeSelectionLiterals", + "HexRCF.NativeSelectionConformance", + "HexRCF.NativeSelectionOrdinaryConformance", + "HexRCF.NativeSelectionOrderedConformance", + "HexRCF.SectionReplayConformance", + "HexRCF.SectionProduceConformance", + "HexRCF.SectionOrdinaryConformance", + "HexRCF.PointReplayConformance", + "HexRCF.PointProduceConformance", + "HexRCF.PointOrdinaryConformance", + "HexRCF.RootReplayLiterals", + "HexRCF.RootReplayConformance", + "HexRCF.RootReplayOrdinaryConformance", + "HexRCF.NestedRootLiterals", + "HexRCF.NestedRootProduceConformance", + "HexRCF.NestedRootOrdinaryConformance", + "HexRCF.RootTransportData", + "HexRCF.RootTransportLiterals", + "HexRCF.RootTransportConformance", + "HexRCF.RootTransportOrdinaryConformance", + "HexRCF.NestedTransport.Frame", + "HexRCF.NestedTransport.Context", + "HexRCF.NestedTransport.Map", + "HexRCF.NestedTransport.Conversion", + "HexRCF.NestedTransport.Fields", + "HexRCF.NestedTransport.Restore", + "HexRCF.NestedTransport.Predecessor", + "HexRCF.NestedTransport.Facts", + "HexRCF.NestedTransport.Constants", + "HexRCF.NestedTransport.Operations", + "HexRCF.NestedTransport.RootRead", + "HexRCF.NestedTransport.Read", + "HexRCF.NestedTransport.Model", + "HexRCF.NestedTransport.Source", + "HexRCF.NestedTransport.Ordinary", + "HexRCF.NestedTransport.Controls", + "HexRCF.NestedTransport.Literals", + "HexRCF.NestedTransport.EndpointLiterals", + "HexRCF.NestedTransport.SignLiterals", + "HexRCF.NestedTransport.SignData", + "HexRCF.TotalAlgebraicProofs", + "HexRCF.AlgebraicDivision", + "HexRCF.NormalizedCoefficients", + "HexRCF.NormalizedInputs", + "HexRCF.RegisteredConstants", + "HexRCF.NamedConstants", + "HexRCF.MixedConstants", + "HexRCF.CoarseConstants", + "HexRCF.RealCoefficientTactic", + "HexRCF.RealCoefficientCommonField", + "HexRCF.CommonFieldPresentation", + "HexRCF.RootAliasesConformance", + "HexRCF.RationalRoots", + "HexRCF.AlgebraicRoots", + "HexRCF.FormulaConformance", + "HexRCF.LiteralSignConformance", + "HexRCF.FieldSpecializeConformance", + "HexRCF.SignDetFieldProofs", + "HexRCF.AdmissionConformance", + "HexRCF.IsolationConformance", + "HexRCF.SelectedRoot.Packing", + "HexRCF.SelectedRoot.PackingData", + "HexRCF.SelectedRoot.InverseData", + "HexRCF.SelectedRoot.InverseReplay", + "HexRCF.SelectedRoot.InverseControls", + "HexRCF.InverseFixture", + "HexRCF.SelectedRoot.PackingReplay", + "HexRCF.SelectedRoot.PackingMissing", + "HexRCF.SelectedRoot.PackingAudit", + "HexRCF.SelectedRoot.CatalogData", + "HexRCF.SelectedRoot.CatalogByteData", + "HexRCF.SelectedRoot.CatalogSource", + "HexRCF.SelectedRoot.Catalog", + "HexRCF.SelectedRoot.CatalogBytes", + "HexRCF.SelectedRoot.CatalogControls", + "HexRCF.SelectedRoot.CatalogAudit", + "HexRCF.SelectedRoot.ByteAudit", + "HexRCF.SelectedRoot.ByteBounds", + "HexRCF.SelectedRoot.ByteChecks", + "HexRCF.SelectedRoot.ByteData", + "HexRCF.SelectedRoot.ByteProofs", + "HexRCF.SelectedRoot.Audit", + "HexRCF.SelectedRoot.Checks", + "HexRCF.SelectedRoot.Collect", + "HexRCF.SelectedRoot.Controls", + "HexRCF.SelectedRoot.Data", + "HexRCF.SelectedRoot.Frozen", + "HexRCF.SelectedRoot.FrozenCollect", + "HexRCF.SelectedRoot.KernelCheck", + "HexRCF.SelectedRoot.Intermediates", + "HexRCF.SelectedRoot.Literals", + "HexRCF.SelectedRoot.PacketFields", + "HexRCF.SelectedRoot.Packets", + "HexRCF.SelectedRoot.Proofs", + "HexRCF.SelectedRoot.Read", + "HexRCF.SelectedRoot.Refusals", + "HexRCF.SelectedRoot.ReplayTools", + "HexRCF.SelectedRoot.Row", + "HexRCF.SelectedRoot.RowCollect", + "HexRCF.SelectedRoot.RowIntermediates", + "HexRCF.SelectedRoot.RowTools", + "HexRCF.SelectedRoot.Source", + "HexRCF.SelectedRoot.Upper", + "HexRCF.PublicGraphCodec" + ], + "base_test_roots": [ + "HexRCF.LanguageTests", + "HexRCF.SturmBuilderTests", + "HexRCF.CarrierTests", + "HexRCF.IsolationsTests", + "HexRCF.SeparationTests", + "HexRCF.CellsTests", + "HexRCF.CommonRootTests", + "HexRCF.SignMatrixTests", + "HexRCF.BuilderTests", + "HexRCF.CertificateTests", + "HexRCF.DecisionTests", + "HexRCF.ReifyTests", + "HexRCF.HandlerTests.Support", + "HexRCF.HandlerTests.Async", + "HexRCF.HandlerTests", + "HexRCF.LintTests" + ], + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/lake-bounded", + "build", + "HexRCF", + "HexRCFRealCoefficients", + "+HexRCF.Conformance", + "+HexRCF.SourceIdentityKernel", + "+HexRCF.SourceIdentityCases", + "+HexRCF.MaximalCoefficientsKernel", + "+HexRCF.MaximalCoefficientsConformance", + "+HexRCF.MaximalCoefficients", + "+HexRCF.CellReplay.AssembledKernel", + "+HexRCF.CellReplay.Assembled", + "+HexRCF.CellReplay.OperationsPublic", + "+HexRCF.CellReplay.OperationsKernel", + "+HexRCF.CellReplay.Operations", + "+HexRCF.CellReplay.Algebraic.Emit", + "+HexRCF.CellReplay.Algebraic.MutationData0", + "+HexRCF.CellReplay.Algebraic.Mutations", + "+HexRCF.CellReplay.Algebraic.Refusals", + "+HexRCF.CellReplay.Algebraic.Guards", + "+HexRCF.CellReplay.Algebraic.Meaning", + "+HexRCF.CellReplay.Algebraic.Boolean", + "+HexRCF.CellReplay.Algebraic.BooleanSources", + "+HexRCF.CellReplay.Algebraic.BooleanBinding", + "+HexRCF.CellReplay.Algebraic.BooleanQuoted", + "+HexRCF.CellBuildConformance", + "+HexRCF.CellDiscoverLinear", + "+HexRCF.CellDiscoverAlgebraic", + "+HexRCF.CellDiscoverCases", + "+HexRCF.CellDiscoverProofs", + "+HexRCF.CellRequestedConformance", + "+HexRCF.CellDecisionProofs", + "+HexRCF.CellCodecProofs", + "+HexRCF.CellExecutionProofs", + "+HexRCF.NumberFieldCellsConformance", + "+HexRCF.GatherCellsConformance", + "+HexRCF.RealModelConformance", + "+HexRCF.AlgebraicPreparationCases", + "+HexRCF.AlgebraicPreparationConformance", + "+HexRCF.SourceAcceptancePublic", + "+HexRCF.AlgebraicCellsConformance", + "+HexRCF.CellReplay.Algebraic.Canonical", + "+HexRCF.CellReplay.Algebraic.Check", + "+HexRCF.CellReplay.Algebraic.Convert", + "+HexRCF.CellReplay.Algebraic.Inputs", + "+HexRCF.CellReplay.Algebraic.LiteralData0", + "+HexRCF.CellReplay.Algebraic.LiteralData1", + "+HexRCF.CellReplay.Algebraic.Literals", + "+HexRCF.CellReplay.Algebraic.Quote", + "+HexRCF.CellReplay.Algebraic.Quoted", + "+HexRCF.CellReplay.Algebraic.CompleteQuote", + "+HexRCF.CellReplay.Algebraic.CompleteQuoted", + "+HexRCF.CellReplay.Algebraic.Radical", + "+HexRCF.CellReplay.Algebraic.Read", + "+HexRCF.CellReplay.Algebraic.Records", + "+HexRCF.CellReplay.Algebraic.ScalarData0", + "+HexRCF.CellReplay.Algebraic.ScalarData1", + "+HexRCF.CellReplay.Algebraic.Scalars", + "+HexRCF.CellReplay.Algebraic.Schema", + "+HexRCF.CellReplay.Algebraic.Sections", + "+HexRCF.RealFormulaConformance", + "+HexRCF.RealCoefficientsConformance", + "+HexRCF.AlgebraicProgress", + "+HexRCF.IsolationProgress", + "+HexRCF.RadicalProgress", + "+HexRCF.ProductionProgress", + "+HexRCF.FieldRootsConformance", + "+HexRCF.CertificationInputs", + "+HexRCF.RationalSources", + "+HexRCF.ProofEvidence", + "+HexRCF.CheckedConversions", + "+HexRCF.ReplayModes", + "+HexRCF.CarrierModes", + "+HexRCF.SignIndex", + "+HexRCF.PreparedCoefficients", + "+HexRCF.FiniteReplay", + "+HexRCF.FiniteSignsConformance", + "+HexRCF.CellReplay.OutsideLiterals", + "+HexRCF.CellReplay.Zero", + "+HexRCF.CellReplay.ZeroLiterals", + "+HexRCF.CellReplay.Valuation", + "+HexRCF.CellReplay.ModuleCheck", + "+HexRCF.CellReplay.Schema", + "+HexRCF.CellReplay.Check", + "+HexRCF.CellReplay.Ordinary", + "+HexRCF.CellReplay.Quote", + "+HexRCF.CellReplay.Controls", + "+HexRCF.CellReplay.Quoted", + "+HexRCF.CellReplay.Refusals", + "+HexRCF.CellReplay.Emit", + "+HexRCF.CellReplay.LiteralData0", + "+HexRCF.CellReplay.Literals", + "+HexRCF.CellReplay.MutationData0", + "+HexRCF.CellReplay.Mutations", + "+HexRCF.FiniteMatrix.Binding", + "+HexRCF.FiniteMatrix.Guards.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Binding", + "+HexRCF.FiniteMatrix.Guards.Quotient.Controls", + "+HexRCF.FiniteMatrix.Guards.Quotient.Emit", + "+HexRCF.FiniteMatrix.Guards.Quotient.Literals", + "+HexRCF.FiniteMatrix.Guards.Quotient.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quotient.Quote", + "+HexRCF.FiniteMatrix.Guards.Quotient.Reader", + "+HexRCF.FiniteMatrix.Guards.Quotient.Records", + "+HexRCF.FiniteMatrix.Guards.Quotient.Source", + "+HexRCF.FiniteMatrix.Guards.Controls", + "+HexRCF.FiniteMatrix.Guards.Data", + "+HexRCF.FiniteMatrix.Guards.Domains", + "+HexRCF.FiniteMatrix.Guards.Emit", + "+HexRCF.FiniteMatrix.Guards.LiteralData0", + "+HexRCF.FiniteMatrix.Guards.Literals", + "+HexRCF.FiniteMatrix.Guards.Meaning", + "+HexRCF.FiniteMatrix.Guards.MutationData0", + "+HexRCF.FiniteMatrix.Guards.Mutations", + "+HexRCF.FiniteMatrix.Guards.Ordinary", + "+HexRCF.FiniteMatrix.Guards.Quote", + "+HexRCF.FiniteMatrix.Guards.Read", + "+HexRCF.FiniteMatrix.Guards.Records", + "+HexRCF.FiniteMatrix.Guards.Refusals", + "+HexRCF.FiniteMatrix.Guards.Schema", + "+HexRCF.FiniteMatrix.Data", + "+HexRCF.FiniteMatrix.Emit", + "+HexRCF.FiniteMatrix.Inputs", + "+HexRCF.FiniteMatrix.KernelControls", + "+HexRCF.FiniteMatrix.LiteralData0", + "+HexRCF.FiniteMatrix.LiteralData1", + "+HexRCF.FiniteMatrix.LiteralData2", + "+HexRCF.FiniteMatrix.LiteralData3", + "+HexRCF.FiniteMatrix.LiteralData4", + "+HexRCF.FiniteMatrix.LiteralData5", + "+HexRCF.FiniteMatrix.Literals", + "+HexRCF.FiniteMatrix.ModuleCheck", + "+HexRCF.FiniteMatrix.Ordinary", + "+HexRCF.FiniteMatrix.Packings", + "+HexRCF.FiniteMatrix.Quote", + "+HexRCF.FiniteMatrix.Controls", + "+HexRCF.FiniteMatrix.Refusals", + "+HexRCF.FiniteMatrix.Read", + "+HexRCF.FiniteMatrix.Restore", + "+HexRCF.FiniteMatrix.Schema", + "+HexRCF.FiniteMatrix.Selected", + "+HexRCF.FiniteMatrix.Semantics", + "+HexRCF.FiniteMatrix.Signs", + "+HexRCF.TowerSamples", + "+HexRCF.Samples", + "+HexRCF.RealizationData", + "+HexRCF.Realization", + "+HexRCF.NumberField", + "+HexRCF.Gather", + "+HexRCF.GatherCatalog", + "+HexRCF.RegisteredGatherConformance", + "+HexRCF.GeneratorWindowInputs", + "+HexRCF.GeneratorWindow", + "+HexRCF.CertificationProofs", + "+HexRCF.SuppliedIrreducible", + "+HexRCF.SuppliedIrreducibleProofs", + "+HexRCF.SuppliedBudget", + "+HexRCF.NativeFormulaConformance", + "+HexRCF.NativeSpecializeConformance", + "+HexRCF.NativeSamplesConformance", + "+HexRCF.NativeSampleModelConformance", + "+HexRCF.NativeSampleModelLiterals", + "+HexRCF.NativeSourcesConformance", + "+HexRCF.NativeSelectionLiterals", + "+HexRCF.NativeSelectionConformance", + "+HexRCF.NativeSelectionOrdinaryConformance", + "+HexRCF.NativeSelectionOrderedConformance", + "+HexRCF.SectionReplayConformance", + "+HexRCF.SectionProduceConformance", + "+HexRCF.SectionOrdinaryConformance", + "+HexRCF.PointReplayConformance", + "+HexRCF.PointProduceConformance", + "+HexRCF.PointOrdinaryConformance", + "+HexRCF.RootReplayLiterals", + "+HexRCF.RootReplayConformance", + "+HexRCF.RootReplayOrdinaryConformance", + "+HexRCF.NestedRootLiterals", + "+HexRCF.NestedRootProduceConformance", + "+HexRCF.NestedRootOrdinaryConformance", + "+HexRCF.RootTransportData", + "+HexRCF.RootTransportLiterals", + "+HexRCF.RootTransportConformance", + "+HexRCF.RootTransportOrdinaryConformance", + "+HexRCF.NestedTransport.Frame", + "+HexRCF.NestedTransport.Context", + "+HexRCF.NestedTransport.Map", + "+HexRCF.NestedTransport.Conversion", + "+HexRCF.NestedTransport.Fields", + "+HexRCF.NestedTransport.Restore", + "+HexRCF.NestedTransport.Predecessor", + "+HexRCF.NestedTransport.Facts", + "+HexRCF.NestedTransport.Constants", + "+HexRCF.NestedTransport.Operations", + "+HexRCF.NestedTransport.RootRead", + "+HexRCF.NestedTransport.Read", + "+HexRCF.NestedTransport.Model", + "+HexRCF.NestedTransport.Source", + "+HexRCF.NestedTransport.Ordinary", + "+HexRCF.NestedTransport.Controls", + "+HexRCF.NestedTransport.Literals", + "+HexRCF.NestedTransport.EndpointLiterals", + "+HexRCF.NestedTransport.SignLiterals", + "+HexRCF.NestedTransport.SignData", + "+HexRCF.TotalAlgebraicProofs", + "+HexRCF.AlgebraicDivision", + "+HexRCF.NormalizedCoefficients", + "+HexRCF.NormalizedInputs", + "+HexRCF.RegisteredConstants", + "+HexRCF.NamedConstants", + "+HexRCF.MixedConstants", + "+HexRCF.CoarseConstants", + "+HexRCF.RealCoefficientTactic", + "+HexRCF.RealCoefficientCommonField", + "+HexRCF.CommonFieldPresentation", + "+HexRCF.RootAliasesConformance", + "+HexRCF.RationalRoots", + "+HexRCF.AlgebraicRoots", + "+HexRCF.FormulaConformance", + "+HexRCF.LiteralSignConformance", + "+HexRCF.FieldSpecializeConformance", + "+HexRCF.SignDetFieldProofs", + "+HexRCF.AdmissionConformance", + "+HexRCF.IsolationConformance", + "+HexRCF.SelectedRoot.Packing", + "+HexRCF.SelectedRoot.PackingData", + "+HexRCF.SelectedRoot.InverseData", + "+HexRCF.SelectedRoot.InverseReplay", + "+HexRCF.SelectedRoot.InverseControls", + "+HexRCF.InverseFixture", + "+HexRCF.SelectedRoot.PackingReplay", + "+HexRCF.SelectedRoot.PackingMissing", + "+HexRCF.SelectedRoot.PackingAudit", + "+HexRCF.SelectedRoot.CatalogData", + "+HexRCF.SelectedRoot.CatalogByteData", + "+HexRCF.SelectedRoot.CatalogSource", + "+HexRCF.SelectedRoot.Catalog", + "+HexRCF.SelectedRoot.CatalogBytes", + "+HexRCF.SelectedRoot.CatalogControls", + "+HexRCF.SelectedRoot.CatalogAudit", + "+HexRCF.SelectedRoot.ByteAudit", + "+HexRCF.SelectedRoot.ByteBounds", + "+HexRCF.SelectedRoot.ByteChecks", + "+HexRCF.SelectedRoot.ByteData", + "+HexRCF.SelectedRoot.ByteProofs", + "+HexRCF.SelectedRoot.Audit", + "+HexRCF.SelectedRoot.Checks", + "+HexRCF.SelectedRoot.Collect", + "+HexRCF.SelectedRoot.Controls", + "+HexRCF.SelectedRoot.Data", + "+HexRCF.SelectedRoot.Frozen", + "+HexRCF.SelectedRoot.FrozenCollect", + "+HexRCF.SelectedRoot.KernelCheck", + "+HexRCF.SelectedRoot.Intermediates", + "+HexRCF.SelectedRoot.Literals", + "+HexRCF.SelectedRoot.PacketFields", + "+HexRCF.SelectedRoot.Packets", + "+HexRCF.SelectedRoot.Proofs", + "+HexRCF.SelectedRoot.Read", + "+HexRCF.SelectedRoot.Refusals", + "+HexRCF.SelectedRoot.ReplayTools", + "+HexRCF.SelectedRoot.Row", + "+HexRCF.SelectedRoot.RowCollect", + "+HexRCF.SelectedRoot.RowIntermediates", + "+HexRCF.SelectedRoot.RowTools", + "+HexRCF.SelectedRoot.Source", + "+HexRCF.SelectedRoot.Upper", + "+HexRCF.PublicGraphCodec", + "+HexRCF.LanguageTests", + "+HexRCF.SturmBuilderTests", + "+HexRCF.CarrierTests", + "+HexRCF.IsolationsTests", + "+HexRCF.SeparationTests", + "+HexRCF.CellsTests", + "+HexRCF.CommonRootTests", + "+HexRCF.SignMatrixTests", + "+HexRCF.BuilderTests", + "+HexRCF.CertificateTests", + "+HexRCF.DecisionTests", + "+HexRCF.ReifyTests", + "+HexRCF.HandlerTests.Support", + "+HexRCF.HandlerTests.Async", + "+HexRCF.HandlerTests", + "+HexRCF.LintTests", + "HexRCFProofProbe", + "HexManual" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "scope": "All 263 actual HexRCF HexConformance roots, all16 base HexReleaseTests roots, both libraries, actual registered-constant proof probes and full manual, after original guard-inventory and recursion fixes." +} diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-browser-4.log.gz b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-browser-4.log.gz new file mode 100644 index 0000000000..0021a78b53 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-browser-4.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-browser-selection-4.json b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-browser-selection-4.json new file mode 100644 index 0000000000..67cb4c97ae --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-browser-selection-4.json @@ -0,0 +1,12 @@ +{ + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/run-bounded", + "node", + "/home/kim/.codex/tasks/hex-10358/source-acceptance-browser.mjs", + "/home/kim/.codex/tasks/hex-10358/atomic-public-current" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/atomic-public-current", + "script_sha256": "ba772a7b3a4609c57ba96f0a7c58764afef1a1fd19c13a0a9b807928e09b0eb2", + "scope": "Six actual desktop/narrow captures and local changed-content overflow checks after fresh full manual render." +} diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-browser.mjs b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-browser.mjs new file mode 100644 index 0000000000..e4cddba948 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-browser.mjs @@ -0,0 +1,50 @@ +import fs from 'node:fs'; +import {spawn} from 'node:child_process'; +const root=process.argv[2]; +if(!root) throw new Error('Pass the scratch render directory'); +const profile=root+'/source-acceptance-profile'; +fs.mkdirSync(profile,{recursive:true}); +fs.rmSync(profile+'/DevToolsActivePort',{force:true}); +const chrome=spawn(process.env.CHROME_BIN || '/home/kim/.cache/ms-playwright/chromium-1243/chrome-linux64/chrome',[ + '--headless=new','--no-sandbox','--disable-gpu','--allow-file-access-from-files', + '--remote-debugging-port=0','--remote-allow-origins=*','--user-data-dir='+profile,'about:blank'], + {env:{...process.env,LD_LIBRARY_PATH:fs.readFileSync(root+'/browser-lib-paths.txt','utf8').trim()},stdio:'ignore'}); +let socket; +try { + const portFile=profile+'/DevToolsActivePort'; + for(let i=0;!fs.existsSync(portFile);i++) { + if(i>200||chrome.exitCode!==null) throw new Error('Chrome did not expose CDP'); + await new Promise(r=>setTimeout(r,100)); + } + const port=fs.readFileSync(portFile,'utf8').split('\n')[0]; + const tabs=await (await fetch('http://127.0.0.1:'+port+'/json')).json(); + socket=new WebSocket(tabs.find(t=>t.type==='page').webSocketDebuggerUrl); + await new Promise((r,j)=>{socket.onopen=r;socket.onerror=j}); + let sequence=0;const pending=new Map();let loaded; + socket.onmessage=e=>{ + const msg=JSON.parse(e.data); + if(msg.id){const p=pending.get(msg.id);pending.delete(msg.id);msg.error?p.reject(msg.error):p.resolve(msg.result);} + if(msg.method==='Page.loadEventFired'&&loaded){loaded();loaded=undefined;} + }; + const call=(method,params={})=>new Promise((resolve,reject)=>{const id=++sequence;pending.set(id,{resolve,reject});socket.send(JSON.stringify({id,method,params}));}); + await call('Page.enable'); + const load=new Promise(r=>loaded=r); + await call('Page.navigate',{url:'file://'+root+'/source-acceptance-html/html-single/index.html'}); + await load; + const evaluate=async expression=>{const r=await call('Runtime.evaluate',{expression,returnByValue:true});if(r.exceptionDetails)throw new Error(JSON.stringify(r.exceptionDetails));return r.result.value;}; + const metadata=[]; + for(const [label,width] of [['desktop',1440],['narrow',390]]) { + await call('Emulation.setDeviceMetricsOverride',{width,height:1000,deviceScaleFactor:1,mobile:false}); + for(const [kind,phrase] of [['equivalence','For the retained algebraic expressions,'],['example','no successful child calculation is assumed.'],['boundary','This proof uses the checked algebraic expressions']] ) { + const exact=await evaluate(`(() => {const p=Array.from(document.querySelectorAll('p')).find(e=>e.textContent.includes(${JSON.stringify(phrase)}));if(!p)throw new Error('missing paragraph');const target=${JSON.stringify(kind)}==='example'?p.nextElementSibling:p;if(${JSON.stringify(kind)}==='example'&&!target.matches('.hl.lean.block, pre, div:has(code)'))throw new Error('target is not a Lean code block');target.scrollIntoView({block:${JSON.stringify('center')}});return {text:p.textContent,viewport:innerWidth,scrollY,paragraphWidth:p.getBoundingClientRect().width,scrollWidth:p.scrollWidth,targetTag:target.tagName,targetWidth:target.getBoundingClientRect().width,targetScrollWidth:target.scrollWidth,descendantOverflow:Math.max(0,...[target,...target.querySelectorAll('*')].map(e=>e.scrollWidth-e.clientWidth)),overflowElements:[target,...target.querySelectorAll('*')].filter(e=>e.scrollWidth-e.clientWidth>1).map(e=>({tag:e.tagName,classes:e.className,width:e.clientWidth,scroll:e.scrollWidth,text:e.textContent.slice(0,100)})).slice(0,8)};})()`); + if(!exact)throw new Error('missing visual target '+kind); + await evaluate('new Promise(resolve=>requestAnimationFrame(()=>requestAnimationFrame(resolve)))'); + const shot=await call('Page.captureScreenshot',{format:'png'}); + fs.writeFileSync(root+'/'+'source-acceptance-'+label+'-'+kind+'.png',Buffer.from(shot.data,'base64')); + metadata.push({label,kind,...exact}); + } + } + fs.writeFileSync(root+'/source-acceptance-inspection.json',JSON.stringify(metadata,null,2)); + if(metadata.some(e=>e.targetScrollWidth>e.targetWidth+1 || e.descendantOverflow>1)) throw new Error('Changed content overflows; retained captures and metrics identify the affected block.'); + process.stdout.write('Saved source acceptance desktop/narrow screenshots\n'); +} finally {if(socket)socket.close();chrome.kill('SIGTERM');} diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-budget-followup-1.log.gz b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-budget-followup-1.log.gz new file mode 100644 index 0000000000..a9da2fa255 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-budget-followup-1.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-budget-followup-selection-1.json b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-budget-followup-selection-1.json new file mode 100644 index 0000000000..d54c983525 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-budget-followup-selection-1.json @@ -0,0 +1,17 @@ +{ + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "source_tree": "55844661fe0c6670fcee1a397cdb947fac228c98", + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/lake-bounded", + "build", + "HexRCF", + "HexRCFRealCoefficients", + "+HexRCF.AlgebraicPreparationCases", + "+HexRCF.AlgebraicPreparationConformance", + "+HexRCF.SourceAcceptancePublic", + "HexRCFProofProbe", + "HexManual" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/boolean-worktree", + "scope": "Focused additional source-budget/alias-scan/control regressions, fresh source acceptance bodies and axiom audit, ordinary public consumer, libraries, caller proof probes and full manual after the complete6f compatibility run. Production source differs only by the guards docstring." +} diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-copyright-6.log b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-copyright-6.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-copyright-7.log b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-copyright-7.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-dag-6.log b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-dag-6.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-dag-7.log b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-dag-7.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-desktop-boundary.png b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-desktop-boundary.png new file mode 100644 index 0000000000..b3c324ef5d Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-desktop-boundary.png differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-desktop-equivalence.png b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-desktop-equivalence.png new file mode 100644 index 0000000000..9328aacc17 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-desktop-equivalence.png differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-desktop-example.png b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-desktop-example.png new file mode 100644 index 0000000000..9bbe006eae Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-desktop-example.png differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-inspection.json b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-inspection.json new file mode 100644 index 0000000000..eb4add2a3b --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-inspection.json @@ -0,0 +1,86 @@ +[ + { + "label": "desktop", + "kind": "equivalence", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe helper reconstructs the ordered original guard inventory from the target;\nediting both stored guard arrays cannot remove or replace an obligation.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 1440, + "scrollY": 272729, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "P", + "targetWidth": 752, + "targetScrollWidth": 752, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "desktop", + "kind": "example", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe helper reconstructs the ordered original guard inventory from the target;\nediting both stored guard arrays cannot remove or replace an obligation.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 1440, + "scrollY": 273142, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "CODE", + "targetWidth": 740, + "targetScrollWidth": 740, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "desktop", + "kind": "boundary", + "text": "\n This proof uses the checked algebraic expressions and their source identities.\nIt does not identify separately computed proposals with frozen literals,\nreconstruct provider histories, or add a tactic handler. Those authentication\nand quotation obligations remain separate. The helper continues the same\naggregate reflection budget, returns its updated usage for later stages, and\nrestores caller state on exhaustion or failure.\nCallers continue with {prepared with usage} when constructing further proofs.\nBoth preparation and acceptance preserve a caller's lowered recursion limit.\nFresh importing regressions check its actual theorem bodies, true and false\nsources, retained zero guards and reversed intervals, with exactly the standard\nthree axioms.", + "viewport": 1440, + "scrollY": 273566, + "paragraphWidth": 752, + "scrollWidth": 752, + "targetTag": "P", + "targetWidth": 752, + "targetScrollWidth": 752, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "equivalence", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe helper reconstructs the ordered original guard inventory from the target;\nediting both stored guard arrays cannot remove or replace an obligation.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 390, + "scrollY": 436942, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "P", + "targetWidth": 343, + "targetScrollWidth": 343, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "example", + "text": "\n For the retained algebraic expressions, prepared.acceptanceIff proves an exact\nacceptance equivalence. The left side requires the actual algebraic producer\nto return a complete packet and that packet's checker to accept true. The\nright side contains both the original real statement and every original\ndivisor's nonzero condition. Guard validity is a conclusion of acceptance,\neven when cancellation or an empty interval makes the statement trivial.\nThe helper reconstructs the ordered original guard inventory from the target;\nediting both stored guard arrays cannot remove or replace an obligation.\nThe existing producer completeness and domain laws prove this equivalence;\nno successful child calculation is assumed.", + "viewport": 390, + "scrollY": 437482, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "CODE", + "targetWidth": 331, + "targetScrollWidth": 331, + "descendantOverflow": 0, + "overflowElements": [] + }, + { + "label": "narrow", + "kind": "boundary", + "text": "\n This proof uses the checked algebraic expressions and their source identities.\nIt does not identify separately computed proposals with frozen literals,\nreconstruct provider histories, or add a tactic handler. Those authentication\nand quotation obligations remain separate. The helper continues the same\naggregate reflection budget, returns its updated usage for later stages, and\nrestores caller state on exhaustion or failure.\nCallers continue with {prepared with usage} when constructing further proofs.\nBoth preparation and acceptance preserve a caller's lowered recursion limit.\nFresh importing regressions check its actual theorem bodies, true and false\nsources, retained zero guards and reversed intervals, with exactly the standard\nthree axioms.", + "viewport": 390, + "scrollY": 438034, + "paragraphWidth": 343, + "scrollWidth": 343, + "targetTag": "P", + "targetWidth": 343, + "targetScrollWidth": 343, + "descendantOverflow": 0, + "overflowElements": [] + } +] \ No newline at end of file diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-lines-6.log b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-lines-6.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-lines-7.log b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-lines-7.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-narrow-boundary.png b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-narrow-boundary.png new file mode 100644 index 0000000000..8fb96e5a18 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-narrow-boundary.png differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-narrow-equivalence.png b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-narrow-equivalence.png new file mode 100644 index 0000000000..ae4a83afb9 Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-narrow-equivalence.png differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-narrow-example.png b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-narrow-example.png new file mode 100644 index 0000000000..e6dbd507fd Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-narrow-example.png differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-render-4.log.gz b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-render-4.log.gz new file mode 100644 index 0000000000..9ec3fc30ab Binary files /dev/null and b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-render-4.log.gz differ diff --git a/reports/data/hexrcf-source-acceptance/validation/source-acceptance-render-selection-4.json b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-render-selection-4.json new file mode 100644 index 0000000000..31acfce180 --- /dev/null +++ b/reports/data/hexrcf-source-acceptance/validation/source-acceptance-render-selection-4.json @@ -0,0 +1,14 @@ +{ + "source_commit": "cdc9b747aafee5970f7e818a28ff89c1ca343ec6", + "argv": [ + "/home/kim/.codex/tasks/hex-10358/bin/run-bounded", + "env", + "LAKE_NO_CACHE=true", + "lake", + "build", + "+AuditImportProbe", + "+SourceAcceptanceRender4" + ], + "cwd": "/home/kim/.codex/tasks/hex-10358/atomic-public-current", + "scope": "Fresh manual render and joint fresh source-body-audit plus complete-manual import." +} diff --git a/reports/hexrcf-source-acceptance.md b/reports/hexrcf-source-acceptance.md new file mode 100644 index 0000000000..e7ec12076b --- /dev/null +++ b/reports/hexrcf-source-acceptance.md @@ -0,0 +1,143 @@ +# Acceptance at original algebraic sources + +`AlgebraicCells.accepts` states two concrete facts: the existing algebraic +producer returns a packet, and the complete packet checker returns accepted +true. Its source tuple, coefficient indices, original-divisor indices, shared +matrix and quantifier are fixed arguments. This is mathematical acceptance +of the actual total producer and checker, not a new certificate format. + +`accepts_iff` proves that acceptance is equivalent to every original real +divisor being nonzero and the shared sentence holding at its original fixed +algebraic values. It composes the existing `build_complete`, `build_sound` +and `build_domains` laws. It assumes no successful child calculation, supplied +root table or sector function. `accepts_tuple` separates ordered coefficient +and divisor coordinates. `accepts_source` transports that result through +checked source identities and the shared frontend's exact original-goal +equivalence. A semantically trivial source does not remove its divisor +conjuncts: an empty domain with an original zero divisor remains invalid. + +`AlgebraicPreparation.Inputs.acceptanceIff` constructs this proof from the +retained kernel algebraic expressions. It checks each expression and its exact +`toReal` equality, constructs the ordered finite functions, reads the quantifier +and matrix from the checked source formula, and checks the source equivalence. +It reconstructs the ordered divisor inventory from the original target and +rejects omitted or replaced guards, even when both public arrays are edited. +It does not use the separately evaluated runtime proposals or the editable +runtime formula/quantifier fields as proof evidence. The result's right side +is exactly the original real target together with all original nonzero guards. + +The helper continues the preparation's aggregate reflection budget, including +the additional source scan and alias-proof check. Callers thread returned usage +with `{prepared with usage}` into subsequent stages. It charges +proofs before checking them, returns the updated aggregate usage for later +stages, preserves caller metavariables on success and +restores the complete state after exhaustion or failure. Successful private +proof auxiliaries remain available for the returned ordinary proof. + +Source-specific consumers cover rational zero-coordinate input, an +irrational positive source, a false source, both original quotient/inverse +occurrences, a cancelled semantically zero divisor, reversed intervals with +and without a zero divisor, and a local real alias with its equality hypothesis. +They compare the exact original target and ordered source-expression tuple. +Editing runtime proposals, the runtime matrix and the runtime quantifier must +leave the returned theorem type unchanged. Continued usage must increase; +one node below the measured cumulative proof limit refuses, and the exact +limit succeeds. Source-node tests check continued growth and exact limits as +well. The alias consumer uses distinct original and substituted source sizes, +so charging the original view twice cannot satisfy its accounting assertion. +Unchanged records succeed after the forgery tests with caller metavariables +preserved. Heartbeat, recursion and interruption entry checks remain +terminal, with state/declaration rollback. Separate lowered-depth tests enter +both preparation and acceptance at depth zero and require a recursion exception +inside the operation. They do not force interruption halfway through kernel +checking. Edited coefficient/divisor identities and exhausted-budget cases +exercise rollback after auxiliary proof work. Missing guards and same-count +replacement guards with valid identities are rejected independently of those +identity-mutation tests. + +A fresh importing module checks the actual theorem bodies and their transitive +axiom closure, requiring the real producer completeness and domain laws. An +ordinary-public-import consumer unfolds `accepts` and constructs an accepted +empty-input packet from `build_complete`, without an acceptance premise. +Its body is included in the fresh audit. The only axioms are `propext`, +`Classical.choice` and `Quot.sound`. + +The [guard and budget validation record](data/hexrcf-source-acceptance/validation/record.json) +binds the complete selection at `6f0ae423ab` and focused additional regressions +at `cdc9b747aa`. The full selection contains all 263 RCF conformance roots, +16 base-test roots, both libraries, caller-supplied π/e proof probes and the +complete manual. It passes 14,610 jobs in 25m29.596s at 10.7 GiB peak/no swap. +The follow-up changes only conformance tests and the public guard scanner's +docstring; production definitions remain unchanged. Its source-budget, +distinct-alias and unchanged-record regressions, fresh body/axiom audit, +ordinary-public consumer, libraries, caller probes and full manual pass 14,322 +jobs in 7m53.580s at 7.8 GiB/no swap. Both snapshots pass DAG/umbrella, +copyright, line and admission checks. The record includes the live cgroup +observation bound to the full selection's actual Lake process and arguments. +These are build observations with dependency work, not matched performance +comparisons or isolated replay/scaling measurements. +The fresh render and joint audit/manual import pass 14,317 jobs in 11.803s +at 2 GiB/no swap. All six new desktop/narrow captures were opened and their +changed-content overflow checks pass; other book content is excluded. The +browser capture run takes 10.733s at 8 GiB/no swap under the same aggregate cap. + +The expanded consumer selection at `b1f0c80539` has 11,036 jobs, takes +3m14.332s and peaks at 4 GiB with no swap. Its manual/dependency selection +passes 11,681 jobs in 6m19.764s at 13.1 GiB; the actual revised chapter rebuilds +in 5.9s. At `466e399045`, retained identities consume the cumulative +preparation budget and acceptance preserves a caller's lowered recursion limit +through the options wrapper. The combined consumer, fresh +body-audit, public-import and manual selection passes 11,681 jobs in 2m44.798s +at 3.6 GiB. The chapter takes 5.2s. These observations include incremental +dependency work and different test scopes; they are not matched performance +comparisons or isolated replay/scaling measurements. + +All own local builds remain serial under 32 GiB aggregate memory, no swap and +two Lean threads. Successful calls retain private proof auxiliaries for the +returned evidence. Repeated retention and guard-only algebraic inputs contribute +to the remaining depth, memory and expanded-work measurements. + +This does not prove a computed proposal equal to a frozen literal or reconstruct +provider/predecessor histories. It does not install a generic tactic handler, +authenticate a compiled complete packet, establish strict rejection of missing +intermediate records, or close #10358. General literal-source quotation, +resource-scheduled acceptance, realization and remaining stress/performance +work retain their own obligations. The manual explains the distinction and +runs the meta helper on an original irrational-coefficient statement. + +At `25c5f7afac`, the complete selection of all 263 RCF conformance roots, +all 16 base-test roots, both libraries, the actual caller-supplied π/e proof +probes and the full manual passes 14,610 jobs in 51m21.530s, with a 12.8 GiB +peak and no swap. This is a build observation with dependency work included, +not an isolated algorithm measurement or a matched comparison. + +The runnable example's extra kernel check uses a module-private auxiliary name +to avoid generated-theorem collisions across chapters. The diagnostic archive +contains the unscoped failure separately from successful checks. The full manual +at `25c5f7afac` passes 14,311 jobs in +2m36.421s at 2.1 GiB. The final single-page HTML render passes 14,313 jobs in +11.503s at 1.4 GiB. All six desktop and narrow captures of the acceptance +paragraph, runnable example and limitation paragraph were opened. Their local +overflow checks pass after shortening the example's lines. This does not +assert that the rest of the book has no horizontal overflow. + +A fresh ordinary-import probe also imports the source-acceptance audit and +the complete manual together. It passes 14,317 jobs in 15.473s at 3.3 GiB, +so the retained audit is composable with the corrected manual. + +The [parent integration record](data/hexrcf-source-acceptance/integration/record.json) +binds the merged parent `2bde7905ed` to focused checks at `dd32822835`. +At that snapshot, every Lean source, the Lake manifest, toolchain and library +metadata are unchanged from +the complete selection at `25c5f7afac`. The focused integration passes 14,322 +jobs in 4.965s at 307.2 MiB with no swap; this is a warm build, not a matched +performance comparison. DAG/umbrella, copyright, line and admission checks +also pass at the integrated source. + +The [source-bound record](data/hexrcf-source-acceptance/context.json) retains +the exact selection, code and script hashes, scoped proof/build logs, +metadata commands and captures. The +[complete selection log](data/hexrcf-source-acceptance/source-acceptance-all-1.log.gz) +and [final render log](data/hexrcf-source-acceptance/source-acceptance-render-3.log.gz) +are separate from the +[failed import diagnostic](data/hexrcf-source-acceptance/source-acceptance-render-1.log.gz).