빗자루, 금붕어 되다, 김동주, 2010

2010년 언저리에 좋은 한국 독립 영화들이 많아 나왔던 것으로 기억한다. <파수꾼>, <혜화, 동>, <경복> 등등… 하지만 그 중에서도 가장 궁금했던 작품이 바로 <빗자루, 금붕어 되다>였다. 그도 그럴 것이 이 영화는 2008년 전주국제영화제와 2010년 잠깐의 개봉을 제외하고는 영상자료원, OTT, 물리 매체 등 그 어떤 방법으로도 볼 수가 없었기 때문이다. 그런데 마침 올해 서울에서 한 번 상영을 해 준다고 하여 몇몇 씨네꼼 부원들과 함께 관람했다.

영화는 오랜 기다림이 아깝지 않을 만큼 훌륭했다. 대부분의 내용은 신림 고시촌에 홀로 근근히 살아가는 50대 주인공의 일상으로 채워져 있는데, 영화는 이것을 아주 엄격한 형식미로 담는다. 카메라는 눈높이 이상의 위치를 고집하면서, 살짝 기울어진 채로, 마치 깔보듯이 인물들을 찍어낸다.¹ 단순한 실험이나 스케치에서 그치지 않고, 중후반부에는 나름 담대한 서사적 도약을 거치는 것 또한 흥미로웠다. 기회가 있을 지는 모르겠지만 꼭 한 번 더 보고 싶다. 김동주 감독의 두 번째 영화를 기다린다…

스탑 메이킹 센스, 조나단 드미, 1984

한동안은 이 영화(와 음악)에 푹 빠져 살았다. 극장에서 총 세 번, 그 중 두 번은 댄스어롱으로 감상했다. 사실 세 번쨰 볼 때쯤에는 영화보다도 춤추는 사람들을 더 유심히 보았다. 다른 사람들의 시선은 의식하지도 않은 채로, 제목대로 이성과 상식을 내려놓고 뛰어노는 사람들에게서 큰 감동을 받았다. 아주 오랫동안 잊기 힘든 극장 경험이 될 것 같다.

샤크네이도, 안소니 C. 페란테, 2013

<샤크네이도>는 영화에 대한 애정을 되살려주는 작품이었다. “영화는 움직인다” (혹은 움직여야만 한다)는 당연한 사실을 이렇게까지 잘 구현한 사례가 있을까? 익히 알려져 있듯 이 영화의 기술적 완성도는 형편없다. 이를테면, 숏-리버스 숏에서 한 숏에서는 화창하지만 다른 숏에선 폭풍우가 몰아치는 식이다. 그렇지만 페란테는 이러한 불균질성에는 신경도 쓰지 않는 듯하다. 영화는 움직여야만 하고, 한 번 시작했으면 반드시 끝에 도달해야만 하며, 그러기 위해서 두 숏은 붙어야만 하기 때문이다. 그렇게 설명할 수 없는 불가항력적인 힘에 의해 두 숏은 접합된다.

이러한 당위적 구성은 서사적으로도 반복된다. 이 영화에서 많은 사람들이 가장 좋아하는 장면은 주인공 노라의 생존이다. 노라는 영화의 클라이막스에서 헬리콥터를 향해 달려드는 상어에게 잡아먹혀 버린다. 그러나 잠시 뒤, (또다른 주인공인) 핀이 달려드는 상어를 전기톱으로 지져버릴 때, 놀랍게도 그 상어의 뱃속에서 노라는 기적적으로 구해진다. 나는 처음에 이 장면이 도저히 이해가 되지 않았다. 그러나 영화의 결말에서 핀의 아들과 노라가 연인이 될 때에서야 납득할 수 있었다. 사실 <샤크네이도>에서는 주인공의 가족들을 제외한 등장 인물들은 전부 죽는다. 반대로 말하면 주인공의 가족들은 절대 죽을 수 없다. 그렇기 때문에 노라 또한 죽을 수 없다. 노라는 주인공의 가족으로 포섭되어야만 하며, 그러기 위해서는 살아 있어야만 하고, 상어에게 공중에서 잡아먹히더라도 핀에게로 도달해야만 하는 것이다. 다시 말하자면 <샤크네이도>는, 마치 물 속에 있어야 할 상어가 하늘을 날아다니듯, 인과율을 완전히 역전시킨 논리에서 구축된 영화인 셈이다.

성냥팔이 소녀의 재림, 장선우, 2013

<성냥팔이 소녀의 재림>을 보면서 떠오른 것은 유운성 평론가가 <에스퍼의 빛>을 변호하면서 말한 게임적 감각이라는 개념이었다. 정작 나는 <에스퍼의 빛>을 그렇게 좋게 보지 않았기 때문에 유운성 평론가가 무엇을 이야기했는지는 잘 모르겠지만, 적어도 내가 보기엔 <성냥팔이 소녀의 재림>이 훨씬 성공적인 구현에 가까웠다. 초중반부의 맥락 없는 서사는 마치 <GTA> 등에서 보이는 오픈월드적 구성을, 중후반부의 하이스트 시퀀스는 <콜 오브 듀티> 시리즈 같은 캠페인-퀘스트적 구성을 떠올리게 하며, 이는 자유의지를 되찾기 위한 왕도적 서사라는 영화 전반의 주제와 썩 어울린다고 느껴졌다. 물론 <매트릭스>를 대놓고 베낀 특정 장면 같이 객관적 결함은 있지만, 그리고 이 영화가 100억원을 쓸 정도라고는 전혀 생각하지 않지만, 나무위키에 적혀 있는 것처럼 살벌한 평가를 받을 만한 작품은 아니라고 생각한다. 나는 기꺼이 이 영화를 지지하고 싶다.

전혀 다른 영화 세 편을 추천하고 싶다.

빛을 향한 그리움 Nostalgia for the Light, 파트리시오 구즈만, 2010

때때로 시선은 영화의 모든 것을 결정한다. 파트리시오 구즈만의 시선은 칠레의 땅으로부터 출발해 역사를 관통한다. 안데스 산맥의 서쪽, 칠레의 북쪽 지역에는 아타카타 사막이 있다. 이곳은 너무 건조해서 1년 내내 비가 내리지 않은 지역마저 있을 정도다. 그리하여 이곳에는 구름을 피해 별을 바라보는 천문학자들, 썩지 않은 고대 인류의 시체를 조사하는 고고학자들, 그리고 피노체트 집권기에 총살당한 뒤 버려진 가족의 유해를 찾는 할머니들이 모여든다. 목적도, 찾는 바도 다르지만, 구즈만은 이들이 같이 공유하는 노스탤지어를 포착해낸다. 어쩌면 언제나 같은 속도로, 앞으로만 흘러가는 시간에 무력하게 매인 우리들이 할 수 있는 것은 지나간 것을 그리워하는 것밖에 없을 지도 모른다. 그렇다면 <빛을 향한 그리움>은 모든 그리워하는 사람들에게 보내는 가장 아름다운 러브레터 중 하나일테다.

마이애미 커넥션 Miami Connection, 김영군, 박우상, 1987

열 세 살의 나이에 태권도 검은띠를 딴 김영군은 1977년 미국으로 이주했다. 그리고 그는 불현듯 태권도 영화를 만들기로 결심했다. 그렇게 <마이애미 커넥션>이 세상에 나왔다. 마이애미 어딘가에서 태권도 록밴드 “드래곤 사운드”로 활동하는 절친 네 명이 닌자 폭주족 갱단에 맞서 싸운다는 단순한 듯 단순하지 않은 내용에는 피와 땀과 눈물과 한국인의 얼의 정수가 담겨있다. 마약이 가득 담긴 삼양라면 박스, 주연을 겸한 김영군의 조악한 콩글리시, 5분이 넘게 나오는 태권도 품새와 대련을 보면서 웃지 않을 수 있는 한국인은 없을 것이다. 이 영화의 마지막에는 “폭력을 제거하는 것만이 평화로 가는 유일한 길”이라는 자막이 나온다. 나는 이 영화의 순진무구함을 사랑한다.

나를 사랑하는 척 해줘 Pretend That You Love Me, 조엘 헤이버, 2020

