those of us joining us on the video
recording apologies that you've missed

most of the storybook version of the
talk but we're now at the end where the

heroes have reflected sort of on what's
happened now that all the dust is

settled and you know they did some
soul-searching they looked deep inside

themselves and as is the case with the
ends of many of these stories they

discovered that the solution was within
them all along and so the the punchline

of this work is that these original
beautiful combinatorial constructions

actually can solve this this problem

individually right yes actually both of
these constructions solve this original

problem which I will quantify more in
just a second okay and then they live

happily ever after the end
okay so that's the talk alright that's

the short version of the talk but so now
that we've heard the short version let

me give the the longer version okay so
remember the short version was trying to

get around the fact that the title had
lots of buzzwords in it but so now let's

go back and look at the title and try to
deconstruct what it's saying okay so the

title has improved decoding a folded
reed-solomon a multiplicity codes so the

first part is folded reed-solomon &
multiplicity codes so these are the the

heroes of our story and these are
beautiful algebraic constructions of

error correcting codes so the second
part is decoding so both folded

reed-solomon codes and multiplicity
codes were breakthroughs in what's

called list decoding and local decoding
so they were really big deals but they

didn't quite solve all of the problems
and in particular there there are two

problems that I got to talk about today
that they did not quite solve so one of

them is with some jargon list decoding
to capacity with constant list sizes

this is that cognate Oryx problem that I
said before how many points can you pack

into a high dimensional discrete space
so that not too many of them live in a

small Hamming ball and the second is
something called high rate local list

recovery which I will talk about if
there's time left at the end and

subsequent work over the past five or
ten years has modified these

instructions and these constructions to
basically solve these problems but the

improvement here so that's the first
word of the talk title our improvement

is basically that these codes
essentially solve these problems all on

their own no fancy machinery needed so
that that's the

that's what this talk is about and so
the plan so first I'm gonna tell you

about list decoding and once again even
if you don't care at all about err

correcting codes this is a very natural
combinatoric problem so I hope you might

be interested in that
this is the goal that we were talking

about in the picture book version of the
talk and then we'll introduce our first

heroes folded reed-solomon codes so I'll
explain what they are and I'll prove to

you that they are listed codable to
capacity with constant list sizes

basically means solve this problem and
if time hopefully I think I should be

able to give you basically the entire
proof during the talk it's quite simple

then I'll wave my hands about how the
same thing can be done for multiplicity

codes which is this other construction
which I will define and time permitting

at the end I'll talk about this second
problem high rate locally list decoding

and how this can be achieved with local
with multivariate multiplicity codes and

then that'll be it okay so that's the
plan so let's get started with just what

our error correcting codes what is
listed coding what is this combinatoric

problem that our heroes are trying to
solve

okay so Aero cracking codes so for the
purposes of this talk an error

correcting code is just a set so I have
some big discrete space Sigma to the N

so Sigma is called the alphabet so it's
just some finite set and code is just a

subset of this big set so I go to call
elements of my code code words so this

red dot corresponds to a code word it's
just a vector of length n over the South

event and the reason I call it a code
and not a set is that I kind of think

about it as being kind of big and kind
of spread out so big means that the size

of this set should be roughly
exponential an N and kind of spread out

should mean that the minimum distance
here I'm measuring distance in relative

Hamming distance so the fraction of
coordinates on which I need two vectors

differ this distance between any pair of
code words should be pretty big okay so

and actually for almost all of this talk
I'm going to be talking exclusively

about codes which kind of achieved the
best trade-off between big and spread

out in this sense so I think you think
these codes that are really big really

spread out that's what I'm interested in
all right so that's what a code is list

decoding so here's the combinatorial
quiet question that I promised list

decoding is defined as follows so I say
that a code so some subset

is row comma el list decodable if for
all points Z in my space Sigma to the

end so for example here is Z if I look
at a Hamming ball of radius row around Z

the number of code words that live in
that ball is no more than some parameter

capital L right so not many code words
live in this Hamming ball does the

definition make sense and then we talked
about this for the whole talks if it

does not make sense ask a question good
ok so our goal is to create a set which

is as big as possible which has this
property that not too many code words

live in any Hamming ball no matter where
I put the Hamming ball ok so one

question might be why should I care
about this definition well one reason

one might care there's a natural sort of
communication interpretation of it which

is sort of the aircraft encode lens on
it so suppose that Alice wants to talk

to Bob but the problem is that anything
she sends to Bob is going to go through

some noisy channel which corrupts let's
say up to a row fraction of the symbols

so one way that Alice and Bob might
solve this problem in practice

assuming that let's say Alice it's like
a cellphone and Bob as a cell tower one

way they might solve this in practice is
to use an error correcting code which is

again a big set of strings that are all
far apart and the way they're going to

use this error correcting code is for
each of these strings they're going to

associate it with a message that Alice
might want to send so for example this

string might mean attack it dawn this
string my me make me a sandwich

