admin
	ps2 back, avg=33
today
	converting to block sources
	condensers
	GUV extractor
converting to block sources
	NisanZuckerman96
		if X\in\bits^n is a (\delta n)-source
			=> 	 random subset S\subset[n], |S|=\ell, X|_S is ~\delta\ell source whp
			=> pseudorandom subset S\subset[n], |S|=\ell, X|_S is ~\delta\ell source whp
				eg, pick S with k-wise independence
			=> (X|_S,X) is ~ (\delta\ell)\times (\delta(n-\ell)) block source
			[[then recurse]]
	[[want to quantify this conversion]]
	lem[chain rule for min-entropy]
		(W,X) k-source
		|\Supp(W)|\le 2^\ell
		\eps>0
		w/p 1-\eps, w\from W, X|_{W=w} is k-\ell-\log(1/\eps) source
		[[suppose W uniform, then this is about right]]
		[[not as nice as chain rule for shannon entropy]]
	pf: hw
	cor: X (n-\Delta)-source
		X=(X_1,X_2) some partition into n=n_1+n_2 bits
		=> (X_1,X_2) is \eps-close to (n_1-\Delta,n_2-\Delta-\log(1/\eps))-block source
	pf: hw
	rmk: suppose X is (1-\alpha)n source, for \alpha<1/2
		=> X is \eps-close to (n(.5-\alpha), n(.5-\alpha)-\lg(1/\eps))-block source
	idea: reduce to high-rate regime, then convert to block source
condensers
	def: Cond:\bits^n\times\bits^d\to\bits^m is k\to_\eps k' condenser if
		for every k-source X, \Cond(X,U_d) is \eps-close to a k' source
		is lossless of k'=k+d
	rmk: 
		m=k' is extractor
		k/n < k'/m is progress toward k'/m=1
	[[grand unified theory]]
	lem: Cond is a k->\eps k+d condenser iff it is a (=K,(1-\eps)D) vertex expander
	pf
		=> [[easy direction]]
			[[draw picture]]
			S\subseteq[N] size =K
			T=N(S) [[multiset]]
			X=U_S flat k-source
			Cond(S,U_d)=U_T [[as multiset]]
			\Delta(U_T,R)\le \eps, R (k+d)-source
			=> |\Supp(T)|\ge (1-\eps) KD [[as otherwise get distinguishing statistical test]]
		<= [[interesting direction]]
			|\Supp(T)|\ge (1-\eps) KD
			define Y\subseteq[M] of size KD such that Y\supseteq \Supp(T)
			U_Y is flat k+d source
			\Delta(Cond(X,U_d),Y)\le \eps
				[[draw picture]]
				[[we only changed \eps fraction of arrows]]
	[[PV codes => PV vertex expander => PV condenser]]
	cor[ParvareshVardy Condenser]
		\alpha>0 constant
		explicit PV:\bits^n\times\bits^d\to\bits^m, k\to_\eps k+d condenser
		d=O(\log (n/\eps))
		m=(1+\alpha)k+O(\log (n/\eps))
		[[get output min entropy rate 1-\beta any constant \beta]]
		[[so we can use this to convert to block sources]]