유튜브는 영화가 될 수 있을까? 요새 들어 유튜버들의 정식 감독 데뷔가 이어지고 있지만, 여전히 기성 제작/배급 시스템을 거부한 채 유튜브로 영화를 만드는 이들이 있다. 조엘 헤이버가 만든 <나를 사랑하는 척 해줘>는 아마 그 중 가장 유명하고 상징적인 작품일 것이다. 컨셉은 이렇다. 헤이버는 영화를 만든다는 이유로 여배우들을 본인 집으로 초청해서 오디션을 보고, 그 모습을 녹화한다. 곧 그와 여배우들의 관계는 거의 연인처럼 보일 정도로 가까워지고, 공과 사, 현실과 연기의 구분이 흐릿해진다. 흥미롭지만 다소 낡은 이 영화의 형식이 유지되는 것은 오로지 조엘 헤이버의 과감한 솔직함 때문이다. 헤이버는 유튜브 영상만이 가능한 방식으로 인터넷에 상주하는 젊은 사람들이 공유하는 무력감과 우울감을 사실적으로 포착해낸다. 단정하고 싶지는 않지만, 어쩌면 우리는 새로운 영화의 흐름이 탄생하는 지점에 서 있을지도 모른다.

영화들은 개봉 연도 순으로 나열했고, 특별한 순위는 없다. 또 언제든지 기분에 따라 바뀔 수도 있다.

셜록 2세 Sherlock Jr.

버스터 키튼 Buster Keaton, 1922

산딸기 Smultronstället

잉마르 베리만 Ingmar Bergman, 1957

안드레이 루블료프 Андрей Рублёв

안드레이 타르코프스키 Андрей Тарковский, 1966

삼포 가는 길

이만희, 1975

올 댓 재즈 All That Jazz

밥 포시 Bob Fosse, 1979

스탑 메이킹 센스 Stop Making Sense

조나단 드미 Jonathan Demme, 1984

하나 그리고 둘 一一

에드워드 양 楊德昌, 2000

빛을 향한 그리움 Nostalgia de la Luz

파트리시오 구스만 Patricio Guzmán, 2010

업스트림 컬러 Upstream Color

쉐인 카루스 Shane Carruth, 2013

월드 오브 투모로우 World Of Tomorrow

돈 허츠펠트 Don Hertzfelt, 2015

Fast IO

Go에서 가장 많이 쓰이는 fmt.Scan, fmt.Println에는 기본적으로 buffer가 쓰이지 않는다. 흔히 말하는 Fast IO를 Go에서 쓰려면, bufio 패키지를 이용해야 한다. 내가 자주 쓰는 형식은 이렇다.

package main

import (
	"bufio"
	"fmt"
	"os"
)

var stdio = bufio.NewReadWriter(
	bufio.NewReader(os.Stdin),
	bufio.NewWriter(os.Stdout),
)

func main() {
	defer stdio.Flush()

	// Code goes here
}

이제 fmt.Scan(...), fmt.Println(...) 대신 fmt.Fscan(stdio, ...), fmt.Fprintln(stdio, ...)를 쓰면 된다. 아래는 백준 1000번 A+B을 Go로 푼 예시이다.

package main

import (
	"bufio"
	"os"
)

var stdio = bufio.NewReadWriter(
	bufio.NewReader(os.Stdin),
	bufio.NewWriter(os.Stdout),
)

func main() {
	defer stdio.Flush()

	var a, b int
	fmt.Fscan(stdio, &a, &b)
	fmt.Fprintln(stdio, a+b)
}

자료구조 스니펫

한 가지 거슬리는 점 중 하나는 Go의 내장 라이브러리에는 자료 구조에 대한 지원이 제대로 되어있지 않다는 점이다. 아마 제네릭이 최근에야 추가돼서 그런 거 같은데, 기본적인 큐나 스택도 없다는 것은 이해할 수 없다. 슬라이스로 대체해서 쓰라는 것 같긴 하지만. 하여간, 나는 간단한 코드 스니펫을 만들어서 돌려쓰고 있다. 백준은 Go 1.18이 지원되어서 제네릭을 쓸 수 있지만, 코드포스 같은 곳은 아직 지원하지 않으므로 참고하길 바란다.

Queue

type Queue[T any] []T

func (q Queue[T]) Front() T  { return q[0] }
func (q Queue[T]) Back() T   { return q[len(q)-1] }
func (q *Queue[T]) Push(x T) { *q = append(*q, x) }
func (q *Queue[T]) Pop() T {
	x := (*q)[0]
	*q = (*q)[1:]
	return x
}

Stack

type Stack[T any] []T

func (s Stack[T]) Front() T  { return s[0] }
func (s Stack[T]) Back() T   { return s[len(s)-1] }
func (s *Stack[T]) Push(x T) { *s = append(*s, x) }
func (s *Stack[T]) Pop() T {
	x := (*s)[len(*s)-1]
	*s = (*s)[:len(*s)-1]
	return x
}

Deque

type Deque[T any] struct{ items *list.List }

func NewDeque[T any]() Deque[T]  { return Deque[T]{list.New()} }
func (d Deque[T]) Front() T      { return d.items.Front().Value.(T) }
func (d Deque[T]) Back() T       { return d.items.Back().Value.(T) }
func (d Deque[T]) PushFront(x T) { d.items.PushFront(x) }
func (d Deque[T]) PushBack(x T)  { d.items.PushBack(x) }
func (d Deque[T]) PopFront() T   { return d.items.Remove(d.items.Front()).(T) }
func (d Deque[T]) PopBack() T    { return d.items.Remove(d.items.Back()).(T) }
func (d Deque[T]) Len() int      { return d.items.Len() }

Heap

Heap은 사용법이 좀 독특하다. container/heap의 도큐멘테이션을 참고하길 바란다. 또 heap의 constraint로 constraints.Ordered를 쓰면 좋겠지만, 이 또한 아직 표준 라이브러리로 편입되지 않은 관계로… 일단 int, float64, string만 지원한다.

type Heap[T int | float64 | string] []T

func (h Heap[T]) Len() int           { return len(h) }
func (h Heap[T]) Less(i, j int) bool { return h[i] < h[j] }
func (h Heap[T]) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *Heap[T]) Push(x any)        { *h = append(*h, x.(T)) }
func (h *Heap[T]) Pop() any {
	x := (*h)[len(*h)-1]
	*h = (*h)[:len(*h)-1]
	return x
}

Pair

type Pair[T1, T2 any] struct {
	First  T1
	Second T2
}

int vs int64

잘 알려져있다시피 Go의 int형은 구현에 따라 크기가 다르다. 일반적으로 통용되는 것은 int형은 64비트 시스템의 경우 64비트, 32비트 시스템의 경우 32비트라는 것이다. 백준 같은 사이트는 채점 서버가 64비트이므로, 그냥 int를 써도 상관이 없다. 그러나 코드포스 같은 곳은 32비트 채점 서버를 쓰므로 오버플로우 문제에 걸리기 싫다면 반드시 int64형을 써야 한다. 이 문제는 특히 Go에서 정수의 기본 타입이 int형이라 더 골치아프다. a := 0 같은 표현 대신 var a int64 = 0 혹은 a := int64(0)으로 명시를 해야 한다.

국내 인터넷에는 MIT 졸업생 95%가 못 푸는 문제라는 이름으로 돌아다니는 것 같다. 나무위키에도 잘 설명이 되어 있듯이, 이 문제는 전형적인 디오판토스 문제이다.

다행히도, 이 문제는 Bremmer와 Macleod에 의해 이미 연구되어서, 우리까지 머리를 싸매고 고민할 필요는 없다. 둘의 논문은 여기에서 확인할 수 있다. 심심해서 이 논문을 구현한 코드를 직접 짜 보았다. $N = 4$뿐만 아니라 다른 경우에 대해서도 해를 찾을 수 있다. 실행에는 SageMath가 필요하다.

from sage.all import *

"""
Solve a/(b+c) + b/(a+c) + c/(a+b) = N
Reference: https://ami.uni-eszterhazy.hu/uploads/papers/finalpdf/AMI_43_from29to41.pdf
"""

N = 6  # Fun fact: There is no solution when N is odd!

print(f"[+] Finding solution for: a/(b+c) + b/(a+c) + c/(a+b) = {N}")

# Build an elliptic curve and mapping.
E = EllipticCurve([0, 4 * N**2 + 12 * N - 3, 0, 32 * (N + 3), 0])
T = [E(t) for t in E.torsion_subgroup()]

print(f"[+] Elliptic curve: {latex(E)}")