and so on and so if Alice wants to say
something like attack at dawn she's

gonna send Bob that string and what Bob
hears is some perturbed version of what

Alice sent because the channel is going
to introduce some errors and so what

what he hears is this perturbed point
over here now if the perturbation is

very small then there's going to be only
a unique code word that is close to what

Bob hears and so Bob can kind of round
back and figure out what Alice meant to

say list decoding is interesting in the
case where the errors are much more than

that
we're actually there are lots of

different or there are multiple
different code words that Alice might

have sent and there's no way that Bob
can do unique decoding with the levels

of error that he's facing but this is
still a win if

not too many code words in this ball if
the code is well list decodable you know

Bob might not know exactly what Alice
means to say but he can narrow it down

significantly so in this case maybe she
meant to say either attack at dawn or

run away or make me a sandwich and maybe
Bob can immediately rule out make me a

sandwich because why would Alice say
that in a battle situation so this turns

out to be a useful primitive for
communication and and lots of other

tasks in there correcting codes another
reason we might care about lists

decoding is because this combinatorial
problem is just a useful notion and so

one reason is that it's related to
various pseudo random objects so for

example you can imagine forming a
bipartite graph by taking your code

words on the left-hand side and taking
your alphabet on the right-hand side and

connecting a codeword to an alphabet
symbol just if that symbol appears in

that code word so this and related
constructions are similar constructions

actually are some of the best ways we
know how to get good expander good

explicit expander graphs and extractors
I'm being a little fast and loose with

this but you can there's a really nice
survey of Vardhan which goes into more

detail about this so air crafting codes
are loose decoding in particular there

are lots of reasons we might care about
it so communication and pseudo

randomness it also shows up in algorithm
design and crypto and many other areas

so it's just a just useful conversation
and for today we're just going to focus

in on this straight-up combinatorial
comment orcs question how do we saw

design a big set which has this property
not too many points writable and along

with this there's a accompanying
algorithmic question which is if you

give me Z how do I efficiently find all
of these points so that would be

important for Bob in the the
communication setup okay so these are

going to be our questions for for the
rest of the talk everybody sufficiently

motivated

yeah very good yeah so you should think
of Sigma as being quite large so it's

the this question is very interesting
when Sigma is 0-1 but for this talk I'm

gonna be thinking of Sigma is being very
large so think of it as being like N or

maybe even polynomial in n that's sort
of the regime in which what I'm talking

about makes sense any other questions

great okay so the first question you
might ask is okay what can we hope for

what's optimal here but whatever what
our server benchmarks and again just

like Richard asked I'm gonna say when
Sigma is big what we can hope for when

Sigma is small is somewhat different and
another interesting question but for now

I'll just focus on Sigma so what can we
hope for so like many cases in coding

theory a random construction turns out
to be optimal so by random construction

what do I mean I mean you take your big
discrete space and you just start

popping down points at random okay and
it's not hard to see it's sort of a

simple exercise that this gets sort of
just about the best trade-offs you can

hope for so what are those trade-offs
well let me try just to be a little bit

quantitative so let's let Delta be the
minimum distance of this code so once

again that's sort of the the distance
between any pair of code words and let's

assume that Delta is as big as possible
given the size of Si and and I could

write down what that is but then I'd
have a big mess of parameters and no one

wants to see that so just assume that
it's but it's optimal and all the codes

we talked about today will be okay so
given this we might ask okay so how how

big can Rho be the radius of this ball
before I start happening let's say more

than a constant number of code words in
this bowler before I start having an

exponential number of code words in this
ball and it turns out that the answer

which is achieved by a random code is
that right yeah so sorry so so what can

we expect for how big Rho can be so one
thing to observe is that if we take Rho

equal to Delta over 2 then we can always
solve this problem with with size 1 no

matter where I put this little ball of
size Delta over 2 because everything is

Delta apart from each other I'm never
going to enclose more than one ball so

the answer for Rho is definitely gonna
be bigger than Delta over 2

is how big is it and the answer is that
basically it can be as big as Delta so

as big as the minimum distance of the
code and it's not hard to see that once

you get beyond that you start having an
exponentially you must start having an

exponential number of code words in the
ball so the right answer in some sense

is I should be able to take Rho the
radius of this ball as big as the

distance of the code the pairwise
separation between the two points

and codes which achieve this which allow
road to get that big without blowing up

in the list size we say that that
achieves list decoding capacity so

that's the best we could hope for and
that turns out actually to be a pretty

great answer I find this quite
surprising right basically this means in

the communication setting that you know
if I'm willing to go from one message to

a constant number of messages that Bob
might receive I can handle twice as many

errors so in the big alphabet setting
this means that basically even if 99% of

the symbols are corrupted Bob can still
recover a non-trivial amount of

information but I find this very
surprising it's very useful so the

question is okay now that we know what
optimal is we want Rho this radius of

this ball to be about as big as Delta
the distance between any two codewords

the question is how do we design an
explicit code that has this so I just

