Constructed slices · row and column tables · zero dimensions

Actual rectangular sums and finite Fubini

Construct actual signed affine slices and row-sum tables, then prove equality of row-first and column-first totals by ordinary finite induction.

32 kernel- and Lean-verified Alpha-closed theorems · 18 conservative definitions · 34 notation dependencies

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable

Current library: Alpha v34, 4,223 checked-use theorems; Stable remains 432. Historical first admissions, original proof editions, and non-admitted aliases are preserved.

50 items
RS0001 signed_rectangular_slice_lookup

Every actual slice lookup is the identical canonical signed value at its explicitly computed source index.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0002 signed_rectangular_slice_restrict

Restrict only the strict slice window, retaining the same actual output streams and source packing.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0003 signed_rectangular_slice_empty

A zero-length affine slice still requires real packed source and output tables; its strict entry window is empty.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0004 signed_rectangular_slice_extensional_unique

Two slices of the same window agree in their represented signed entries, not necessarily their codes or component streams.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0005 signed_rectangular_slice_extend

A preserved actual prefix and one real source lookup extend the slice without changing any earlier represented value.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0006 signed_rectangular_slice_exists

Ordinary induction constructs the affine output by actual two-beta extension, including zero length and zero stride.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0008 signed_rectangular_slice_sum_exists

Construct an actual affine slice and actual positive/negative prefix-sum traces; the result is not a supplied sum oracle.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0009 signed_rectangular_slice_sum_functional

The canonical signed affine-sum value is independent of every permissible slice encoding.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS000A signed_rectangular_slice_sum_empty_value

Every actual empty affine sum is the canonical signed zero, irrespective of offset or stride.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS000B signed_rectangular_slice_sum_empty_exists

A valid source actually admits an empty slice and its zero sum, rather than merely a vacuous uniqueness assertion.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS000C signed_rectangular_slice_sum_successor_decompose

A successor affine sum decomposes into its actual prefix sum and actual last source entry with the original SignedAdd relation.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS000D signed_rectangular_slice_sum_successor_intro

Extend both beta streams by the actual next source value and append the actual signed sum; no output slice is assumed.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS000E signed_rectangular_slice_sum_successor_add

Any two actual consecutive affine sums and their true intervening source value satisfy the signed addition law.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS000F signed_rectangular_slice_sum_exists_unique

Every finite affine window of a genuine source table has a constructed and literally unique canonical signed sum.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0010 signed_rectangular_row_sums_lookup

Each actual row-table entry is the actual signed sum of the corresponding affine source slice.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0012 signed_rectangular_row_sums_empty

Zero rows impose no fictitious row values but still certify genuine source and row-table packings.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0013 signed_rectangular_row_sums_extensional_unique

All genuine row-sum tables agree entrywise in canonical signed values, without identifying arbitrary beta encodings.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0014 signed_rectangular_row_sums_extend

A preserved row-table prefix extends by one actually proved slice sum, never by an assumed finite-choice table.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0015 signed_rectangular_row_sums_exists

Ordinary induction computes each finite slice sum and appends its actual signed value to construct the entire row-sum table.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0017 signed_rectangular_sum_exists

Construct the whole row-sum table and then its actual finite sum; both finite dimensions are arbitrary.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0018 signed_rectangular_sum_functional

All actual representations of the same rectangular sum have the identical canonical signed result.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0019 signed_rectangular_sum_exists_unique

Every genuine source and every finite affine rectangle admit a constructed, unique signed double-sum value.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS001A signed_rectangular_sum_zero_outer

A rectangle with zero rows has actual signed total zero, including when its column count is nonzero.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS001B signed_rectangular_row_sums_zero_inner

Induction proves the sum of any actual table of empty row sums is zero; a positive number of zero-length rows is not silently discarded.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS001C signed_rectangular_sum_zero_inner

A rectangle with zero columns has actual signed total zero for every row count.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS001D signed_rectangular_columns_successor_add

Appending one real grid row adds its actual entries pointwise to the actual column-sum table, using only the elementary equality of the two coordinate expressions.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS001E signed_rectangular_fubini