def point_to_sol(x, y):
    a = 8 * (N + 3) - x + y
    b = 8 * (N + 3) - x - y
    c = 2 * (-4 * (N + 3) - x * (N + 2))

    if a < 0:
        a, b, c = -a, -b, -c

    g = GCD(GCD(a, b), c)

    return a // g, b // g, c // g


# Get one integral point of E.
P = E.integral_points()
# Generator must be inside the "egg".
for p in P:
    if p[0] < 0:
        break
print(f"[+] Found integral point: {p}")
cnt = 1
q = p

# Iterate until we find positive solution.
is_found = False
while True:
    print(f"[*] Trying {cnt} * P")

    for qq in [q] + [q + t for t in T]:
        a, b, c = point_to_sol(qq[0], qq[1])

        if (a > 0) and (b > 0) and (c > 0):
            print("[+] Found a, b, c!")
            is_found = True
            break

    if is_found:
        break

    q += p
    cnt += 1

print(f"[+] a = {a}")
print(f"[+] b = {b}")
print(f"[+] c = {c}")

# Check!
assert a / (b + c) + b / (c + a) + c / (b + a) == N

(GitHub Gist)

이제 당신도 상위 5% 수잘알이 되었다!!

자세한 설명은 역시 나보다는 논문을 참고하는 것이 더 좋을 것 같다. 핵심적인 관찰은, 주어진 방정식은 다음과 같은 ($\mathbb Q$ 위의) 타원 곡선으로 변형할 수 있다는 것이다.

여기에서 mapping은 다음과 같은 꼴이다. 사실 이건 적당히 $n$배를 취한 것이긴 한데, 어차피 이 방정식의 해는 상수배를 취해도 여전히 해가 되므로 큰 상관은 없다.

따라서, 먼저 방정식을 타원 곡선으로 옮긴 뒤, 그 곡선의 적당한 generator를 잡고, 다시 위의 map을 이용해서 되돌려 보내면 되는 것이다.

일단 위의 코드는 주어진 식을 변형하여 만들어진 타원 곡선 $E_N(\mathbb Q)$의 rank가 1인 경우만 확실하게 풀 수 있다. 그 외의 경우에는 더 많은 generator들을 고려해야 할 것 같은데, 확실하진 않다. 이건 나중에 추가하던지 해야겠다. 어차피 이런 케이스는 개인용 컴퓨터로 충분히 빠르게 찾을 수 있을지도 잘 모르겠다.

참고로, 모든 $N$에 대해서 양수 해가 존재하는 것은 아니다. 양수 해가 존재하려면,$E_N(\mathbb Q)$의 generator가 곡선의 “달걀” 부분에 있어야 한다. $N$이 홀수라면 이 조건을 항상 만족하지 못하고, 짝수여도 항상 만족하는 것은 아니다. 그렇지만 이 조건을 만족하는 짝수는 무한히 많다.

Reference

• A. Bremner and A. MacLeod, An unusual cubic representation problem, Ann. Math. Inform. 43 (2014) 29–41.

Problem. $[a, b]$에서 연속인 함수 $f$에 가장 가까운 다항식 $p$는 무엇일까?

여기서 “가깝”다는 것은 보통 다음과 같은 Supreme Norm의 관점에서 말하는 것이다.

만약 우리가 두 함수의 차의 최댓값을 $\varepsilon$ 아래로 줄일 수 있다면, 즉 $p$가 $f$에 대해서 $\lVert f-p \rVert < \varepsilon$을 만족시킨다면, 우리는 $p$를 $f$의 $\varepsilon$-근사라고 한다. 만약 그러한 $\varepsilon$이 최소라면, 우리는 $p$를 $f$의 최적 근사(best approximation)이라고 한다.

Weierstrass Approximation Theorem

해석학을 배워 본 사람이라면, 어떤 연속함수 $f$를 가져오더라도 항상 다항식으로 근사할 수 있다는 사실을 이미 알고 있을 것이다. 이것이 그 유명한 바이어슈트라우스 근사 정리(Weierstrass Approximation Theorem) 혹은 스톤-바이어슈트라우스 정리(Stone-Weierstrass Theorem)이다.

Theorem. (Weierstrass.) $[a, b]$에서 연속인 임의의 $f$에 대해서, $f$로 균등 수렴(uniformly converge)하는 적당한 다항식 함수열 $p_n$이 항상 존재한다.

다른 말로 써보자면, 임의의 $f$에 대해서 어떤 $\varepsilon$을 가져오더라도 $f$를 $\varepsilon$-근사하는 다항식을 찾을 수 있다는 것이다. 심지어 이 정리의 증명은 구성적이다. Bernstein Polynomial이라는 것을 이용하면 항상 주어진 조건을 만족하는 함수열을 직접 만들어낼 수 있다. 이런! 문제가 너무 싱겁게 풀려버린 것 같다.

하지만 아직 안심(…?)하기엔 이르다. 왜냐하면, 많은 경우에 우리는 근사하는 다항식의 차수를 제한하고 싶기 때문이다. Weierstrass Approximation Theorem은 다항식의 차수에 대해서 말해주지도 않고, Bernstein Polynomial도 주어진 차수에 대해서 최적의 근사인지에 대한 보장은 없다. 문제는 아직도 굳건하다.

Minimax Approximation

차수까지 고려해서 문제를 다시 적어보자면, 아래와 같다.

Problem. $[a, b]$에서 연속인 $f$에 대해서, $\lVert f - p \rVert = \max_{x \in [a, b]} \lvert f(x) - p(x) \rvert$를 최소화하는 $n$차 (혹은 그 이하의) 다항식 $p$를 구하시오.

이 문제는 최댓값(maximum)을 최소화(minimize)하는 것이므로, 보통 미니맥스 근사(Minimax Approximation) 문제라고 부른다. 이 글에서 살펴볼 문제도 바로 이것이다. (그리고, 앞으로 항상 $f$는 $[a, b]$에서 연속인 함수, 그리고 $p$는 $n$차 이하의 다항식이라고 가정하겠다.)

Theorem. 미니맥스 근사 문제의 해답은 존재한다.

pf. 구간 $[a, b]$에서 연속인 함수를 $\mathcal C[a,b]$라고 하고, 최대 $n$차의 다항식들의 집합을 $\mathcal P_n$이라고 하자. 그러면 $\mathcal P_n$은 (normed, linear space) $\mathcal C[a,b]$의 finite-dimensional subspace가 된다. $p \in \mathcal P_n$이 주어진 문제의 정답이라고 하자. 그러면, 적어도 $\lVert f - p \rVert < \lVert f \rVert$여야 한다. 즉, $p$는 집합 $K = \{q \in \mathcal P_n: \lVert f - q \rVert < \lVert f \rVert \}$ 내부에 존재한다. 이제 사상 $L(q) = \lVert f - q \rVert$를 생각하면, $K$는 컴팩트이고 $L$은 연속이므로 $L$을 최소화하는 점이 $K$ 내부에 존재하고, 이 점이 우리가 찾던 $p$이다.

Alternating Sets and Chebyshev Equioscillation Theorem

미니맥스 근사 문제를 처음 고안하고 풀어낸 것은 러시아의 수학자 파프누티 체비셰프(Pafnuty Chebyshev)였다. 그는 이 문제의 답을 1854년에 찾았는데, 한 가지 놀라운 사실은 체비셰프의 결과는 위에서 살펴본 바이어슈트라우스의 정리보다 30년이나 앞선다는 사실이다. 즉, 체비셰프가 이 문제를 풀었을 때에는 해답이 존재하는지 존재하지 않는지조차 명확하지 않았다.

먼저 Alternating Set의 개념을 짚고 넘어가자.

Definition. (Alternating Set.) $f$에 대해서 만약 점들 $a \le x_1 < \cdots < x_k \le b$이 다음 두 가지 조건을 만족한다면,

1. $\lvert f(x_i) \rvert = \lVert f \rVert$
2. $f(x_i) = - f(x_{i-1})$

우리는 $x_i$들을 $f$의 Alternating Set이라고 하며, 이 때 $k$를 이 Alternating Set의 길이(length)라고 한다.

다소 생소하게 등장하는 개념이지만, 일단 다음과 같은 관계를 쉽게 관찰할 수 있다.

Theorem. $p$가 $f$의 최적 근사라고 하자. 그러면 $f-p$는 항상 길이 2의 Alternating Set을 가진다.