told you that a completely random one
does it but how do we design an explicit

one and also how do we have efficient
algorithms for it so these are the two

questions now in a slightly more
quantitative way that I'm going to ask

for the rest of the talk cool ok so now
that we know what the question is let me

tell you sort of a brief history of
attacks on this question so like I said

this has been open for a long time sort
of the first work in or that the kind of

launched algorithmic list decoding is
the work of guru Swami in Sudan in the

late 90s so they showed that
reed-solomon codes which I'll define

shortly are efficiently lists decodable
these are explicit constructions of

codes which are efficiently lists
decodable not quite up to capacity so

you can't get Rho quite as big as you'd
like

but it's still non-trivial and it's it's
a beautiful result this is sort of the

first like fast algorithm that we had
for these sorts of codes and then since

then
starting around 2005 there were a couple

of constructions which did better and
finally achieve list decoding capacity

so this is getting rid of the big nasty
dragon and putting in the little lizard

in my picture book version of the story
and so folded reed-solomon codes were

introduced by guru Swami and Rudra in
2008 univariate multiplicity codes by

guru Swami had weighing and
independently by compartir in 2011 and

2012 and they showed that these
constructions you can get Delta or you

can get Road like as big as you would
want the optimal bigness the downside is

that the list size ends up not being
constant which is what you would want

but instead polynomial in in this is
much better than exponential and end but

still not quite constant and then since
then there's been a lot of work here's

some of it basically modifying and
taking variants of these sorts of codes

maybe by replacing them with you know
some algebraic geometry codes your

techniques from about drug geometry or
introducing techniques from expander

graphs on top or introducing something
called subspace designs to kind of yeah

they're bit many modifications and
basically these have been able to reduce

the list size down to a constant the
star here is hiding some log star and

factors for some of the things but this
is this is essentially good right and so

with the story that I was telling
earlier the the punchline of this talk

is that he's folded reed-solomon in
univariate multiplicity codes actually

still no we knew they'd already achieved
capacity that you could get rows because

you wanted but now you can actually do
it with constant list sizes so sort of

these this this fancy machinery is not
necessary to solve this problem

cool okay so that sort of intro to list
of coding intro to the setup question

should interrupt me at any time yeah

right so the right answer for this
constant it depends on how close row is

to Delta so if row is like just epsilon
away from Delta then the right answer

for this constant is like 1 over Epsilon
I have an opinion about what the correct

constant should be in front of that one
over epsilon but I'm not gonna say it in

public we do not get that so we get some
some function of epsilon which is not

quite right and that's one of the big
and questions left by our work is

getting it down to to the right the
rights list size that I ran and could

would achieve cool
any other questions yeah random constant

she's one over epsilon the constant in
front is one but I can get you a code

which does better in terms of the
leading constant but that's another

story it does yeah so the it depends on
the alphabet size but I'm assuming the

alphabet sizes growing hmm with n yeah
so all of these things are under the

assumption the alphabet size is growing
the if the alphabet size is constant

then the correct list size has that
constant in it but the contribution goes

to 0 as Delta as the alphabet size goes
to infinity so there's probably should

be a little one or more questions okay
so now let's go on to the now that we

all know what the problem is let's go on
to the second part where we introduce

our first hero folded reed-solomon codes
okay so actually before I tell you about

fold 3 Solomon codes just quick aside
about finite fields so let Q be a prime

power so throughout the talk FQ is going
to denote the finite field with Q

elements if you haven't seen finite
fields before fine it's just it's some

finite set where arithmetic works like
you want it to that's all we need and

I'm also going to use the fact which I'm
not even going to use it I'm just going

to use it in my notation that I can
write all of the elements of this finite

field as gamma gamma squared gamma cubed
up to gamma the Q minus 1 for some

nonzero element gamma and that is all we
need about finite fields ok ok so now

let me tell you about reed-solomon codes
so I'm going to tell you eventually

about folded reed-solomon codes finally
what reed-solomon codes are first

so what are we telemon codes so this is
a classic polynomial code so these have

been around since the 60s they were
invented by Reed and Solomon surprising

the ones and yeah they've been around
for a long time they're used in

everything so they're used in hard
drives they're used in QR codes like

that you scan with your cell phone
there's a Reed Solomon codes there

they're everywhere
and so what are these codes

so the alphabet is FQ finite field of
size Q and the length is Q minus 1 so FQ

to the Q minus 1 and code words in this
set so these red dots correspond to

polynomials of low degree over FQ so I
have my set here of polynomials over F Q

of degree less than K and I'm going to
map these polynomials into the code

words by evaluating a polynomial at all
the nonzero points in FQ so given a

polynomial F I'm going to get a code
word that looks like this

so f of gamma f of gamma squared FF
gamma cubed up to F of gamma to the Q

minus 1 and that will map it into a
vector that lives in FQ to the Q minus 1

down here was the definition make sense
cool see ya who's seen this before some

people not everyone right
okay so reed-solomon codes are this

