경계통과(자리올림)의 정량화:중앙 중첩, 폭, 그리고 시간에 따른 수렴
자리올림(자릿수 경계 통과)을 숫자로 재는 방법 제시
“중앙 중첩의 폭”이 어떻게 커지는지 정량화(근사식)
“합성 깊이(시간)”가 깊어질수록 벤포드/자리올림 패턴이 안정되는 메커니즘 확인
ASCII 수식과 파이썬 스니펫 제공
“자리올림”은 자릿수 경계 통과 이벤트다.
합성(곱/합)이 많이 겹치는 중앙부일수록 위상 혼합이 빠르고, 그 결과 경계 통과 빈도(자리올림)가 중앙에 집중된다.
합성 깊이가 깊어질수록(시간 경과) 그 패턴이 더 선명해진다.
11^n을 손계산으로 전개한다고 생각해보자.
캐리(자리올림) 전의 “가상 자릿값”은 파스칼 삼각형의 한 줄:
[C(n,0), C(n,1), ..., C(n,n)]
여기서 한 칸이 한 자리(베이스 10)를 넘으면 자리올림이 발생한다.
따라서, 중앙부 폭은 다음처럼 정의할 수 있다.
정의(ASCII):
W_n = |{ k ∈ {0,...,n} : C(n,k) ≥ 10 }|
(즉, “한 자리(9)를 초과하는 계수가 몇 칸이나 되는가?”)
직관:
n ≤ 4에서는 W_n = 0 (모든 계수가 0~6이어서 자리올림 없음)
n = 5에서 처음으로 C(5,2) = 10이 되어 W_5 > 0
n이 커질수록 중앙부의 큰 계수가 넓은 띠를 만들고 W_n이 점점 커진다
중앙 근처에서 이항계수를 정규근사로 본다면(대략적 직관용)
근사 아이디어:
C(n,k) ≈ 2^n * P(Bin(n, 1/2) = k)
≈ 2^n * (1 / sqrt(π n / 2)) * exp( - 2 * (k - n/2)^2 / n )
경계 조건:
C(n,k) ≥ 10 인 k의 범위(중앙 띠)를 풀면, 대략
(k - n/2)^2 ≤ (n/2) * ln( 2^n / (10 * sqrt(π n / 2)) )
따라서 중앙 띠의 반폭 Δ_n은
Δ_n ≈ sqrt{ (n/2) * ln( 2^n / (10 * sqrt(π n / 2)) ) }
그리고 대략적 폭
W_n ≈ 2 * floor(Δ_n) + 1
(정수 반올림/클리핑)
요지는 W_n이 대략 √n 스케일로 증가한다는 것.
즉, n이 커질수록 “자리올림이 필요한 중앙 구간”이 넓어진다(중앙 중첩 강화).
주의: 위 식은 직관용 근사다. 실제 값은 정수 효과와 캐스케이드(연쇄 캐리) 때문에 달라질 수 있다. 아래 코드로 정확한 카운트를 쉽게 얻을 수 있다.
자리올림은 한 칸에서 끝나지 않고 오른쪽(상위 자리)으로 연쇄적으로 전파될 수 있다.
연쇄의 직관적 지표는 다음처럼 둘 수 있다.
“자리올림 사건 수” 카운트: 파스칼 계수 줄에서 왼쪽(하위 자리)부터 차례로
q = floor(value / 10) 를 다음 칸에 더하고, 현재 칸은
value % 10으로 바꾸는 연산을 반복할 때,
모든 칸에 대해 q를 누적합하면 총 자리올림 건수가 된다.
“자리올림 밀도”
D_n = (총 자리올림 건수) / (최종 자릿수 길이)
합성(깊이 n)이 커질수록 D_n은 일반적으로 증가하고, 분포는 중앙부에 집중 하는 경향이 강해진다.
지난 편에서 정의한 위상 혼합 지표를 다시 보자.
가수 위상: phi = frac(log10 X)
혼합 지표: H_B = 1 − 12 * Var(phi) (0에 가까울수록 “벤포드적”)
합성 깊이(시간) n이 증가할수록, 다양한 성장률/배율이 섞이며 phi가 점점 균등에 가까워진다.
따라서 H_B → 0, 첫 자릿수 분포는 벤포드형 으로, 자리올림의 경계 통과 패턴은 안정 된다.
아래 코드는 2가지를 보여준다.
(A) 11^n 자리올림 지도: 파스칼 계수 → 베이스10 자리올림 → 중앙 띠 폭 W_n, 총 자리올림 수, 자리올림밀도 D_n
(B) 곱셈 과정의 벤포드 수렴: 가수 위상 phi의 혼합(H_B), 첫 자릿수 엔트로피 H1
표준 파이썬만 사용해 그대로 붙여넣어 실행 가능함
import math
from collections import Counter
from random import random
# -------------------------
# (A) 11^n 자리올림 지도
# -------------------------
def pascal_row(n):
"""Return list [C(n,0),...,C(n,n)]."""
row = [1]
for k in range(1, n+1):
# iterative formula: C(n,k) = C(n,k-1) * (n-k+1) // k
row.append(row[-1] * (n - k + 1) // k)
return row
def carry_map_from_pascal(n, base=10):
"""
From Pascal row for 11^n, perform base-10 carrying left->right (LSD first).
Returns:
final_digits (list of ints, LSD first),
total_carries (int),
pre_width_Wn (int): count of entries >= base before carrying.
"""
row = pascal_row(n)[:] # copy
pre_width_Wn = sum(1 for v in row if v >= base)
total_carries = 0
i = 0
# Extend row during carry propagation if needed
while i < len(row):
q, r = divmod(row[i], base)
row[i] = r
if q > 0:
total_carries += q
if i + 1 < len(row):
row[i+1] += q
else:
row.append(q)
i += 1
final_digits = row # LSD first
Dn = total_carries / len(final_digits)
return final_digits, total_carries, pre_width_Wn, Dn
def demo_table_for_n(n_min=2, n_max=30):
"""
Prints a small table:
n, width W_n (pre-carry), total_carries, density D_n, num_digits
"""
print("n | W_n | total_carries | D_n(carry/len) | num_digits")
print("--|-----|---------------|----------------|-----------")
for n in range(n_min, n_max+1):
digits, tc, Wn, Dn = carry_map_from_pascal(n, base=10)
print(f"{n:2d}|{Wn:4d}|{tc:15d}|{Dn:16.4f}|{len(digits):11d}")
# Uncomment to see the table:
# demo_table_for_n(2, 40)
# -----------------------------------------
# (B) 곱셈 과정의 벤포드 수렴 (위상 혼합)
# -----------------------------------------
def frac(x):
return x - math.floor(x)
def first_digit(x):
"""Return first decimal digit of positive x."""
x = float(x)
if x <= 0:
return None
m = 10 ** frac(math.log10(x))
# m ∈ [1, 10)
return int(m)
def shannon_entropy(p):
"""Entropy in bits; p is iterable of probabilities summing to 1."""
eps = 1e-12
return -sum(pi * math.log(pi + eps, 2) for pi in p)
def benford_probs():
return [math.log10(1 + 1/d) for d in range(1, 10)]
def simulate_benford_convergence(steps=5000, growth_sampler=None):
"""
Multiplicative process: X_{t+1} = X_t * Y_t
growth_sampler(): returns Y_t > 0
Track phi = frac(log10 X_t), H_B, and first-digit entropy H1.
"""
if growth_sampler is None:
# Default: mild random growth/decay around 1, multiplicative
# Y ~ 10^U, U uniform on [-0.5, 0.5] (decades)
growth_sampler = lambda: 10 ** (random() - 0.5)
x = 1.234567
phis = []
firsts = []
for t in range(steps):
y = growth_sampler()
x *= y
phi = frac(math.log10(x))
phis.append(phi)
d = first_digit(x)
if d is not None and 1 <= d <= 9:
firsts.append(d)
# Phase variance / H_B
mean_phi = sum(phis) / len(phis)
var_phi = sum((p - mean_phi) ** 2 for p in phis) / len(phis)
HB = max(0.0, 1.0 - 12.0 * var_phi) # clip to [0,1] lower bound
# First-digit entropy
cnt = Counter(firsts)
total = sum(cnt.values())
p = [cnt.get(d, 0) / total for d in range(1, 10)]
H1 = shannon_entropy(p)
return {
"HB": HB,
"var_phi": var_phi,
"H1_bits": H1,
"first_digit_hist": p, # length 9 list
"benford": benford_probs() # reference
}
# Example usage:
# res = simulate_benford_convergence(steps=20000)
# print("HB ~", res["HB"])
# print("H1_bits ~", res["H1_bits"])
# print("first_digit_hist ~", [round(x,3) for x in res["first_digit_hist"]])
# print("benford_ref ~", [round(x,3) for x in res["benford"]])
(A)에서 demo_table_for_n(2, 40)를 켜면, n에 따라
W_n(중앙 띠 폭), total_carries(총 자리올림 수), D_n(밀도), num_digits(최종 자릿수 길이) 가 출력된다.
(B)에서 simulate_benford_convergence는 합성 깊이가 커질수록 HB → 0, H1_bits → 2.876 bits 근처로 수렴하는 걸 확인할 수 있다.
W_n(중앙 띠 폭)은 n이 커질수록 대략 √n 스케일로 넓어진다 → 중앙 중첩 강화.
자리올림은 경계 통과 이벤트이며, 합성이 많이 겹치는 중앙에서 집중된다.
시간(합성 깊이)이 충분하면 위상 혼합이 진행되어 벤포드 패턴과 자리올림 지도가 안정된다.
간단 지표: H_B = 1 − 12 * Var(phi) (작을수록 “벤포드적” 섞임이 잘 된 상태)
경계 통과율(λ)을 시간에 따라 모델링: lambda(n; base)와 “중앙/외곽 대비”의 정량 지표 설계
실제 데이터(가격/거래량/자연 측정치)에 ③–④의 지표 적용 가이드
이상 탐지: “중앙 띠 폭/밀도/엔트로피” 삼각 지표로 특이한 생성·가공 데이터를 가려내는 실무 팁