pf. 그러지 않다고 가정하자. 즉, 오차 $E = \lVert f-p \rVert$에 대해서 $f(x) - p(x) = E$를 만족하는 $x$가 유일하다고 하자. 또, $e = \min (f(x) - p(x)) > -E$라고 정의하자. 이제 $q = p + (E+e)/2$라고 하면, $q$가 $p$보다 더 최적의 근사가 된다. 이는 모순이다.

체비셰프는 최적 근사와 Alternating Set 사이에 더 심오하고 신기한 관계가 숨어 있음을 발견했다. 우리는 이 정리를 (Chebyshev) Equioscillation Theorem, 혹은 Alternating Theorem이라고 부른다. (우리말로는 교번 정리라고 부르는 모양이다.)

Theorem. (Chebyshev.) $p$가 $f$의 최적 근사인 것은 $f - p$가 길이 $n+2$의 Alternating Set을 가진다는 것과 동치이다.

pf. 증명을 쓸 수 있겠다면 좋겠지만… 여기에 전부 쓰기엔 너무 길다. 관심이 있는 독자라면 A Short Course on Approximation Theory의 챕터 4를 읽어보기를 바란다. 증명의 아이디어 자체는 위의 케이스와 크게 다르지 않지만, 조금 더 복잡한 과정이 필요하다.

Collary. 미니맥스 근사 문제의 해답은 유일하다.

pf. 그렇지 않다고 가정하자. 즉, 서로 다른 두 다항식 $p, q$가 $f$의 최적 근사라고 가정하자. 그렇다면, Equioscillation Theorem에 의해서 $r = (p + q)/2$도 $f$의 최적 근사가 된다. 이제 다시 $x_1, \cdots, x_{n+2}$를 $f-r$의 Alternating Set이라고 하자. 정의상,

이 때 물론 $E = \lVert f - p \rVert = \lVert f - q \rVert$이다. 따라서, $\lvert (f-p)(x_i) \rvert, \lvert (f-q)(x_i) \rvert$는 $E$보다 작거나 같다. 그런데 이 둘의 합은 $2E$보다 크고, 이것은 두 값이 $E$라는 것을 함의한다. 즉, $f-p$와 $f-q$의 Alternating Set은 같다. 그런데 Alternating Set은 $p$와 $q$를 각각 유일하게 결정하므로, 결국 $p=q$여야만 한다. 이는 모순이다.

이 정리를 이해하는 데 주의할 점은, $E$를 먼저 정하고 조건을 만족하는 $p$를 찾는 것으로 오해하면 안 된다는 것이다. 결국 $E$도 $p$에 의존하는 함수이기 때문이다. 그보다 더 정확한 비유는 다음과 같다. 주어진 $f$에 대해서, 먼저 그것을 대충 근사하는 다항식 $p$를 그린다. 그리고, $\lvert f-p \rvert$의 최댓값 $E$를 따라서 $f+E$와 $f-E$를 그린다. 이 때 두 선이 $p$와 $n+2$개 이하의 점에서 만난다면, 이 오차를 더 강하게 쥐어짜서 더 좋은 근사 $p'$를 찾을 수 있다는 것이 Equioscillation Theorem이다.

Remez Algorithm

우리는 Equioscillation Theorem을 통해 미니맥스 근사 문제의 만족할 만할 답을 그럭저럭 찾아냈다. 답이 존재한다는 것과, 유일하다는 것, 그리고 그 대답의 필요충분조건까지 알아냈기 때문이다. 그런데, Alternating Set을 구하는 문제는 여전히 남아 있다.

$f$가 비교적 간단하고 $n$이 작을 때에는, 적당히 손으로 구해도 문제는 없다. 실제로 체비셰프는 직접 수기로 $x^n$을 $[-1, 1]$에서 최대 $n-1$차 다항식으로 근사하는 문제를 풀었고, 이를 체비셰프 다항식(Chebyshev Polynomial)이라고 부른다. 조금 더 복잡한 함수의 경우엔 컴퓨터의 도움을 받아야 하는데, 그 방법은 소련의 수학자 에브게니 레메즈(Evgeny Remez)가 1934년에 발표했다. 이것을 레메즈 알고리즘(Remez Algorithm)이라고 부른다.

레메즈 알고리즘은 드 라 발레푸생(de la Vallee-Poussin)의 정리로부터 출발한다.

Theorem. (de la Vallee-Poussin.) $f-p$가 $n+2$개의 점 $x_1, \cdots, x_{n+2}$에서 부호가 교차한다고 하자. (Alternating Set은 아니다.) 이 때, 다음이 성립한다.

Equioscillation Theorem에 따라서, 등호는 $p$가 최적 근사이고 $x_i$가 $f-p$의 Alternating Set일 때 성립한다.

드 라 발레푸생의 정리는 Alternating Set의 조건을 만족하는 점들이 아니라 구간 내의 아무 점에 대해서나 만족한다는 점을 생각하자. 레메즈 알고리즘은 우변을 최대화해나가는 점들을 반복적으로 찾아나간다. 그러다 등호 조건을 만족하는 점들을 찾는다면, 알고리즘을 종료한다.

Definition. (Remez Algorithm.) 다음 알고리즘은 주어진 $f$의 최적 근사 $p$, 오차 $E$, 그리고 $f-p$의 Alternating Set $x_1, \cdots, x_{n+2}$를 찾는다.

1. 구간 내의 점 $x_1, \cdots, x_{n+2}$를 임의로 잡는다. 보통 체비셰프 방정식의 해 $\cos(k/(n+2) \pi)$를 사용한다.
2. 미지수 $a_0, \cdots, a_n, E$에 대해서 연립방정식 $a_0 + a_1x_i + \cdots + a_nx_i^n + (-1)^iE = f(x_i)$을 푼다.
3. $p = a_0+a_1x + \cdots +a_nx^n$으로 잡고, $f-p$의 극점들의 집합 $M$을 찾는다.
   • 만약 고른 점들 $x_1, \cdots, x_{n+2}$가 $M$과 같다면, 알고리즘을 종료한다.
   • 다르다면, $M$을 새로운 점들 $x_1, \cdots, x_{n+2}$로 잡고 2번으로 돌아간다.

3번에서, $M$은 결국 $\lvert f-p \rvert$의 값들을 최대화시키는 점들이다. 즉, 이 점에서 드 라 발레푸생 정리의 식의 우변이 최대가 된다는 것을 확인할 수 있다.

Haar Condition

지금까지 우리는 $p$를 다항식으로 가정해 왔다. 그런데, 사실은 위에서 살펴본 내용 중에 다항식의 특수한 성질을 이용한 내용은 없었다. 즉, Equioscillation Theorem은 조금 더 일반적인 $p$에 대해서도 성립한다. 우리는 그 조건을 하르 조건(Haar Condition)이라고 한다.

Definition. (Haar Condition.) 서로 선형 독립인 연속 함수 $v_1, \cdots, v_n$에 대해서, 0이 아닌 함수 $p = a_1v_1 + \cdots + a_nv_n$이 언제나 $n-1$개의 해를 갖는다고 하자. 이 조건을 하르 조건(Haar Condition)이라고 하며, $v_1, \cdots, v_n$이 생성하는 공간을 체비셰프 시스템(Chebyshev system)이라고 한다.

당연히, $1, x, \cdots, x^n$은 하르 조건을 만족한다. 삼각함수들 또한 하르 조건을 만족함을 쉽게 확인할 수 있다.

이 블로그에는 수학 글이 자주 올라오기 때문에 수식 렌더링 기능이 필수적이다. 보통 이것은 MathJax나 KaTeX 같은 라이브러리의 자동 렌더링 기능을 이용해서 구현한다. 그렇지만 이것은 결국 클라이언트에서 도는 자바스크립트 파일이고, 단순함에 목숨을 건 나는 이것이 탐탁치 않았다(…) KaTeX은 서버 측 렌더링 기능도 지원하기 때문에, 별 생각없이 이 방법을 택했다.

다행스럽게도 Jekyll에서는 이 기능을 쉽게 구현할 수 있는 젬이 두 개 있다. 하나는 katex에 기반한 kramdown-math-katex이고, 다른 하나는 sskatex에 기반한 kramdown-math-sskatex이다. 전자의 경우 자바스크립트와 CSS 파일이 내장되어 있어 편하게 쓸 수 있지만, 구버전의 KaTeX가 강제된다. 후자의 경우 관리가 중단되었지만, 필요한 자바스크립트와 CSS 파일 등을 직접 설정해 줄 수 있다. 나는 둘 중 후자의 젬을 선택했다. 관리가 중단되었다고는 해도 코드가 워낙 간단해서 작동하지 않을 염려는 별로 없는 것 같았고, 최신 버전의 KaTeX를 쓰는 것이 더 중요하다고 생각했다.