really nice construction and one reason
they're really nice and used everywhere

is because they have very good distance
each one of these points is pairwise

very far apart in fact it's sort of the
optimal value of pairwise far apart that

you could possibly hope for and the
reason for that is that low degree

polynomials do not agree in too many
places right this code word is basically

like a graph of some polynomial and if I
took another code word corresponding to

some polynomial G it's a graph of a
different polynomial and F and G being

low degree polynomials integrate agree
in at most K places right sorry the most

in my table
yes in most K places so they don't they

don't agree to many places which means
they have good distance great okay so

now what are folded reed-solomon codes
so now we know what reed-solomon codes

are folded reed-solomon codes are just a
very beautiful riff on reed-solomon

codes we just take this codeword and we
fold it so what do I mean by folded I

mean you take like the first M symbols
here and you bundle them and make them

one simple and then you take the next
two M symbols and you bundle them and

you make them another symbol and so on
and so what I'm left with is a code over

a larger alphabet so the alphabet is now
FQ to the M because my symbols are now M

tuples of values of my finite field and
the length is a little bit shorter

instead of being Q minus 1 it's now Q
minus 1 divided by M so just but

otherwise I'm not doing anything else
I'm just sort of repackaging the symbols

right so the alphabet is FQ to the M the
length is Q minus one over N so make

sense cool and once again this same
observation holds low degree polynomials

continue to not agree in too many places
and these codes all inherit sort of

these nice distance properties from
reed-solomon codes so they have the best

trader okay yeah so what's going on so
this is a code the code word is

basically like the whole matrix and this
is the first symbol as a point in space

I'm looking the space I'm looking at is
FQ to the M to the Q minus one over m so

that's my big blue circle is FQ to the M
to the Q minus one over m and then these

are these are elements of that space so
I haven't really changed anything except

like I put an M in here and divided by M
out there I'm just thinking of it

exactly yep I know say I'm evaluating it
the same number of points the the length

has gone down that's right yes yeah
right yeah so that's the key is that the

notion of distance has changed now and
what it means to corrupt a symbol is not

corrupting just one of these but
corrupting this right yeah Richard it is

a power it turns out that for finite
fields there is some element so that if

I start powering it up I'll eventually
iterate through the whole field yeah yes

it's a primitive element of the field no
it could just just fix any of them yes

yeah I just described the code word so
how would use it to encode probably

should have another picture like this
we'll take our rights

for purposes of this talk a code is just
a set so I don't need to tell you it

encoding algorithm but I will anyway
just just out of the charity right so we

will take a message which we're going to
associate with a polynomial of degree

less than K so if you like yes you think
about it's a message as the coefficients

of the polynomial and then I'm going to
the way you encode or read psalm

encoders I just evaluate this polynomial
the way I encode a folder reed-solomon

code word is I'm going to evaluate the
following polynomial and then do this to

it okay so the alphabet will change
between the encoding and between the

message and the codeword that's okay so
it makes sense everyone else on board

with the okay yeah so so all we're doing
is just just repackaging the symbols so

now it's a shorter code word over a
bigger alphabet but but otherwise

nothing else is happen so this is just
describing some subset of this thing so

take all of the vectors that look like
this for all the degree polynomials that

tells you some subset of this funky
space and that is a full good Reed

Solomon code great ok so these guys have
good distance for the same reason and as

before they have the best trade off you
can get between the distance and the

sides of the code turns out and another
observation which will be useful in the

future is that the the space of these
things so before I said okay this is

just a set of elements of this thing
that is now covered up but they're

actually also form an FQ linear subspace
so what that means is that if I take any

of these two things that you have to
treat them as as matrices or something

if I add them together I'm gonna get
another code word another thing that

looks like this
because if I add too low degree

polynomials I get another low degree
polynomial and also if I multiply it by

scalars in FQ I still stay in the space
because if I multiply a polynomial by a

scalar it's still a low degree
polynomial alright so this is this form

some FQ linear subspace so that would be
useful so the the main punchline and

this is a result of course Swami and
Rudra is that folded reed-solomon codes

achieve list decoding capacity and this
is really why they're the heroes of this

story is they were they were the first
it's known to do so and I find this very

surprising it'll draw you a picture as
to why I find this surprising so you can

one can show that reed-solomon codes
themselves do not achieve capacity so

that means for the reed-solomon codes
like in this picture there is a set of a

bunch of code words that live in some
ball there's some cluster he said right

and what this is saying is that when I
fold it just by repackaging things

somehow the code words become magically
spread out and this no longer happens so

on a first glance this might seem kind
of magical the way I like to think about

it is is something that someone said
earlier like the reason this is possible

is because the notion of distance
changes so for example like consider

like this this code word or sorry this
word Z which is might be what you

receive and consider the difference
between Z and one of the close code

words in this ball let's say they differ
in in these spots so for the

reed-solomon case this is like an
allowable error pattern but if it has

let's say row a row fraction of errors
but if I take this error pattern and I

