Finite split-Gibbs weights, normalization, closure, and boundary gates
DefinitionFiniteSplitGibbsMethodsIIFor a finite type and a real weight , define and ; a probability weight is pointwise nonnegative and has total mass one. For finite and finite feature type , the bundle applies these notions to on , and defines its partition function, normalized split weight, and reflected observable kernel. It also defines absorption of a common half-factor, products of split data, coefficient scaling, and inverse-partition scaling. The controls include the two-point symmetric weight, its configuration and normalized weights, delta observables, and zero split data. Eight proposition gates specify the theorem boundary. The substantive gate proofs are separate theorem items.
import Definitions.Def_FiniteReflectionPositivityMethodsI
import Mathlib.Algebra.BigOperators.Field
noncomputable section
open scoped BigOperators
namespace FiniteSplitGibbsMethodsII
open FiniteReflectionPositivityMethodsI
/-! ## Generic finite normalization -/
def partitionFunction {Omega : Type*} [Fintype Omega]
(weight : Omega -> Real) : Real :=
∑ omega, weight omega
def normalizedWeight {Omega : Type*} [Fintype Omega]
(weight : Omega -> Real) (omega : Omega) : Real :=
weight omega / partitionFunction weight
def IsProbabilityWeight {Omega : Type*} [Fintype Omega]
(weight : Omega -> Real) : Prop :=
(forall omega, 0 <= weight omega) ∧ ∑ omega, weight omega = 1
/-! ## Split finite Gibbs weights -/
def splitWeightFunction {X A : Type*} [Fintype A]
(data : SplitWeightData X A) : FullConfiguration X -> Real :=
fun omega => data.weight omega.1 omega.2
def splitPartitionFunction {X A : Type*} [Fintype X] [Fintype A]
(data : SplitWeightData X A) : Real :=
partitionFunction (splitWeightFunction data)
def normalizedSplitWeight {X A : Type*} [Fintype X] [Fintype A]
(data : SplitWeightData X A) (left right : X) : Real :=
data.weight left right / splitPartitionFunction data
def normalizedReflectedKernel
{X A I : Type*} [Fintype X] [Fintype A]
(data : SplitWeightData X A) (observable : I -> X -> Real) :
Matrix I I Real :=
reflectedKernel (normalizedSplitWeight data) observable
/-! ## Closure operations on split data -/
def absorbHalfFactors {X A : Type*}
(half : X -> Real) (data : SplitWeightData X A) :
SplitWeightData X A where
coefficient := data.coefficient
feature := fun a x => half x * data.feature a x
def productSplitWeightData {X A B : Type*}
(first : SplitWeightData X A) (second : SplitWeightData X B) :
SplitWeightData X (A × B) where
coefficient := fun ab =>
first.coefficient ab.1 * second.coefficient ab.2
feature := fun ab x => first.feature ab.1 x * second.feature ab.2 x
def scaledSplitWeightData {X A : Type*}
(scale : Real) (data : SplitWeightData X A) : SplitWeightData X A where
coefficient := fun a => scale * data.coefficient a
feature := data.feature
def normalizedSplitData {X A : Type*} [Fintype X] [Fintype A]
(data : SplitWeightData X A) : SplitWeightData X A :=
scaledSplitWeightData (splitPartitionFunction data)⁻¹ data
/-! ## Frozen controls -/
def pointwiseNonnegativeSymmetricWeight : Fin 2 -> Fin 2 -> Real :=
fun i j => if i = j then 1 else 2
def pointwiseNonnegativeConfigurationWeight :
FullConfiguration (Fin 2) -> Real :=
fun omega => pointwiseNonnegativeSymmetricWeight omega.1 omega.2
def normalizedPointwiseNonnegativeWeight : Fin 2 -> Fin 2 -> Real :=
fun i j =>
normalizedWeight pointwiseNonnegativeConfigurationWeight (i, j)
def deltaObservable (i x : Fin 2) : Real :=
if x = i then 1 else 0
def zeroSplitWeightData (X : Type*) : SplitWeightData X (Fin 1) where
coefficient := fun _ => 0
feature := fun _ _ => 1
/-! ## Eight-node theorem gates -/
def PartitionNormalizationGate : Prop :=
forall (Omega : Type) [Fintype Omega] (weight : Omega -> Real),
(forall omega, 0 <= weight omega) ->
(exists omega, 0 < weight omega) ->
0 < partitionFunction weight ∧
IsProbabilityWeight (normalizedWeight weight)
def HalfFactorClosureGate : Prop :=
forall (X A : Type) [Fintype A]
(half : X -> Real) (data : SplitWeightData X A),
(forall left right,
(absorbHalfFactors half data).weight left right =
half left * half right * data.weight left right) ∧
((forall a, 0 <= data.coefficient a) ->
forall a, 0 <= (absorbHalfFactors half data).coefficient a) ∧
((forall x, 0 <= half x) ->
(forall left right, 0 <= data.weight left right) ->
forall left right,
0 <= (absorbHalfFactors half data).weight left right)
def ProductClosureGate : Prop :=
forall (X A B : Type) [Fintype A] [Fintype B]
(first : SplitWeightData X A) (second : SplitWeightData X B),
(forall left right,
(productSplitWeightData first second).weight left right =
first.weight left right * second.weight left right) ∧
((forall a, 0 <= first.coefficient a) ->
(forall b, 0 <= second.coefficient b) ->
forall ab,
0 <= (productSplitWeightData first second).coefficient ab) ∧
((forall left right, 0 <= first.weight left right) ->
(forall left right, 0 <= second.weight left right) ->
forall left right,
0 <= (productSplitWeightData first second).weight left right)
def NormalizedReflectionPositivityGate : Prop :=
forall (X A I : Type) [Fintype X] [Fintype A] [Fintype I]
(data : SplitWeightData X A),
(forall a, 0 <= data.coefficient a) ->
0 < splitPartitionFunction data ->
forall observable : I -> X -> Real,
PositiveSemidefinite (normalizedReflectedKernel data observable)
def NormalizedSplitGibbsGate : Prop :=
forall (X A I : Type) [Fintype X] [Fintype A] [Fintype I]
(data : SplitWeightData X A),
(forall a, 0 <= data.coefficient a) ->
(forall left right, 0 <= data.weight left right) ->
(exists left right, 0 < data.weight left right) ->
forall observable : I -> X -> Real,
IsProbabilityWeight
(fun omega : FullConfiguration X =>
normalizedSplitWeight data omega.1 omega.2) ∧
PositiveSemidefinite (normalizedReflectedKernel data observable) ∧
forall i j,
normalizedReflectedKernel data observable i j ^ 2 <=
normalizedReflectedKernel data observable i i *
normalizedReflectedKernel data observable j j
def PointwisePositiveNoGoGate : Prop :=
(forall i j, 0 <= pointwiseNonnegativeSymmetricWeight i j) ∧
(forall i j,
pointwiseNonnegativeSymmetricWeight i j =
pointwiseNonnegativeSymmetricWeight j i) ∧
0 < partitionFunction pointwiseNonnegativeConfigurationWeight ∧
IsProbabilityWeight
(normalizedWeight pointwiseNonnegativeConfigurationWeight) ∧
¬ PositiveSemidefinite pointwiseNonnegativeSymmetricWeight ∧
¬ PositiveSemidefinite
(reflectedKernel pointwiseNonnegativeSymmetricWeight deltaObservable) ∧
¬ PositiveSemidefinite
(reflectedKernel normalizedPointwiseNonnegativeWeight deltaObservable)
def ZeroWeightNoGoGate : Prop :=
(forall (X : Type) (a : Fin 1),
0 <= (zeroSplitWeightData X).coefficient a) ∧
(forall (X : Type) (left right : X),
0 <= (zeroSplitWeightData X).weight left right) ∧
(forall (X : Type) [Fintype X],
splitPartitionFunction (zeroSplitWeightData X) = 0) ∧
(forall (X I : Type) [Fintype X] [Fintype I]
(observable : I -> X -> Real),
PositiveSemidefinite
(reflectedKernel (zeroSplitWeightData X).weight observable)) ∧
forall (X : Type) [Fintype X],
¬ IsProbabilityWeight
(fun omega : FullConfiguration X =>
normalizedSplitWeight (zeroSplitWeightData X) omega.1 omega.2)
def ClaimBoundary : Prop :=
PartitionNormalizationGate ∧
HalfFactorClosureGate ∧
ProductClosureGate ∧
NormalizedReflectionPositivityGate ∧
NormalizedSplitGibbsGate ∧
PointwisePositiveNoGoGate ∧
ZeroWeightNoGoGate
end FiniteSplitGibbsMethodsII
Read-back
What the Lean code literally says, in plain math · gpt-5
For a finite type and a real-valued function on it, write and , where division is the total real-number division operation (so division by zero has its formal value). Call a probability weight exactly when every and \\sum_\\omega w(\\omega)=1. A split datum on a type , with feature index type , has coefficients , features , and its associated split weight is denoted ; a full configuration is a pair . Its split partition function is when and are finite, its normalized split weight is , and, for observables , its normalized reflected kernel is the reflected-kernel matrix formed from that normalized weight and those observables. Positive semidefiniteness means nonnegativity of every real quadratic form of the matrix. The proposition ClaimBoundary is the conjunction of all seven of the following assertions. (1) For every type equipped with a finite-type structure and every , if all values of are nonnegative and at least one value is strictly positive, then and is a probability weight. Thus the universally quantified types include the empty type, although on it the strict-positivity hypothesis cannot be met. (2) For every type , every finite type , every , and every split datum indexed by , let retain the coefficients of and replace each feature by . Then, simultaneously, for every ; if every coefficient of is nonnegative, every coefficient of is nonnegative; and if every and every are nonnegative, every is nonnegative. No finiteness assumption is made on . (3) For every type , finite types and , and split data and indexed respectively by and , form indexed by with coefficient and feature . Then, simultaneously, for every ; nonnegativity of all coefficients of each input implies nonnegativity of all product coefficients; and pointwise nonnegativity of both input weights implies pointwise nonnegativity of the product weight. Again, need not be finite. (4) For every finite types , , and , every split datum indexed by , and every family of observables , if every coefficient of is nonnegative and , then the reflected-kernel matrix formed from and is positive semidefinite. (5) For every finite types , , and , every split datum indexed by , and every family of observables , if all coefficients of are nonnegative, all values are nonnegative, and there exist with , then the function is a probability weight on , the corresponding reflected-kernel matrix is positive semidefinite, and, for every , . The quantified finite types may in principle be empty, but the existence hypothesis rules out an empty ; no analogous inhabitance premise is imposed on or . (6) On , define when and otherwise; regard the same rule as a weight on ordered pairs, normalize it by its sum over all four pairs, and let be when and otherwise. Then all are nonnegative, is symmetric, its partition function is strictly positive, its normalized ordered-pair weight is a probability weight, the matrix is not positive semidefinite, the reflected kernel made from and the delta observables is not positive semidefinite, and the reflected kernel made from the normalized weight and the delta observables is not positive semidefinite. (7) For every type , define a split datum with the single index in , coefficient zero, and constant feature . Then, simultaneously, its sole coefficient is nonnegative for every ; is nonnegative for every and every ; for every finite , its split partition function is zero; for every finite and finite and every observable family, the reflected kernel formed from its unnormalized zero weight is positive semidefinite; and, for every finite , the normalized split weight is not a probability weight. This last universal assertion includes empty ; total real division makes every normalized value zero, and in all cases the required total mass is not .