JS / CSS 설정하기

설정법은 간단하다. Gemfile에 gem "kramdown-math-sskatex"을 추가하고 bundle install을 실행하면 젬을 다운받을 수 있다. 자바스크립트와 CSS, 폰트 파일의 경우엔 항상 최신 버전을 다운받도록 플러그인을 짰다. 말은 쉽지만, 루비는 처음이라 꽤나 고생했다.

require "open-uri"


KATEX_URL = "https://cdn.jsdelivr.net/npm/katex@latest/dist"

# Download css to _katex.scss
katex_css = URI.open("#{KATEX_URL}/katex.min.css").read()
File.write("_sass/_katex.scss", katex_css)

# Download fonts
CSS_PATH = "assets/css"
Dir.mkdir(CSS_PATH + "/fonts") unless File.exists?(CSS_PATH + "/fonts")
katex_css.scan(/src:url\((.*?)\)/).each { |font| 
    File.write("#{CSS_PATH}/#{font[0]}", URI.open("#{KATEX_URL}/#{font[0]}").read())
}

# Download katex
katex_js = URI.open("#{KATEX_URL}/katex.min.js").read()
JS_PATH = "_plugins"
Dir.mkdir(JS_PATH) unless File.exists?(JS_PATH)
File.write("#{JS_PATH}/katex.js", katex_js)

이제 이 파일을 _plugins 디렉토리에 넣으면, Jekyll이 알아서 컴파일 전에 이 파일을 실행시킨다. 마지막으로, CSS에 @include 'katex';를 적어주고, _config.yml에

kramdown:
  math_engine: sskatex
  math_engine_opts:
    katex_js: _plugins/katex.js

설정을 넣어주면 된다.

수식 인라인 기호 설정하기

일반 LaTeX을 포함한 내가 아는 거의 모든 수식 에디터는 $...$을 인라인 수식 렌더링 기호로 쓴다. KaTeX의 자동 렌더링 스크립트에는 delimiter 옵션을 통해 이것을 조절할 수 있다. 하지만, Jekyll이 사용하는 마크다운 엔진인 kramdown에서는 무조건 $$...$$을 인라인 수식 기호로 사용해야 한다. 정확히 말하면, 일반 문단 사이에 섞인 $$...$$는 인라인 수식으로, 독립된 블록은 블록 수식으로 파싱된다.

나는 이게 싫었다. 작성 습관을 바꾸는 것도 고역이었지만, 글을 쓸 때 애용하는 VSCode의 마크다운 렌더러에서는 $$...$$을 모조리 블록 수식으로 파싱하기 때문에 블로그와 다르게 보이는 것도 마음에 들지 않았다. 인라인 수식이 많은 글은 VSCode에서는 거의 볼 수도 없을 정도였다. 구글링을 좀 해 보니, kramdown에 등록된 이슈 중 정확히 나와 같은 문제를 겪는 사람이 있었다. 하지만 이슈에 달린 개발자의 답글을 보면 이것은 의도된 기능이며 바꿀 계획도 없다고 한다. ㅠㅠ

그렇다고 좌절할 수는 없다. 처음에는 Jekyll의 Hook 기능을 써서 직접 파서를 짜보기로 했다. 파싱까지는 regex 매칭을 이용하면 크게 어렵지는 않았지만, 문제는 예외 케이스가 너무 많다는 것이었다. 일단 코드 블럭 안의 달러는 무시해야 하고, 앞에 escape 문자를 붙인 달러 \$도 무시해야 하고… 등등.

결국 내가 선택한 방법은 kramdown의 파서를 직접 연장하는 것이었다. kramdown의 parser.rb를 보면, 간단한 설명과 함께 파서 구현 예제가 적혀 있다. 이것을 참고해서 루비 파일을 작성했다.

require 'kramdown/parser/kramdown'
require 'kramdown-parser-gfm'

class Kramdown::Parser::GFMKatex < Kramdown::Parser::GFM
    # Override inline math parser
    @@parsers.delete(:inline_math)

    INLINE_MATH_START = /(\$+)([^\$]+)(\$+)/m

    def parse_inline_math
        start_line_number = @src.current_line_number
        @src.pos += @src.matched_size
        @tree.children << Element.new(:math, @src.matched[1..-2], nil, category: :span, location: start_line_number)
    end

    define_parser(:inline_math, INLINE_MATH_START, '\$')
end

kramdown의 파서는 @@parser 변수에 파서의 목록을 넣어 놓는다. 그렇기 때문에 여기에서 내장된 :inline_math 파서를 제거한 다음 직접 만든 새로운 파서를 끼워넣기만 하면 된다. 위와 같이 이 파일을 _plugins 디렉토리에 저장하고, _config.yml의 kramdown 밑에 새로운 파서를 지정해 준다.

kramdown:
  input: GFMKatex

이제 일반 문단에서 $...$를 이용해서 인라인 수식을 작성할 수 있다. 원래 이슈에도 설명과 함께 이 코드를 첨부했고, 감사인사와 함께 따봉을 받았다. 문제 해결!

결론

처음에는 간단할 줄 알았는데 어쩌다 보니 kramdown의 소스코드까지 분석하게 됐다. Gatsby같은 NodeJS 기반의 프레임워크에서는 그냥 플러그인 하나 추가하는 것으로 쉽게 끝나는 것 같던데, Jekyll은 루비 기반이다 보니 자바스크립트와는 상성이 잘 맞지 않는 듯하다. 길게 보면 결국 Gatsby로 넘어가는 것이 좋을 것 같지만, 자바스크립트를 언제 배울 수 있을지… 일단 내가 원하는 기능은 어찌저찌 구현이 되었으니 블로그 글이나 열심히 써야겠다.

pip install unicorn
pip install pwntools
conda install sage

순으로 하면 된다.

CTF에서 crypto 문제를 풀 때, 수학 계산을 위해선 보통 sage를 쓰고, 소켓 통신을 위해선 pwntools를 쓴다. 나 같은 경우에는 conda 환경을 만들어서 사용하는데, 애플 실리콘이 들어간 맥을 사용하고부터는 두 개를 함께 설치하려고 하니 문제가 생겼다.

일단 conda를 이용해 sage를 설치하고, pwntools를 설치하려고 했더니 에러를 뿜는 것을 볼 수 있었다.

➜ conda install pwntools
Found conflicts! Looking for incompatible packages.
This can take several minutes.  Press CTRL-C to abort.
failed

UnsatisfiableError: The following specifications were found to be incompatible with each other:

Output in format: Requested package -> Available versions

pip을 이용해도 안 되는 건 매한가지였다.

➜ pip install pwntools
error: subprocess-exited-with-error
  
(대충 중간 생략)

× Encountered error while trying to install package.
╰─> unicorn

note: This is an issue with the package mentioned above, not pip.
hint: See above for output from the failure.

에러를 찬찬히 읽어보니 unicorn 패키지에서 문제가 생긴 것을 알 수 있었다. 다행히도, pip install unicorn만 따로 하면 설치가 된다. 그런데 이번에는 정작 pwntools가 설치가 안 된다!! 이후로 삽질을 엄청나게 오래 했는데, pwntools를 먼저 설치한 다음 sage를 설치하니 정상적으로 설치가 되는 것을 알 수 있었다. 즉, 반드시 다음의 순서로 설치를 진행해야 한다.

pip install unicorn
pip install pwntools
conda install sage

왜인지는 나도 모르겠다. 🤷‍♂️ 또 까먹을까봐 일단 블로그에 적어 둔다.

정수 문제는 일반적으로 아주 어렵다. 그렇기 때문에 수학자들은 아주 오래 전부터 정수 문제를 풀기 위한 방법을 고안해냈다. 예를 들어서, 다음의 아주 일반적인 문제를 살펴보자.

Problem. (Integer Relation). $a_1, \cdots, a_n \in \R$에 대해서, 다음을 만족하는 non-trivial solution $x_1, \cdots, x_n \in \Z$를 찾으시오.