kind of move it into the folded version
maybe it looks like this this all of a

sudden becomes no longer an allowable
error pattern because before I was

corrupting a row fraction of the symbols
and now I'm corrupting a row x m

fraction of the symbols which is not
allowed if I'm only looking for row so

basically the the reason this one way to
think about why this works is that

you're kind of restricting the power of
an adversary if the adversary is is

adding errors into your code board the
adversary there are fewer error patterns

open to them and ok so now maybe this
convinces you that there is some M such

that this should get nice and the
surprising thing that Gore Swami and

Rudra showed is that this works even
when n is a constant so I just jack up

the field size just a little bit and I
check up the alphabet size just a little

bit just by a constant constant exponent
and all of a sudden I go from nowhere

close or probably nowhere close to list
decoding capacity up to lest building

capacity yeah yes
yeah and that's actually the only reason

why I needed to be writing the elements
in this particular order

so if you fold them in this particular
order the proof of guru Swami and Rudra

goes through and it's a very nice sound
to break proof I can show that if you

take a if you put them in a random order
and fold them it also works well but I

cannot show that an arbitrary order
works well I don't know whether that's

true or not but it certainly matters for
the analysis the order yeah good

question
any other questions oh I see yes so in

all this setting I'm assuming that the
randomness might be used to create the

code once and for all and then the
adversary gets to inspect it in an

unbounded way yes the adversary is
absolutely worst case yeah it turns out

if the adversary is random like can't
see what your code is then even if you

just like scramble the symbols like you
don't even need to do list of coding you

can uniquely decodable ax T oh yeah

that's right yep

yes oh the scaling right so before N and
Q were basically the same and and now N

and n times M is equal to Q and so think
of M as being a constant so n is still

scaling linearly with Q or Q is still
staying scaling linearly linearly with n

that's right yeah more questions

great ok all right so for folded
reed-solomon codes now there's a there's

good news and bad news
so the good news is that like I just

start with the bad news okay the bad
news is that even though we have these

nice list decoding results from guru
Swami and Rudra and then the follow-up

work by guru Swami and Wang they only
show that the list size the number of

points in this ball is a polynomial in n
well ideally we'd want constant so

that's the bad news but the good news is
that the second work actually shows that

this polynomial size list is very
structured it lives in a low dimensional

subspace I'm so here I've changed my
picture slightly to try to capture the

fact that this code is an FQ linear
subspace so now it has linear structure

see yeah my cartoon and and what this is
saying is that if I look just at the

points that live sort of in this ball
they live in an even lower dimensional

subspace like a constant dimensional
subspace so the number of points in a

constant dimensional subspace is cued vo
of 1 and we just said that Q is scaling

linearly with n so this is like n to the
O of 1 so this isn't telling you that

the list is small it's telling you it's
polynomial which is the result but it

does tell you that it has some
additional structure which is nice and

actually this fact has been used to
obtain some of those modifications that

I mentioned at the beginning so our new
result is that actually folded

reed-solomon codes have constants list
size someone was asking before about the

constant this is the one we can prove so
in particular take choose any epsilon

greater than 0 any delta that you like
there is a family of folded reed-solomon

codes with distance at least Delta which
are Rowell lists decodable for row sort

of approaching this capacity so row
approaching Delta arbitrarily close and

L which is constant but just depends on
the

back this additive back off Epsilon
you're backing off capacity back yeah we

know what the right power is one yeah so
however they're still not the right

answer which should be whatever Epsilon
I can't I can't prove that or else I

would have put it on the slide but I
strongly believe this is the right

answer
yeah so where does 1 over Epsilon come

from so actually the what the actual
answer is is it's asymptotically equal

to 1 over Epsilon but if you work it out
the most natural rate right it is in

terms of the qre entropy and then the
Taylor expansion says this is roughly 1

over epsilon in this parameter regime so
I'm not sure that there's I don't know

if that comes up in queuing theory as
well or ok I mean we can talk offline

about where exactly this comes from but
in particular if I were over and out

small alphabet this would be 1 over
epsilon squared because in that

parameter team that's how the atrophy
happens that that's how qre entropy

happens to behave so the 1 over epsilon
is kind of particular to this parameter

regime yeah more questions about the
result awesome ok so I'm going much

lower than I anticipated but I think I
will still have time to tell you the

proof so the proof idea I've already
told you all the ingredients we need the

proof ideas as follows so what are the
two things we know we only basically

know two things so far about these codes
we know that all of the points that that

sort of live in the true list here all
of the points that live in this Hamming

ball actually live in a low dimensional
subspace and we also know that this code

has really good distance Irish all we
need here is constant distance and

dilemma so this is the lemma that the
main lemma is that if you have thing 1

and thing 2 then you have the answer
that you want if Rho is less than Delta

so all the way up until this capacity
thing there are at most a constant

number of code words that live in this
ball so all you need is this low

dimensional thing and the fact that they
are all spread out

