# MITC4 eigen 독립 검산과 판정



<a id="numerical-review"></a>

<a id="numerical-review--독립-numerical-review"></a>
## 독립 Numerical Review

- Feature ID: `mitc4-shell-feast-eigen2`; Owner: `numerical-review-agent`; revision `r1`.
- 입력: [requirements r1](requirements.md#requirements), [evidence](requirements.md#requirements-evidence),
  [새 research](research.md#research), [새 formulation r1](formulation.md), [TOLERANCE](../TOLERANCE.md).
- Verdict: **`pass-for-io-definition`**. 새 수학 계약의 확인된 blocking defect 없음.
- 범위: 문서·독립 수학 검산. 구현, FEAST runtime, build/test, reference comparison, Physics/release 통과 판정이 아니다.

<a id="numerical-review--판단과-독립-근거"></a>
### 판단과 독립 근거

새 질량·stabilization·constraint/FEAST 문서를 실제 작성 후 모두 읽었다.
기존 pass를 전제로 삼지 않고 새 요구 27개와 식·실패 경계를 대조했다.
기준 문서는 [프로젝트 지침](../../AGENTS.md), [PRD](../PRD.md),
[ARCHITECTURE](../ARCHITECTURE.md), [ADR-028](../ADR.md#adr-028)이다.

| 검토 | 판단 |
| --- | --- |
| 운동학·부호·DOF·단위 | `[uX,uY,uZ,thetaX,thetaY,thetaZ]`, `S=-[d]cross`, `S theta=theta cross d`의 signs와 mass cross-block transpose 일치. C0/C1/C2 차원 M/ML/ML²; 길이 congruence 후 eigen/residual norm 일관 |
| 적분·consistent mass | `NiNj z^k J` 최대 성분별 차수4로 27점의 degree5 정확성 충분. Positive weights/J에서 Hq=0인 다항식은 모든 nodal u=0, Si theta=0이므로 physical20 positive, drill null4. 독립 rational 적분으로 C1 비영·행합·first moment 재현 |
| Derived lumped | Partition of unity로 scalar moment row-sum과 `integral rho Ni Gi^TGi` 일치. Strict Cauchy–Schwarz로 rank5/node·central tangent inertia 양수. Jensen 차1/2와 kinetic energy 추가1/2 구분. Orbital inertia/모든 spectrum 동일성을 주장하지 않음 |
| 공변 stabilization | Rotary block trace는 independent tangent orthogonal change에 불변. 여덟 항을 모두 평균하며 양의 초기 scale. Geometry/frame부터 재적분한 complete K/ML와 partial-BC static reaction이 공변; NR-MFE-001 새 식에서 해소 |
| 실제 BC·finite spectrum | Free injection을 먼저 적용. Constrained director exact-zero 교집합만 mass null이고 tiny positive는 유지. Shared director와 positive kd로 KZ=Zdiag(kappa), Kpz=0,Kzz>0; partial BC에 남은 stabilization 보존. 일반 Schur 반례5/2 대 삭제3도 정합 |
| Whitening·안정성 | Mp nodal SPD Cholesky와 `A=L^-1KpL^-T`·`phi=DCPL^-T x`는 exact congruence. Null rank와 numerical conditioning 분리, inverse/floor/pseudoinverse 우회 없음 |
| Lowest N·multiplicity | Fixed a0의 outward enclosure가 낮은 spectrum 부재 근거. 성공 total count=n과 guarded upper search·bounded enclosing fallback, final c=count=m와 c 전체 Gram/residual을 조합. Count empty 성공의 비보장성은 필수 수학 전제에서 제거 |
| Recovery·state | 최종 normalized phi에서 gi/yf를 다시 계산한 full original-free residual·Gram·Rayleigh/energy를 검사. Constrained components exact zero; modal reaction/stress를 새 output으로 만들지 않음. 검증 candidate·writer finalize 후 state commit 경계 유지 |
| 비선형 영향 | Initial kd의 Dkd=D²kd=0으로 기존 objective potential의 residual/Hessian 미분을 유지. Nonlinear Hessian SPD나 초기 Dgamma=linear Td를 주장하지 않음. 선형극한·objectivity·회귀·rollback은 후속 실행 의무 |

Fresh 독립 oracle의 재현 코드와 실제 값은 [numerical-review-evidence](numerical-review.md#numerical-review-evidence)에 있다.
NR-MFE-001은 `kd=19/4800`, `Mff=3/50`, `Kff=10369/7500`,
`lambda=10369/450`, 단위 moment `thetaZ=7500/10369`을 확인했다.
Complete K/ML/response/full reaction 공변성 ratio는 모두 `1.8e-16` 미만이다.
곡면 mass rational oracle와 27점 적분 최대 entry 차는 `2.221e-16` 미만이었다.

<a id="numerical-review--고정한-기준과-후속-인계"></a>
### 고정한 기준과 후속 인계

- [내부 controls](numerical-review-controls.md): 검토 후 채택한 기존 C1–C4/C6/C7 수치 정의,
  새 fixed-lower C5·finite budgets·seed·conditioning·raw classification. 기존 workflow/제외 portfolio/과거 pass는 미채택.
- [27개 verification cases](numerical-review-cases.md): requirement 27개별 analytical/invariant,
  actual FEAST·실패 주입·남는 static coverage. Expected value는 production 재호출로 생성하지 않는다.
- [reference-model](reference-model.md): 원본 TXT의 literal `Frame: Mode i`와 유일한 source
  `Step-2`에서 per-modal-frame 10 singleton Value families를 새로 판정했다. 공통 정책 그대로
  행5%·RMS1%, 이번 singleton의 실효 각 Value1%; 모두 blocking. 외부 mode shape gate 없음.

I/O는 정확한 입력 allowlist·diagnostic·영속 HDF5 경로 및 source/modal identity를 정의한다.
최소한 used lumped mass/backend, N개 public pair와 전체 c개 검증의 재현 evidence,
raw negative/nearzero와 frequency validity, 실패한 optional optimization·fallback까지의
count/solve history를 의미 손실 없이 연결해야 한다. 데이터 layout은 NR가 선점하지 않는다.

<a id="numerical-review--잔여-위험미실행"></a>
### 잔여 위험·미실행

Research G01/G02의 installed count-empty/endpoint/workspace·ABI probes, n1/N=n/allzero/
repeated/clustered actual FEAST와 shifted sparse factorization memory는 **NOT RUN**이다.
현재 수학 blocker는 아니지만 구현 완료 시 필수다. 넓은 enclosing fallback도 runtime 실패나
O(n²) 메모리 비용을 없애지 않으며 bounded failure와 기존 결과 보존이 필요하다.

얇은 shell·거의 정렬된 partial BC의 positive mass conditioning, 왜곡/곡면 MITC4의
locking·accuracy, 27점 밖 geometry injectivity 및 floating count의 정확성 한계가 남는다.
이 한계를 arbitrary rank cutoff·reference fitting·tolerance 완화로 숨기지 않는다.
남는 shell/shellNL/linear-limit fresh solves와 nonlinear tangent/objectivity·balance는 미실행이다.
제외된 네 예제의 원본·복사·cache를 읽거나 사용하지 않았다. Pressure fresh 외부 coverage 부재를 명시한다.

확인된 수학 correction request는 없다. 구현 owner는 명시 controls/cases를 실제 runtime과
연결하고 I/O owner는 reference/validation projection을 보존해야 한다. Source/tests,
upstream 계약·공통 tolerance·reference artifacts·Git은 수정하지 않았다.

<a id="numerical-review-evidence"></a>

<a id="numerical-review-evidence--독립-수학-검산-evidence"></a>
## 독립 수학 검산 evidence

- Feature ID: `mitc4-shell-feast-eigen2`
- 검토일: `2026-09-08`; 기본 보고서: [numerical-review](numerical-review.md#numerical-review).
- 대상: 새 requirement r1. 아래는 Python 표준 라이브러리만 사용하는 수학 검산이며 C++/FEAST 실행이 아니다.

<a id="numerical-review-evidence--nr-mfe-001의-geometry부터-재계산"></a>
### NR-MFE-001의 geometry부터 재계산

`a=(0,1,0)`, `b=(-4/5,0,3/5)`, `d=(3/5,0,4/5)`이고
`X=[-2a-b,2a-b,2a+b,-2a+b]`, `E=12`, `nu=0`, `rho=t=1`이다.
Node 1 URZ만 free이고 나머지 23 DOF는 fixed다. Z45° 회전은 같은 physical
free subspace를 유지한다. 아래는 [이전 독립 적분](../mitc4-shell-feast-eigen/numerical-review.md#numerical-review-evidence)의
평판 membrane/curvature/MITC edge-work를 검토한 뒤 geometry edge에서 길이·axes·director를
다시 얻도록 구성한 새 실행이다. 기존 수치 출력이나 저장 K를 입력으로 쓰지 않는다.
전역 24×24 physical K를 직접 적분하고 새 director의 least-aligned tangent를 재생성해
여덟 rotary diagonal의 trace mean을 계산한다. 비교 대상 congruence에만 원 K를 회전한다.
Norm에는 ell=4, D=diag(ell I3,I3)를 사용하여 matrix는 D^T A D,
response는 D^-1 q, force/moment residual은 D^T r로 같은 단위를 만든다.

```python
from math import sqrt, fsum
from fractions import Fraction as F
def dot(a,b): return fsum(x*y for x,y in zip(a,b))
def cross(a,b): return (a[1]*b[2]-a[2]*b[1],a[2]*b[0]-a[0]*b[2],a[0]*b[1]-a[1]*b[0])
def norm(a): return sqrt(dot(a,a))
def unit(a): return tuple(x/norm(a) for x in a)
def sub(a,b): return tuple(x-y for x,y in zip(a,b))
def rz(v): return ((v[0]-v[1])/sqrt(2),(v[0]+v[1])/sqrt(2),v[2])
def action(A,x): return [dot(row,x) for row in A]
def rotate_vector(v): return [x for i in range(0,len(v),3) for x in rz(v[i:i+3])]
def rotate_matrix(A):
    left=list(zip(*(rotate_vector(c) for c in zip(*A))))
    return [rotate_vector(row) for row in left]
def err(a,b): return norm(sub(a,b))/(norm(a)+norm(b))
D=[4. if i%6<3 else 1. for i in range(24)]
def merr(A,B): return err([D[i]*A[i][j]*D[j] for i in range(24) for j in range(24)],[D[i]*B[i][j]*D[j] for i in range(24) for j in range(24)])
def qerr(a,b): return err([x/s for x,s in zip(a,D)],[x/s for x,s in zip(b,D)])
def rerr(a,b): return err([x*s for x,s in zip(a,D)],[x*s for x,s in zip(b,D)])
def build(X):
    edge1=sub(X[1],X[0]); edge2=sub(X[3],X[0])
    lx,ly=norm(edge1),norm(edge2); ex,ey=unit(edge1),unit(edge2)
    d=unit(cross(ex,ey)); area=lx*ly
    K=[[0.]*24 for _ in range(24)]
    for xi in [-1/sqrt(3),1/sqrt(3)]:
        for eta in [-1/sqrt(3),1/sqrt(3)]:
            fields=[]
            for sx,sy in [(-1,-1),(1,-1),(1,1),(-1,1)]:
                nx=sx*(1+sy*eta)/(2*lx); ny=sy*(1+sx*xi)/(2*ly)
                tx=(1+sy*eta)/4; ty=(1+sx*xi)/4
                for c in range(3):
                    fields.append(([nx*ex[c],ny*ey[c],ny*ex[c]+nx*ey[c]],[0,0,0],[nx*d[c],ny*d[c]]))
                for c in range(3):
                    fields.append(([0,0,0],[nx*ey[c],-ny*ex[c],ny*ey[c]-nx*ex[c]],[tx*ey[c],-ty*ex[c]]))
            for i,(mi,bi,si) in enumerate(fields):
                for j,(mj,bj,sj) in enumerate(fields):
                    K[i][j]+=area/4*(12*mi[0]*mj[0]+12*mi[1]*mj[1]+6*mi[2]*mj[2]+bi[0]*bj[0]+bi[1]*bj[1]+.5*bi[2]*bj[2]+5*dot(si,sj))
    axis=min(range(3),key=lambda k:(abs(d[k]),k))
    ta=unit(tuple(float(c==axis)-d[axis]*d[c] for c in range(3)))
    tb=cross(d,ta); diag=[]
    for i in range(4):
        for tangent in [ta,tb]:
            v=[0.]*24; v[6*i+3:6*i+6]=tangent
            diag.append(dot(v,action(K,v)))
    kd=fsum(diag)/8000
    M=[[0.]*24 for _ in range(24)]
    for i in range(4):
        for a in range(3):
            M[6*i+a][6*i+a]=area/4
            for b in range(3):
                K[6*i+3+a][6*i+3+b]+=kd*d[a]*d[b]
                M[6*i+3+a][6*i+3+b]=area/48*(float(a==b)-d[a]*d[b])
    return K,M,kd,d,ey,diag
a=(0.,1.,0.); b=(-.8,0.,.6)
X=[tuple(s*a[k]+t*b[k] for k in range(3)) for s,t in [(-2,-1),(2,-1),(2,1),(-2,1)]]
K,M,kd,d,ey,diags=build(X)
Kr,Mr,kdr,dr,eyr,diagsr=build([rz(x) for x in X])
load=[0.]*24; load[3:6]=[5*x/3 for x in ey]; lr=rotate_vector(load)
q=[0.]*24; qr=[0.]*24; q[5]=load[5]/K[5][5]; qr[5]=lr[5]/Kr[5][5]
r=sub(action(K,q),load); rr=sub(action(Kr,qr),lr)
targets=[float(F(19,4800)),float(F(10369,7500)),float(F(3,50)),float(F(10369,450)),float(F(7500,10369))]
actual=[kd,K[5][5],M[5][5],K[5][5]/M[5][5],q[5]]
for v,w in zip(actual,targets): assert abs(v-w)/(abs(v)+abs(w))<1e-12
cov=[merr(Kr,rotate_matrix(K)),merr(Mr,rotate_matrix(M)),qerr(qr,rotate_vector(q)),rerr(rr,rotate_vector(r))]
assert max(cov)<1e-12
assert abs(kd-kdr)/(abs(kd)+abs(kdr))<1e-12
assert abs(dot(d,load[3:6]))/norm(load[3:6])<1e-12
for A,v,f,residual in [(K,q,load,r),(Kr,qr,lr,rr)]:
    assert abs(residual[5])/(abs(A[5][5]*v[5])+abs(f[5]))<=1e-10
print('partial_bc=',actual)
print('rotated_partial_bc=',[kdr,Kr[5][5],Mr[5][5],Kr[5][5]/Mr[5][5],qr[5]])
print('covariance_K_M_q_reaction=',cov)
print('fresh_rotary_diagonals=',diags,diagsr)
```

<a id="numerical-review-evidence--독립-rational-mass-oracle"></a>
### 독립 rational mass oracle

다음 coefficient-dictionary 적분은 production shape/J/질량 함수를 사용하지 않는다.
이전 문서의 rational fixture 자체는 재사용하지만 모든 계수·행합·first moment를 이번에
다시 적분한다. Kernel-level director fixture이며 input explicit-normal 지원을 추가하지 않는다.

```python
from fractions import Fraction as F
from itertools import permutations, product
from math import sqrt
def const(x): return {(0,0,0):F(x)}
def add(*args):
    out={}
    for a in args:
        for p,c in a.items(): out[p]=out.get(p,F(0))+c
    return {p:c for p,c in out.items() if c}
def scale(a,c): return {p:v*c for p,v in a.items() if v*c}
def mul(a,b):
    out={}
    for p,c in a.items():
        for q,d in b.items():
            key=tuple(x+y for x,y in zip(p,q));out[key]=out.get(key,F(0))+c*d
    return {p:c for p,c in out.items() if c}
def diff(a,k):
    out={}
    for p,c in a.items():
        if p[k]:
            q=list(p);q[k]-=1;out[tuple(q)]=c*p[k]
    return out
def integ(a): return sum((c*F(8,(p[0]+1)*(p[1]+1)*(p[2]+1)) for p,c in a.items() if all(v%2==0 for v in p)),F(0))
def value(a,x): return sum(float(c)*x[0]**p[0]*x[1]**p[1]*x[2]**p[2] for p,c in a.items())
v=[{tuple(int(k==i) for k in range(3)):F(1)} for i in range(3)]
N=[scale(mul(add(const(1),scale(v[0],sx)),add(const(1),scale(v[1],sy))),F(1,4)) for sx,sy in [(-1,-1),(1,-1),(1,1),(-1,1)]]
X=[(-1,-1,F(1,10)),(1,-1,-F(1,10)),(1,1,F(1,5)),(-1,1,-F(1,10))]
d=[(0,0,1),(F(3,5),0,F(4,5)),(F(2,3),F(1,3),F(2,3)),(0,F(3,5),F(4,5))]
z=scale(v[2],F(1,4));pos=[add(*(mul(N[i],add(const(X[i][c]),scale(z,d[i][c]))) for i in range(4))) for c in range(3)]
J={}
for perm in permutations(range(3)):
    inversions=sum(perm[i]>perm[j] for i in range(3) for j in range(i+1,3))
    term=const((-1)**inversions)
    for c in range(3): term=mul(term,diff(pos[c],perm[c]))
    J=add(J,term)
rhoJ=scale(J,F(3));zk=[const(1),z,mul(z,z)]
polys=[[[mul(mul(mul(rhoJ,N[i]),N[j]),zk[k]) for j in range(4)] for i in range(4)] for k in range(3)]
C=[[[integ(p) for p in row] for row in mat] for mat in polys]
rows=[[sum(row,F(0)) for row in mat] for mat in C]
assert [mat[0][0] for mat in C]==[F(17609,28800),F(11003,1440000),F(88177,6912000)]
assert [sum(row,F(0)) for row in rows]==[F(7743,1600),F(739,12000),F(517,5120)]
first=[sum((rows[0][i]*X[i][c]+rows[1][i]*d[i][c] for i in range(4)),F(0)) for c in range(3)]
assert first==[integ(mul(rhoJ,p)) for p in pos]
g=[(-sqrt(3/5),5/9),(0.,8/9),(sqrt(3/5),5/9)]
maxerr=0.;jvals=[]
for q in product(g,repeat=3): jvals.append(value(J,[s[0] for s in q]))
for k,i,j in product(range(3),range(4),range(4)):
    approx=sum(value(polys[k][i][j],[s[0] for s in q])*q[0][1]*q[1][1]*q[2][1] for q in product(g,repeat=3))
    maxerr=max(maxerr,abs(approx-float(C[k][i][j])))
assert min(jvals)>0 and maxerr<1e-12
central=[rows[2][i]-rows[1][i]**2/rows[0][i] for i in range(4)]
assert min(central)>0
print('mass_C11=',[str(mat[0][0]) for mat in C])
print('mass_rows=',[[str(x) for x in row] for row in rows])
print('mass_first_moment=',[str(x) for x in first])
print('mass_Jrange_Gauss_error_central=',min(jvals),max(jvals),maxerr,float(min(central)))
```

<a id="numerical-review-evidence--이번-실행-결과"></a>
### 이번 실행 결과

2026-09-08 PowerShell here-string에서 이 문서의 두 Python block을 추출하고
`subprocess.run([sys.executable,'-B','-'])`으로 각각 실행했다. Oracle 1/2 exit `0`이다.

| 항목 | 이번 직접 계산 |
| --- | --- |
| `kd`, `Kff`, `Mff` | `0.003958333333333333`, `1.3825333333333332`, `0.05999999999999998` |
| `lambda` 원/회전 | `23.04222222222223` / `23.042222222222208`; exact `10369/450 [T^-2]` |
| 단위 moment의 `thetaZ` 원/회전 | `0.7233098659465717` / `0.7233098659465714`; exact `7500/10369` |
| Complete `K`, `ML`, response, full reaction 공변성 ratio | `1.658e-16`, `7.851e-17`, `1.535e-16`, `1.706e-16` |
| 원/회전 free residual raw | `0`, `-1.1102230246251565e-16`; 기존 scaled `1e-10` 기준 충족 |
| Rational `C0_11,C1_11,C2_11` | `17609/28800`, `11003/1440000`, `88177/6912000` |
| `sum m,sum h,sum j` | `7743/1600`, `739/12000`, `517/5120` |
| Spatial first moment 두 독립식 | Exact equal: `(-79747/360000,-685951/2880000,49651/320000)` |
| 27점 J min/max | `0.1285991922161525` / `0.2701341411171808` |
| Gauss vs rational 최대 entry absolute error | `2.220446049250313e-16` |
| 최소 nodal central inertia | `0.022318161338791092 > 0` |

최초 oracle 1 exit `1`은 회전 후 raw free residual에 잘못 추가한 exact-zero assertion이었다.
반력은 일반 floating arithmetic이며 원 계약은 scaled residual `1e-10`이다.
이를 기존 기준으로 수정하고 raw 값을 보존했다. Exact constrained displacement zero 조건,
정식화 또는 승인 tolerance를 변경한 것이 아니다.

외부 solver, FEAST runtime, build/test, retained static fresh solve 및 HDF5–reference
comparison은 **NOT RUN**이다. 위 항등식의 통과는 구현/reference 통과가 아니다.

최종 정적 Python audit는 owned Markdown 5개, 상대 파일 링크 38개, requirement 27개와
case 27개의 유일·연속 identity, UTF-8/whitespace/final newline을 검사했고 exit `0`이었다.
두 oracle 모두 exit `0`; 이후 norm의 length congruence 명시를 코드에 반영하고 영향받은
첫 oracle를 재실행하여 exit `0` 및 위 최종 scaled ratio를 확인했다. 식·판정 한계는 불변이다.