GUV extractor
	thm:
		explicit \Ext:\bits^n\times\bits^d\to\bits^m (k,\eps) extractor
		m\ge k/2
		d=O(\lg n/\eps)
	rmk:	later work gets m\ge (1-1/\polylog(n))k w/ same seed
		open: m=k+d-2\lg 1/\eps w/ same seed
			can get this if O(log k*log(n/\eps)) seed
	pf strategy
		[[similar to zig-zag product]]
		goal: build (k,\eps) extractor m=k/2, for all k
			recursively from (k',\eps) m'=k'/2 extractors
			[[need to increase min-entropy extracted
				need to increase output size]]
				min-entropy	seed	output	error
		base		k		d	k+d	\eps		[[leftover hash lemma]]
		induction	k		d	k/2	\eps
				2k		2d	k	C*\eps		[[extract twice independent seeds]]
				2k		d	k	C^2*\eps	[[block-source composition]]
		=> logarithmic # of rounds
			O(1) recursive calls per round => runtime C^{O(\lg n)}*\poly(n)=\poly(n)
			error \poly(n)*\eps
		but: parameters are much more messy
	extracting twice
		lem: 
			Ext_1:\bits^n\times\bits^{d_1}\to\bits^{m_1} is (k_1,\eps) extractor
			Ext_2:\bits^n\times\bits^{d_2}\to\bits^{m_2} is (k_2=k-m_1-\log(1/\eps),\eps) extractor
			=> Ext:\bits^n\times\bits^{d_1+d_2}\to\bits^{m_1+m_2} 
				Ext(x,(y_1,y_2))=(Ext(x,y_1),Ext(x,y_2))
				is (k,3\eps) extractor
		pf:
			Z_1=Ext_1(X,Y_1)
				\eps-close to U_{m_1}
				support size 2^{m_1}
			chain rule: w/p 1-\eps X|_{Z_1} is (k-m_1-\log(1/\eps))-source
			=> w/p 1-\eps \Ext_2(X|_{Z_1},Y_2) is \eps-close to U_{m_2}
			=> w/p 1-\eps (Ext_1(X,Y_1),Ext_2(X,Y_2)) is 2\eps-close to (Ext_1(X,Y_1),U_{m_2})
			=> (Ext_1(X,Y_1),Ext_2(X,Y_2)) is 3\eps-close to (U_{m_1},U_{m_2})
		eg: k_1=k/2, m=m_1=m_2=k/2-O(log(1/\eps))
			Ext_1:(k/2,\eps)->k/2-O(\log(1/\eps))
			Ext_2:(k/2,\eps)->k/2-O(\log(1/\eps))
			=>Ext:(k,3\eps) ->k-2*O(\log(1/\eps))
			[[hence we *almost* double output size, but this is okay in the end]]
	reducing seedlength
		lem:
			Ext_1:\bits^{n_1}\times\bits^{d_1}\to\bits^{m_1} (k_1,\eps) extractor
			Ext_2:\bits^{n_2}\times\bits^{d_2}\to\bits^{m_2} (k_2,\eps) extractor
			=> explicit Ext':\bits^{n_1+n_2}\times\bits^{d_2}\to\bits^{m_1+m_2-d_1}
				(k_1\times k_2,2\eps) extractor
			[[saw before]]
			[[block source composition]]
		lem[building block extractor]]
			t\ge 1 constant
			explict Ext_BB:\bits^n\times\bits^d\to\bits^m (k,\eps) extractor
				m\ge k/2
				d=k/t+O(\log n/\eps)
		pf: hw
			hint:
				use PV condenser
				convert to block source
				use LHL
		idea:
			Ext_1 \circ Ext_BB
				choose
					m_2=d_1
					k_2=2m_2=2d_1
				get
					d=d_2=k_2/t+O(\lg n/\eps)
						=2d_1/t+O(\lg n/\eps)
						=> d_1 is made arbitarily smaller by constant factor
					m=m_1
		lem:
			Ext:\bits^n\times\bits^d\to\bits^{m} (k/4,\eps) extractor, k>>d
			=> Ext':\bits^n\times\bits^{d/t}\to\bits^m (k,O(\eps)) extractor any constant t
		pf
			PV condenser: k-source in n bits to k source in (1+\alpha)k bits, any \alpha
			=> 2\times (k/2-\alpha) block source
			=> 2\times k/4 block source
			Ext: get m bits of output from first block seed d
			Ext_BB: second block yields d bits using seed ~d/t
			block source extraction => result
		hence:
			required more min-entropy for same output size
			but: seed-length dropped 
	recursion
				min-entropy	seed	output	error
		induction	k		d	k/2	\eps
				2k		2d	~k	C*\eps		[[extract twice independent seeds]]
				2k		d	k	C^2*\eps	[[block-source composition]]
		=> logarithmic # of rounds
			O(1) recursive calls per round => runtime C^{O(\lg n)}*\poly(n)=\poly(n)
			error \poly(n)*\eps
		but: parameters are much more messy
next time
	pseudorandom generators