so that that's what we're going to show
do people see why this will we'll finish

the proof and you up to some
quantitative stuff okay so the proof

idea proof by algorithm proof by
randomized algorithm which makes it

appropriate for the algorithm and
randomness Center is the following so

suppose that T is the correct list of
code words here so here's T these these

points that live in the ball and let's
let V be the FQ span of T so I said they

live in some low dimensional subspace so
suppose this is V so notice that V might

contain points outside the ball - it
contains a polynomial a number of points

and what we'd like to do is prune this
subspace V down to just a constant

number that truly live in the ball and
show that there's only a constant number

there right so V has flow dimension and
all the points in V are pairwise apart

and so the strategy is going to be to
define some randomized algorithm prune

which has the following property so it
takes as input V this low dimensional

subspace and also Z the original point
and it's going to output either

something in this subspace so some thing
here or it's going to output bot and the

guarantee is that for any of these
actual code words the ones in T that we

want to recover with some small constant
probability prune will return that thing

does that make sense
I don't know I don't care I don't care

yeah so all I wanted I could always
check if it's close so then this

inspires a randomized algorithm which is
once I have this thing well run it ten

thousand times and this will be some
small constant that will depend on

epsilon and Delta in ways that I'm
suppressing

so run it run at a constant number of
times and just we type and then with

high probability you'll you'll find all
of the points and so in particular this

implies that the number of points in
this ball is constant scales like 1 over

whatever the small constant is so
outline makes sense so all I need to do

is tell you what this algorithm is and
it's actually super simple ok so here's

the algorithm so remember my goal is
that for any of the code words in this

ball I just want to make sure that I
return it with probability at least some

small constant
okay so prune takes his input V and Z so

let me draw them here so here's a Z and
this is a vector of length n which is

the center of my ball and here's all of
the code words in V all right so a whole

bunch of them some low dimensional
linear subspace where everything is far

apart and what I'm going to do is choose
a subset of n of such constant size

randomly so let's say I choose these
coordinates at random and ignore

everything else and now I'm going to
find all of the V's in my list so that V

sub I is equal to Z sub I so the agrees
with Z on these special coordinates all

right so let's say that this is one of
them all of these coordinates agree with

Z and if there is exactly one such V I'm
going to return it so in this case

there's exactly one such V this is what
I will return and otherwise I'm going to

return bottom if there's more than one
or if I don't find any so that's the

whole algorithm I'll give them make
sense doesn't make sense or okay

all right let's see why it works okay so
why should this work so we need two

things so the first thing we need is
that if you know there's some V that is

actually close to my code words see that
I that it will agree with Z and all the

places that I picked so that I actually
include it with some small probability

you can work out what that probability
is it's at least 1 minus Rho to the size

of the set and that's because all the
points that I'm interested in our row

close to Z so with high problem or with
probability 1 minus Rho I'm going to

pick some coordinate that I agree on and
I'm thinking I coordinates independently

1 minus sort of the I great and the next
thing the the trickier bit is to the

part with the bot is to show that I
there are not too many of these that

there's no more than one probably
so in particular I need to show that the

probability over this set that I choose
that there exists two distinct things

here which both agree with Z is very
small smaller than this ideally and so

that's that's the claim that I'm going
to prove for you now which is that it's

very unlikely that there is
I'm gonna prove actually a slightly

different claim I'm gonna show that it's
very unlikely that there is a nonzero

vector V in here so that when restricted
to all these positions it's zero on all

of them and because the code is linear
this will be enough to imply imply this

thing here all right so that's the claim
I want to prove I'm just gonna say it

again just so everyone understands I
have this set of code words in my subs

or not code words I have a set of things
in my subspace oh they are good words a

set of code words in my subspace I'm
gonna pick a random set ignore of

positions ignore the rest and I want to
say that probably there is no column

that has all zeros left I say this
happens with very small probability

that's the goal all right so let's let's
try to prove it so the fowling has

helped because we know that the output
list is low dimensional yeah and that's

ulema from from previous work that we're
using so that's the key they said with

when you do this folding you somehow get
this low dimensional structure out that

argument is also very slick but probably
not not five minutes like yeah this part

is code it's folded yeah so think of
each one of these things as being like

an M tuple of a full bit things right
great okay so let's try to prove this

lemma so our first try might be might
just be to be might be to just use

distance right so we know that V has
points that are all far apart V is a

subspace so 0 is in V and so that means
that every other nonzero thing in V has

at least a Delta fraction of non-zeros
all right so if I start sampling them at

random you know I have a delta you know
what one is Delta probability of hitting

a non zero okay so the probability that
for any fixed V that I hit all zeroes is

1 minus Delta to the I which is some
constant because Delta is some constant

and I is some constant some little tiny
constant and then I need to take a Union

bound over all of the things in V and
how many things are in V well polynomial

a many so this this Union band will not
work ok and in fact the statement is

false
so going on just distance alone is not

good enough but now we can use this
other thing and this is where the