만약 이것이 실수에 관한 문제였다면, 풀기가 아주 쉬웠을 것이다. 그냥 $a_1, \cdots, a_{n-1}$에 아무 수나 넣은 다음 일차방정식을 풀면 되기 때문이다. 그렇지만 해가 정수여야 한다는 조건이 붙어 있으므로, 가능한 해가 상당히 빡빡하다는 사실을 직관적으로 알 수 있다. 이렇게 실수들 사이의 정수 관계를 찾는 문제를 Integer Relation Problem이라고 하며, 다른 정수 문제들 또한 Integer Relation Problem의 일부분으로 생각할 수 있다. 예를 들어서, 아주 유명한 Subset Sum Problem을 살펴보자.

Problem. (Subset Sum Problem). 집합 $A \in \Z$와 자연수 $M$이 주어져 있다고 하자. 이 때, $\sum S = M$을 만족하는 $A$의 부분집합 $S$를 찾으시오.

이 문제는 다음과 같이 변형할 수 있다. 먼저, $A = \{a_1, \cdots, a_n\}$이라고 써 보자. 그렇다면, 다음과 같은 방정식을 생각할 수 있다.

이제 $S = \{a_i \mid x_i = 1\}$가 Subset Sum Problem의 해가 된다. 따라서, Subset Sum Problem은 조건이 더 빡빡한 Integer Relation Problem이라고 볼 수 있다.

오늘 이 글에서는, 이러한 정수 문제들을 기하학적으로 접근하는 방법에 대해 다룰 것이다.

Lattices

Lattice는 우리말로는 격자라고 번역할 수 있다. 마치 체스판처럼, 평면을 같은 크기의 칸들로 나눈 것을 격자라고 한다. 조금 더 수학적으로 써 보면…

Definition. (Lattice). 기저(Basis) $\mathbf{B} = \{\mathbf b_1, \cdots, \mathbf b_n \}$에 대해서, 격자 $\mathcal L(\mathbf B)$는 다음과 같이 정의된다.

Lattice Problems and Integer Problems

격자 위의 오래된 문제로는 다음 두 가지가 있다.

• SVP(Shortest Vector Problem): $\mathcal L$ 위의 가장 짧은 벡터 $\lambda_1$을 구하시오.
• CVP(Closest Vector Problem): 주어진 벡터 $\mathbf w \in \R^n$와 가장 가까운 $\mathcal L$ 위의 벡터 $\mathbf v$를 구하시오.

참고로, 두 문제 모두 NP-Hard임이 알려져 있다. 그렇지만, 특수한 조건 하에서의 SVP와 CVP는 쉽게 풀 수 있음 또한 알려져 있다. 따라서, 우리는 먼저 Integer Problem을 SVP로 바꾼 뒤(!) SVP를 풀 것이다. (CVP는 이 글에서는 자세히 다루지 않겠다.)

먼저, 위의 Integer Relation Problem에 집중하자. 이 정의에서, 주어진 $a_i$ 들에 비해서 정수 해 $x_i$들은 매우 작다고 해도 아무 상관이 없다. 왜냐하면, 주어진 식이 선형이므로, 적당한 factor를 $a_i$들에 곱해서 크기를 마음대로 조절할 수 있기 때문이다. 이제, 다음 행렬의 row들이 생성하는 격자를 생각해보자.

각 row를 $\mathbf b_i$라고 하면, 다음 벡터는 $\mathcal L$ 안에 들어있다.

위에서 각 $x_i$들은 충분히 작다고 했으므로, $\mathbf v$는 $\mathcal L$ 위의 짧은 벡터가 된다. 따라서, 우리는 $\mathcal L$에서의 SVP를 풀 수 있다면, Integer Relation Problem도 높은 확률로 풀 수 있게 된 것이다. 언뜻 보면 약팔이 같지만, 이 글에서 우리는 이 방법이 진짜로 먹힌다는 것을 증명할 것이다. 심지어는, NP-Complete라고 알려진 Subset Sum Problem 중 일부를 다항 시간 안에 풀 수 있다는 사실(!)도 알아볼 것이다.

Lattice Reduction

SVP를 푸는 가장 직관적인 답은 기저의 수직성(Orthogonality)를 생각하는 것이다. 왜냐하면, 다음이 성립하기 때문이다.

Claim. 기저 $\mathbf B$가 orthogonal하다고 하자. 그렇다면, $\lambda_1 = \min \mathbf b_i$이다.

pf. 직관적으로 당연하다. $\lambda_1 = \sum a_i\mathbf b_i$라고 하자. 이 때 일반성을 잃지 않고 $a_i \neq 0$이라고 하자. (즉, coefficient가 nonzero인 기저만 생각하자). 그렇다면,

이것을 조금만 더 확장한다면, 굳이 수직일 필요 없이, 적당히 수직이기만 해도 위의 Claim은 여전히 성립한다고 생각할 수 있다. 따라서, 만약 이 격자의 수직에 가까운 기저를 찾는다면, SVP를 풀 수 있을 것이다. 이 문제를 격자 축소 (Lattice Reduction) 문제라고 하며, 이것 또한 가우스 시대 때부터 연구된 유서 깊은 문제이다. (실제로, 2차원에서의 SVP 문제는 가우스가 가장 먼저 풀어냈다.)

그런데, 우리는 이미 일반적인 벡터 공간에서 수직인 기저를 아주 효율적으로 찾는 방법을 이미 알고 있다. 바로 Gram-Schmidt Orthogonalization이다. 까먹은 사람들을 위해 다시 써 보면,

Definition. (Gram-Schmidt Orthogonalization.) 벡터 공간 $V$의 기저 $\mathbf B$가 주어져 있을 때, 다음 과정을 통해 orthogonal한 기저 $\mathbf B^\ast$를 얻을 수 있다.

여기에서, Gram-Schmidt 계수 $\mu_{i, j} = \dfrac{\langle \mathbf b_i, \mathbf b^\ast_j \rangle}{\lVert \mathbf b_j \rVert^2}$이다.

물론, 이것을 그대로 우리의 문제에 가져다 쓸 수는 없다. 격자는 기본적으로 이산적이기 때문에, 이렇게 얻은 기저가 원래 격자를 span할 이유는 전혀 없기 때문이다. 하지만, Gram-Schmidt를 근사한다면 가능하지 않을까? 이것이 바로 LLL Algorithm의 아이디어이다.

LLL Algorithm

LLL(Lenstra-Lenstra-Lovasz) Algorithm은 1982년에 Arjen Lenstra, Hendrik Lenstra, 그리고 Laszlo Lovasz가 고안한 알고리즘이다.

Definition. (LLL-Reduced Basis) $\mathcal L$의 기저 $\mathbf B$와, 그것을 Gram-Schmidt한 기저 $\mathbf B^\ast$을 생각하자. (이 때, 물론 $\mathbf B^\ast \subset \R^n$이다.) $\mathbf B$와 $\mathbf B^\ast$가 다음 조건을 만족한다면, $\mathbf B$를 $\mathcal L$의 LLL-Reduced Basis라고 한다.

1. (Size Condition.) $\displaystyle \lvert \mu_{i, j} \rvert = \left\lvert {\langle \mathbf b_i, \mathbf b^\ast_j \rangle \over \lVert \mathbf b_j \rVert^2} \right\rvert \le {1 \over 2}$
2. (Lovasz Condition.) $\displaystyle \lVert \mathbf b_{i+1}^\ast + \mu_{i+1, i}\mathbf b^\ast_i \rVert^2 \ge {3 \over 4}\lVert \mathbf b^\ast_i \rVert^2$

Lovasz Condition의 $3/4$는 다른 값 $1/4 < \delta < 1$로 대체될 수 있다. 첫 번째 조건을 이해하는 것은 크게 어렵지 않을 것이다. Gram-Schmidt Orthogonalization에서 $\mu$ 대신 $\lceil \mu \rfloor$를 써서 근사하는 것과 동치이기 때문이다. 두 번째 조건은 살짝 이해하기 까다로운데, 접근하는 두 가지 방법이 있다.

첫째는 반례를 생각해보는 것이다. 만약 Size Condition만 주어졌다고 하자. 그렇다면, 만약 $\mathbf b_i$가 $\mathbf b_j$에 비해 매우 길다면, $\mu_{i, j}$의 크기는 둘 사이의 각도와는 관계없이 $1/2$보다 작아질 수 있다. 그렇다면, $\mathbf b_i^\ast$의 길이는 $\mathbf b_j^\ast$의 길이보다 아주 작거나 클 것이다. 하지만, Lovasz Condition이 주어진다면,