Ordinary row-count induction proves finite signed Fubini for arbitrary affine grids, including both zero dimensions, by constructing the missing prefix column table and applying actual signed sum linearity.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS001F signed_rectangular_fubini_exists

Construct actual row and column sum tables and actual signed sum traces sharing one canonical value; no supplied slice, table, sum, or permutation witness is required.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
RS0020 signed_rectangular_row_major_fubini

Every actual row-major m-by-n signed beta table has constructed row and column sums with exactly the same total, including zero rows or columns.

Alpha v34 checked-use · first admitted v31 · independently kernel and Lean verified; not Stable
PD0002 Lt(a,b)

Witness-defined strict order on natural numbers.

Conservative definition · notation layer 0
PD0013 BetaAt(b,c,i,x)

x is the bounded beta-decoded value at index i.

Conservative definition · notation layer 0
ND0142 SignedDecode(z,p,n)

The original canonical integer code: even 2p denotes p, and odd 2k+1 denotes −(k+1). The decoded positive and negative parts are normalized.

Conservative definition · notation layer 0
ND0143 SignedBalance(z,p,n)

The original canonical code z represents the integer difference p−n; these supplied components need not be normalized.

Conservative definition · notation layer 1
ND0252 ArithAt(F,i,z)

Two genuine beta entries of the packed table represent the unique canonical signed value z. Distinct component representations need not be equal.

Conservative definition · notation layer 2
ND0254 ArithTableEqual(F,G,l)

Pointwise equality of actual canonical signed lookups below l, not equality of table codes or their positive/negative components.

Conservative definition · notation layer 3
PD0001 Le(a,b)

Witness-defined non-strict order on natural numbers.

Conservative definition · notation layer 0
ND0251 ArithTable(N,F)

An actual packed signed table with canonical signed entries through index N, including index zero. It contains no divisor transform or inversion hypothesis.

Conservative definition · notation layer 2
ND0144 SignedAdd(a,b,c)

Actual addition of original canonical signed codes, witnessed by their decoders and balanced equality.

Conservative definition · notation layer 1
ND0266 ArithAdd(F,G,H,l)

Three actual signed tables and witnessed SignedAdd entries at each i<l. The unused endpoint certified by ArithTable(l,...) is not included in the prefix sum.

Conservative definition · notation layer 3
ND0264 ArithExtend(F,G,l,z)

A genuine output signed table through l preserves the represented source values at i<l and records the prescribed signed value z at l. Existence is proved by recoding both beta streams.

Conservative definition · notation layer 4
ND0287 ArithSlice(F,G,o,s,l)

Actual signed tables with witnessed values G(i)=F(o+s*i) for i<l. The output is constructed by real beta-stream recoding; its separately certified endpoint is unused.

Conservative definition · notation layer 3
PD0015 Sum(b,c,l,z)

z is the sum of a beta-coded prefix of length l.

Conservative definition · notation layer 1
ND0253 SignedPrefixSum(F,l,z)

The signed balance of two actual natural finite sums, at exactly the indices 0<=i<l. Existence, uniqueness and representation independence are proved separately.

Conservative definition · notation layer 2
ND0288 SignedSliceSum(F,o,s,l,z)

An actually constructed affine slice followed by its genuine signed prefix sum. Both zero length and zero stride are meaningful; no sum oracle is part of the graph.

Conservative definition · notation layer 4
ND0289 ArithRowSums(F,R,o,s,t,m,n)

An actual row table R contains, at i<m, the signed sum of the n entries F((o+s*i)+t*j). Source and row-table packings are explicit, including empty dimensions.

Conservative definition · notation layer 5
ND0290 SignedRectangularSum(F,o,s,t,m,n,z)

Construct an actual row-sum table and take its actual m-entry signed sum. Equality after swapping strides and dimensions is the independently proved finite Fubini theorem.

Conservative definition · notation layer 6

Only proof arrows are theorem dependencies. Definition arrows are hygienic abbreviations of exact first-order formulas and introduce no axiom or kernel symbol.