folding comes in that this all lives in
a low dimensional subspace and I claim

that this is enough to make the proof
work so let's see why so recall that

right so not only is just we have good
distance but it lives in some constant

dimensional subspace so that means that
every one of these code words that live

in V I can write as some matrix times
some vector in fq and again like each

one of these boxes is actually in this
it's it's I just think of it as a tuple

but if you want to think of it as just a
field element this logic works fine so

to multiply it by some vector and FQ and
I can get that good word and picking

random rows of or so picking random
entries of my codeword is the same as

picking random rows of this matrix and
so then saying that it's very unlikely

that there's a nonzero V so that V a sub
I is equal to 0 so that all of these are

equal to 0 is the same as saying that
it's very unlikely that this matrix does

not have full rank because if there's a
nonzero thing here that can multiply and

get all zeroes here that means that this
matrix has some kernel vector right so

it's snuffle ring so I'm gonna move that
claim up here I want to show that it's

very unlikely that this matrix a does
not have full rank ok so how does it

work first let's make an observation any
sub matrix of a with 1 minus Delta times

n rows I claim this does have full rank
and the reason follows from the distance

right so suppose that this set of 1
minus Delta times n rows does not have

or let's just consider any set of 1
minus Delta times n rows the observation

is that not all of these can be 0 if
this vector is not 0 because then we'd

have a nonzero code word with too many
zeros which contradicts this distance

thing so this guy must must have full
rank ok all right so we have this

observation which has follows from
distance and now I'm gonna do a thought

experiment so consider picking these
rows randomly one at a time and suppose

that I I'm picking them and I'm picking
them and I'm thinking them and I do not

yet have full rank so now I claim well
let's consider sort of what happens if I

pick the next row let's call a road bad
if it fails to increase

the rank and good if it does increase
the ring so I claim that there's at most

a 1 minus Delta fraction of bad rows and
the reason is because if I pick them all

then I wouldn't increase the rank so I'd
still have a low rank or nu a degenerate

matrix and all of those have at most 1
minus Delta n rows by our earlier

observation so that means there's at
most 1 minus Delta infraction of sort of

bad rows that won't increase the rank of
this matrix which means that there's a

delta fraction of good rows which will
increase the rank of this matrix so pick

the next row at random let's say I got
lucky and picked it down here then with

probability at least Delta this does
increase the rank and so what I'm saying

is I have this process now where I'm
picking rows at random and with each

time with probability Delta at least
Delta I'm going to increase the rank and

I just want to get up to rank about s
and so you can kind of work out the the

math and show that this implies that
with high probability if you do sort of

order s or order F over Delta choices
you'll reach full rank rank s and this

this logic proves the claim there's
slightly more formally and actually

should say this this lemma is similar to
one that appeared in work by Sir often

you cannon in 2011 if you have this sort
of setup we have a low dimensional

subspace you're picking the columns at
random and then there's some choice of I

which is linear and s so that the
probability of this matrix does not have

full rank is small and in particular
it's smaller than say 1/2 times 1 minus

Rho to the I see you can work this out
and why is this useful so let's return

to the the outline the first thing we
needed is that you know if C is actually

close to Rho then we'll probably return
it well so we we already saw that we

were going to return it with probability
1 minus Rho to the I and the next thing

we needed is that the probability that
there's a collision that the algorithm

is going to return but is very small and
what we've just showed is that this is

less than 1/2 times 1 minus Rho to the I
that's that's what if you work out the

details of the previous logic is what
this shows so then what's the

probability that prune returns any
particular code words C that lives in T

well it's at least the probability that
it picks out T minus the probability

that it there are too many of the things
in it return spot and by what we just

worked out this is at least 1/2 times 1
minus Rho to the I which

some constant because Rho is a constant
and the size of I is a constant so

that's it so then this feeds back this
is just a slide I had before the proof

idea for the lemma proof by algorithm
now I've told you what this randomized

algorithm prune is Mark and this proves
the theorem which is that if we have low

dimensional subspace and good distance
then there's not too many code words in

this ball and I should say this is not
actually the argument we use in the

paper we can get better parameters by
using a slightly fancier arguments so in

particular so I told you that it's for
anything at a low dimensional subspace

it's you know pretty unlikely to get all
zeroes here it turns out for folded or

Solomon codes it's like really really
unlikely for something you know specific

to reed-solomon codes this turns out to
be basically the same as saying that

folded reed-solomon codes are good for
constructing something called subspace

designs which is what they were trying
to do in this paper great okay so that

with this modification proves proof
cysts there any questions about this

yeah where do I get this exponent where
do I believe it should be one all right

so this exponent comes out of this this
argument all right so basically it

you're trying to quantify really how
unlikely is it that you get all zeroes

here the reason I think it should be one
is because that's what random codes

achieve I can't prove a lower bound that
says that that's the best but I think

that that is the best and you know you
would hope that these codes are good and

this is also what random linear codes
achieve so it's the linearity structure