이므로, $\mathbf b_{i+1}^\ast$의 길이가 $\mathbf b_i^\ast$의 길이보다 아주 짧을 수는 없다. 즉, Orthogonal한 벡터들의 순서를 어느 정도 강제한다. 그리고, $\delta > 1/4$여야 한다는 사실도 알 수 있다.

두 번째 접근은 조금 더 엄밀하다. Gram-Schmidt를 거칠게 요약하자면, $\mathbf b_i$를 $\operatorname{span} (\mathbf b_1, \cdots, \mathbf b_{i-1})^{\perp}$로 사영(projection) 시키는 것이다. 이 정의에서 Lovasz condition을 바라본다면, 우변은 $\mathbf b_{i+1}$을 $\operatorname{span} (\mathbf b_1, \cdots, \mathbf b_{i-1})^{\perp}$에 사영시킨 것이고, 좌변은 $\mathbf b_i$를 이 평면에 사영시킨 것이다. 따라서, 비슷하게 이 조건은 벡터들의 순서를 강제하는 것이라고 이해할 수 있다. 만약 $\delta = 1$이라면, 이 순서를 엄밀하게 지킨다는 뜻이 될 것이다.

LLL Algorithm은 LLL-Reduced Basis의 정의에서 자연스럽게 따라나온다.

Definition. (LLL Algorithm.) 다음 알고리즘은 임의의 기저 $\mathbf B$를 LLL-Reduced Basis로 변환한다.

1. Gram-Schmidt Orthogonalization을 근사한다. ($\mu_{i, j}$ 대신 $\lceil \mu_{i, j} \rfloor$을 사용해서.)
2. 모든 $i$에 대해서 Lovasz Condition을 확인한다. 이 때,
   • 조건을 만족한다면 종료한다.
   • $\mathbf b_i^\ast$와 $\mathbf b_{i+1}^\ast$가 조건을 만족하지 않는다면, $\mathbf b_i$와 $\mathbf b_{i+1}$의 순서를 바꾼 뒤, 1번으로 돌아간다.

이 알고리즘의 Correctness는 거의 자명하다. Step 1을 거치면 Size Condition이 만족되고, Step 2를 거치면 Lovasz Condition이 만족된다. 다만 신기한 사실은, 이 알고리즘이 다항 시간 안에 종료된다는 것이다.

Theorem. (Runtime of LLL.) LLL은 다항 시간 안에 종료된다.

pf. 증명은 조금 테크니컬하다. 먼저 다음 두 값을 생각하자.

우리는 다음 두 보조정리를 통해 원래 정리를 증명할 것이다.

Lemma 1. $D$는 bounded되어 있다. 특히, $D \in \Z^+$이다.

pf. Upper Bound는 자명하다. 가장 긴 기저 $\mathbf b_{\text{max}}^\ast$를 대입하면:

Lower Bound는 조금 까다롭다. 먼저, $d_l = (\det \mathbf B_l^\ast)^2$임을 관찰하자. 여기에서 $\mathbf B_l^\ast$는 $\mathbf B^\ast$를 $l$ 차원으로 restrict 시킨 것이다. Gram-Schmidt Orthogonalization의 정의에 따라, $\mathbf B_l$과 $\mathbf B_l^\ast$의 transition matrix는 다음과 같이 정의된다.

따라서, $\det \mathbf B_l^\ast = \det \mathbf B_l \in \Z$이고 $d_l \in \Z^+$이므로, $D \in \Z^+$이다. Lower Bound는 자연스럽게 따라온다.

Lemma 2. $D$는 항상 감소한다.

pf. Step 1에서 $\mathbf B^\ast$가 바뀌지 않음은 쉽게 확인할 수 있다. Step 2에서, $\mathbf b_i$와 $\mathbf b_{i+1}$를 swap했다고 가정하자. 그 뜻은, Lovasz Condition이 만족되지 않았다는 뜻이므로,

이다. 이제, swap한 뒤의 벡터들을 $\tilde {\mathbf b}$라고 하자. 특히, $\tilde {\mathbf b}_i = \mathbf b_{i+1}$, $\tilde{\mathbf b}_{i+1} = \mathbf b_i$이다. 그러면 $\tilde d_l$은 어떻게 될까? 만약 $l < i$라면, $\tilde{\mathbf b}_k = \mathbf b_k$이므로, $d_l = \tilde d_l$일 것이다. 만약 $l \ge i+1$이라면, $d_l$과 $\tilde d_l$ 모두 $\mathbf b_1, \cdots, \mathbf b_i, \mathbf b_{i+1}$을 포함하므로, 역시 $d_l = \tilde d_l$일 것이다. 따라서, 다음이 성립한다.

그런데, 정의에 따르면

따라서, 우리는 $D$가 매 루프마다 적어도 $3/4$만큼 감소한다는 사실을 알 수 있다.

이제 Lemma 1과 Lemma 2에 따르면, LLL 알고리즘은 적어도 $\log_{3/4} \lVert \mathbf b_{\text{max}}^\ast \rVert^{n(n+1)} = O(n^2 \log \lVert b_{\text{max}} \rVert)$ 시간 안에 종료된다. Step 1, Step 2 또한 다항 시간 안에 종료되므로, LLL Algorithm 전체는 다항 시간 안에 종료된다. (실제로는 $O(d^5 n \log^3 \lVert b_{\text{max}} \rVert)$에 종료된다고 알려져 있다.)

이 증명 과정을 유심히 읽어본다면 $\delta < 1$이어야 하는 이유를 알게 될 것이다. 위에서 언급했듯이, $\delta = 1$이라면 $\mathbf b_i^\ast$들의 순서가 더 엄밀해지므로, LLL 알고리즘의 결과가 개선된다. 그렇지만, 우리의 증명 과정에서 사용한 $D$가 감소한다는 사실을 더 이상 쓸 수 없게 되므로, 다항 시간 안에 종료된다는 보장이 없어진다. 실제로도 이 경우에 LLL 알고리즘이 다항 시간 안에 종료되는지의 여부는 아직 open이다.

드디어 이 글의 종착지인 다음 정리에 도착했다.

Theorem. $\mathcal L$의 LLL-Reduced Basis를 $\mathbf B$라고 하자. 그렇다면 다음이 성립한다.

즉, LLL은 SVP를 $\sqrt 2^{n-1}$의 factor로 푼다.

pf. 먼저 다음 보조정리를 증명하자.

Lemma 1. $\lambda_1 \ge \lVert \mathbf b_{\text{min}}^\ast \rVert$

pf. 정의를 쓰면 간단하게 보일 수 있다. 위에서처럼, 일반성을 잃지 않고 $a_i \neq 0$이라고 하자.

이제 $\mathbf b_{\text{min}} = \mathbf b_m$이라고 하자. 위에서 보았듯이, Lovasz Condition에 의해 $\lVert \mathbf b_1^\ast \rVert^2 \le 2\lVert \mathbf b_2^\ast \rVert^2 \le \cdots \le 2^{k-1}\lVert \mathbf b_k^\ast \rVert^2$이 성립한다. 따라서,

양변에 루트를 씌우면 원하는 결과를 얻는다.

Solving Integer Problems using Lattices

지금까지 Integer Problem을 SVP로 바꾼 뒤, LLL을 통해 풀 수 있다는 것을 살펴보았다. 꼭 여기에 있는 문제가 아니더라도, 좋은 조건만 있으면 LLL 알고리즘은 좋은 해결책이 될 수 있다. 일반적으로는 다음과 같은 사고방식을 따르면 좋다.

1. 문제에서 어떻게든 크기가 작고 선형인 해를 뽑아낸다.
2. 적당한 Lattice를 만들어서 1. 에서 구한 작은 해가 SVP의 정답이 되도록 만든다.
   • 이 글에서 자세히 다루지 않았지만, 여기서 target vector의 크기의 좋은 가늠은 $\sqrt n (\det \mathcal L)^{1/n}$ 정도이다. 이 값보다 작다면, SVP를 통해 찾을 수 있을 가능성이 높다.
3. LLL을 통해 SVP를 푼다.
4. PROFIT!

Subset Sum Problem using LLL