doesn't it doesn't hurt you there so
yeah I don't have a strong reason other

than other examples great okay so I am
going way way slower than I thought I

would so next I was going to talk about
univariate multiplicity codes so maybe

I'll just define them and tell you the
punchline and then wrap up so univariate

multiplicity codes are another beautiful
construction of aircraft and codes

Dudek parties are often you can in
around 20

and again they are a very elegant riff
on reed-solomon codes so the way they

work is you take your reed-solomon code
word and now you still turn it into like

some sort of bundled code word but
instead of folding it what you do is you

add derivatives so now the code word has
the same length it looks like it has a

shorter length because I just copied and
pasted this slide from the folded

retelling codes it should have the same
length and but what I'm doing now is

instead of taking F of gamma is my first
symbol I'll take gamma bundled together

with F prime of gamma bundled together
with half double prime is gamma all the

way down to the M derivative of gamma so
these codes still have a bigger alphabet

and now they have they have like that

okay so these are multiplicity codes and
multiplicity codes were introduced

actually in the context of local
decoding I say more later but I'm not

going to get to it I sorry
and they were a real breakthrough in

local decoding there the first
construction we knew of of high rate

locally decodable codes but it turns out
they also attained less decoding

capacity and this is a result of
compartir and gorse omean way and once

again with this result we have bad news
and good news the bad news is that you

have polynomial list size the good news
is just like with full degree telemon

codes the argument is actually very
similar the list lives in a low

dimensional subspace this low
dimensional thing follows from the

decoding algorithm if they give actually
and so we have exactly the same picture

that we had before and exactly the
analogous theorem holds so we get the

same list size and you know some other
slightly different requirements on the

parameters so we saw that float yeah
multiplicity codes also then solve this

holy grail problem and once again
previous results had polynomial list

sizes and now we have constant although
this is still not the right constant at

least I don't believe it is great okay
so now I think in the interest of time

my next bit was going to be about
multivariate multiplicity codes and how

these can solve yet another problem that
had been open for a long time but I

think I'm going to skip that and then
people can ask me offline if they're

interested and just maybe I'll just give
the conclusion of that bit okay

so highlight lil coolest recoverable
codes I haven't told you what these are

but they can be used to construct
capacity achieving locally this

decodable codes near linear time global
and near near linear time global list

decoding algorithms so there they were
something that the coding theory

community has been searching for for a
while the first construction was just

given last year by myself with Brett
Hemingway and Oberon zuy and I can say

this cuz it's my own work it's kind of a
beast there's a lot of moving parts and

it's you know there's a lot a lot to get
going and what this work ends up showing

is that if by applying that result for
multiplicity codes that I already said

we can show that multiplicity codes
actually had this this property high

rate local list recoverability whatever
it means all along so our multiplicity

code heroes actually solved this this
problem that we needed off to my Optimus

Prime to solve last year okay so let me
just wrap up so recap there are a bunch

of problems in coding theory that we
might like to solve but there were some

obstacles to get to the problem we had
our heroes folded reed-solomon codes and

multiplicity codes which substantially
reduced the barriers but then to finally

get you all of the way there we had to
bring out the big guns and make more

complicated constructions which finally
sort of dropped away these barriers and

we finally attained these goals and the
point of this talk is that actually for

many of these goals the the fancy
techniques are not necessary these these

original codes actually directly attain
them by this very simple argument that I

told to you before and they all lived
happily ever after

so maybe let me just recap with some Oh
some open questions right so one open

question that I've mentioned a lot is
how can we get the list size down to the

correct constant or can we so I'm
guessing this is the correct constant

maybe it's not and also if they're a
deterministic algorithm that will solve

this problem so I gave you a randomized
algorithm pick these coordinates at

random but now that we know the list
size is small the next natural question

is to ask for deterministic algorithm
that'll do that and finally okay this

isn't related to the part of the talk I
didn't get to so maybe oh good ok so

then I'll just end there so thanks very
much

and I'm happy to take more questions got
them all out during the talk yeah right

so the size of I is some constant that
depends on the the subspace the

dimension of the subspace and also how
much less Rho is from Earth sorry yeah

how much smaller Rho is then Delta so if
Rho is equal to Delta minus epsilon and

the cited dimension of the subspace is s
then if you choose a number of

coordinates which is roughly I want to
say s over epsilon that's enough to

together with high probability
if you run those those quantitative

things sort of through the argument that
I suggested you're going to get a list

size which is worse than the one I
reported the the this one comes from

these slightly fancier slightly fancier
arguments that are tailored for folded

reed-solomon codes yeah so random code
should yeah that's a good question I

don't know off the top of my head the
sorts of results that I have in my head

yeah I think I even know the correct
constant asymptotically for some things

which would say Delta over 2 which is
not useful because then you can

emphasize one yeah I'm not sure it might
be that for it might be that there are

some yeah I have it I haven't talked
about that question that's a really good

question I don't know

thanks everyone for coming and thanks
for all your questions during the talk