위에서, 특수한 종류의 Subset Sum Problem을 다항 시간 안에 풀 수 있다고 했다. 이 특수한 조건이란 $a_i = O(2^{2n})$ 정도로, 개수에 비해 크기가 아주 큰 조건을 말한다. 이 경우 LO-Attack을 통해 Subset Sum Problem을 풀 수 있다. (후에 CJLOSS 알고리즘을 통해 이 bound는 $O(2^n)$ 정도까지 개선되었다.)

여기에서는 $n = 5$인 다음의 경우를 풀어보도록 하자.

arr = [1562, 1283, 1381, 1272, 1540]
target = 4483

LLL 알고리즘을 직접 코딩하기엔 시간이 너무 많이 걸리므로, SageMath를 이용해서 위의 풀이 과정을 따라가보자.

1. 문제에서 어떻게든 크기가 작고 선형인 해를 뽑아낸다.

이것은 이 문제에서 자연스럽게 주어져 있다. 위에서 보았듯이,

을 푸는 것과 동치이며, $x_1, \cdots, x_n$이 선형이고 작은 해이다.

2. 적당한 Lattice를 만들어서 1. 에서 구한 작은 해가 SVP의 정답이 되도록 만든다.

다음과 같은 Lattice를 생각하자.

각 row들을 $\mathbf b_i$라고 하면,

은 $\mathcal L$ 위의 작은 벡터이고, 따라서 SVP의 답이 될 가능성이 크다. 직접 코딩해보면:

L = []
N = len(arr)

for i, a in enumerate(arr):
    row = [0] * (N+1)
    row[i] = 1
    row[-1] = -a
    L.append(row)
L.append([0] * N + [target])

L = Matrix(L)
print(L)
# [    1     0     0     0     0 -1562]
# [    0     1     0     0     0 -1283]
# [    0     0     1     0     0 -1381]
# [    0     0     0     1     0 -1272]
# [    0     0     0     0     1 -1540]
# [    0     0     0     0     0  4483]

3. LLL을 통해 SVP를 푼다.

L = L.LLL()
print(L)
# [ 1  0  1  0  1  0]
# [-1  2  0 -2  1  0]
# [-3 -1  2 -1  0 -4]
# [ 2 -2 -2 -3  1 -3]
# [ 1  1 -4  2  3 -2]
# [-4 -2  1  1  4  1]

여기에서, L[0]이 우리가 정확히 원하는 형식으로 나왔음을 알 수 있다. (맨 끝의 값은 0이고, 나머지 값은 0 또는 1이다.) 따라서, 우리는 $x_i$를 전부 찾았고, 이 문제를 풀었다! 직접 확인해보자:

sol = []
for i, x in enumerate(L[0]):
    if x == 1:
        sol.append(arr[i])

print(sol) # [1562, 1381, 1540]
print(sum(sol), target) # 4483 4483

맺음말

이 글에서는 정수에 관련된 문제를 격자로 옮긴 뒤, LLL 알고리즘을 통해 푸는 방법을 알아보았다. 꼭 Integer Relation Problem과 관련된 문제가 아니라도, LLL은 초월수 판별, 정수계수 다항식 인수분해 등 다양한 문제에 폭넓게 쓰일 수 있는 강력한 알고리즘이다. 특히, 암호학계에서는 RSA의 가장 강력한 공격 중 하나인 Coppersmith Theorem에 응용된다. (언젠간 이에 대해서 다뤄볼 생각이다.) 꼭 응용이 아니더라도, 한 분야의 문제를 다른 분야로 옮겨서 푼다는 아이디어 자체가 수학적으로도 매력적이라고 생각한다.

코루틴이란, 함수의 실행을 잠시 일시 정지시켰다가 재개할 수 있는 기능이다. Python을 쓰던 사람이라면, generator의 개념에 익숙할 텐데, 제너레이터가 바로 코루틴의 일종이다. Godot 3에서는 yield 키워드를 통해 코루틴을 사용할 수 있다. 하지만, 그 행동이 비직관적인 데다가 매뉴얼도 제대로 작성되어있지 않아 이해하는 데 어려움이 많다. 이 글에서는 어떻게 yield 키워드를 잘 사용할 수 있는지 이야기해보려고 한다.

yield()

GDScript의 yield() 함수는 기본적으로 다음과 같이 정의된다.

yield(Object object = null, String signal = "")

따라서, yield()는 고도에서 두 가지 용법으로 사용된다. 첫째는 아무런 인자를 주지 않았을 때이다. 다음 코드를 보자.

func _ready():
    my_func_one()

func my_func_two():
    print("Three")
    yield()
    print("Four")

func my_func_one():
    print("One")
    var y = my_func_two()
    print("Two")
    y.resume()

var y = my_func_two()라인에서 my_func_two()가 호출되는 것까지는 그냥 return과 동일하다. 하지만 my_func_two() 블럭 안에서 yield()를 만났을 때, my_func_two()의 상태는 GDScriptFunctionState로 저장되어 반환된다. (혹은, 주도권이 caller에게 넘어간다.) 이 상태는 resume() 함수를 통해 재개시킬 수 있다. 따라서, 위 코드의 출력은

One
Three
Two
Four

가 된다.

yield(object, signal)

yield에 signal을 결합시킬 때 이 키워드의 진정한 힘이 나타난다. (signal에 대해서는 언젠가 다룰 기회가 있을 것이다.) 이 경우, yield는 object에 주도권을 넘겨준 뒤, signal 시그널이 감지될 때까지 함수의 실행을 일시 정지시킨다. 이를 활용한 대표적인 예제가 타이머이다.

func _ready():
    yield(get_tree().create_timer(1.0), "timeout")
    print("One")

위 코드에서 get_tree().create_timer(1.0)은 최상위 트리에다가 1.0초짜리 타이머를 추가하는 함수(=오브젝트)이다. 이 함수는 지정된 시간이 끝나면 timeout 시그널을 방출한다. 따라서, 위 코드를 실행하면 1초 뒤 One이 출력된다. 만약 yield가 없었더라면, 1초의 타이머는 _ready() 함수의 실행과 병렬적으로 일어나므로, 즉시 One이 출력된 후 타이머가 종료되었을 것이다.

또한, 모든 yield 키워드는 함수의 상태, GDScriptFunctionState가 파괴되었을 때 자동으로 completed 시그널을 방출한다. 공식 도큐먼테이션에 있는 코드를 살펴보자면

func _ready():
    yield(countdown(), "completed")
    print('Ready')

func countdown():
    print(3)
    yield(get_tree().create_timer(1.0), "timeout")
    print(2)
    yield(get_tree().create_timer(1.0), "timeout")
    print(1)
    yield(get_tree().create_timer(1.0), "timeout")

_ready()의 첫 줄은 countdown()을 코루틴으로 호출하고 있다. countdown() 함수는 우리가 배운 대로 3, 2, 1을 각각 1초의 간격을 두고 출력한다. countdown()의 마지막 yield문이 종료되면, countdown()은 값을 리턴하고 파괴되며, 이 때 completed 시그널을 방출한다. 그 다음에야 Ready가 출력된다.

여기서 헷갈릴 만한 지점은, yield의 기본 행동은 여기서도 유지된다는 점이다. 즉, countdown()의 각 yield(object, singal) 함수는 object에 주도권을 넘겨줌과 동시에 _ready()에 GDScriptFunctionState를 반환한다. 만약 countdown()을 코루틴을 사용하지 않고 그냥 호출한다고 하자.

func _ready():
    countdown()
    print('Ready')

func countdown():
    print(3)
    yield(get_tree().create_timer(1.0), "timeout")
    print(2)
    yield(get_tree().create_timer(1.0), "timeout")
    print(1)
    yield(get_tree().create_timer(1.0), "timeout")

_ready()는 먼저 countdown()을 호출하고, countdown()은 3을 출력한 뒤, 첫 번째 yield문을 만난다. 이 때 countdown()은 자신의 상태를 _ready()에 반환함과 동시에 get_tree().create_timer(1.0)에게 주도권을 넘겨준다. 따라서, _ready()와 countdown()은 이 시점 이후부터는 동시에 병렬적으로 실행되게 된다. 따라서 출력은 다음과 같다.

3
Ready
2
1

Godot 4

올해 안에 나올 Godot 4에서는 yield 키워드가 없어지고 await 키워드가 추가된다고 한다. 이는 C# 등의 다른 언어와 통일성을 갖는 동시에 많은 혼란을 줄여줄 것으로 예상되는 환영할 만한 변화 같다.