►
Description
In this final session of the Token Engineering Academy's Gitcoin Model Research Group, TE Academy Co-Founder Angela Kreitenweis hosts participants in presenting their research questions and work. This is the final presentation session of the #OpenScience approach to understand and expand the cadCAD model of the Gitcoin Grants ecosystem, where teams present their work on various aspects of improving detection and mitigation of attack vectors in Gitcoin Grants.
Learn more about the Token Engineering Academy here:
https://tokenengineeringcommunity.github.io/website/docs/academy-welcome/
Join @gitcoin, @block_science, @tokengineering & QV/QF academics and enthusiasts to discuss the collusion hunting cadCAD model of the Gitcoin Grants ecosystem.
More information about this research initiative:
https://www.notion.so/blockscience/Gitcoin-Modelling-Co-Lab-TL-DR-Public-4e115525dbc0430289bb78d60ad79a04
Read more about Block Science: https://block.science/
Learn more about Token Engineering: https://tokenengineeringcommunity.github.io/website/
More about the Token Engineering Commons: https://medium.com/token-engineering-commons/kicking-off-the-token-engineering-commons-be6a253cba81
cadCAD is an open-source Python package that assists in the processes of designing, testing and validating complex systems through simulation.
Discover more at https://cadcad.org/
Join the cadCAD Community Discord: https://discord.gg/hs4dAN9
Telegram channel: t.me/cadCAD_org
Twitter: https://twitter.com/cadcad_org
Get up to speed on our forum: https://community.cadcad.org/
B
C
D
D
I
really
needed
to
have
a
a
clear
view
on
the
raw
data
of
the
of
the
bitcoin
rounds
in
order
to
see
some,
maybe
some
strategic
behavior
happening.
I
first
I
I
set
out
my
research
question
in
three
groups:
let's
see
to
see
if
there
are
people
getting
early
in
the
party
so
basically
having
having
those
guys
kicking
off
the
party,
then
maybe
late
followers,
and
something
in
between
to
see
if
we
can
see
some
strategic
behavior,
I
put
it
in
a
plot.
I
will
show
that
here.
D
D
That's
just
too
much
for
my
computer
and
that's
this
is
not
a
small
computer,
I'm
working
on,
so
I
only
took
12
000
rows
of
it
and-
and
that
took
me
already
a
couple
of
minutes
to
process
what
I
did
was.
I
landed
some
some
functions
from
the
graph
community's
notebook
like
calculating
total
amounts
over
time,
like
you
know,
gathering
and
momentum
for
grants
or
contributors.
D
D
D
It's
a
real,
simple
node
of
thumb,
but
but
the
nice
thing
is
you:
can
you
can
basically
animate
what's
happening
over
time
here?
So
I'm
going
back
now
see
lots
of
things
happening,
starting
here
of
course,
and
then
see
big
notes
or
big
big
contributions
suddenly
popping
up
and
then
going
to
more
degrees.
So
this
one
is
a
thing
you
have
to
look
into
this
one
or
these,
because
these
are
big
contributions,
but
also
high
level
of
degree
and
smaller
ratios,
so
they
might
be
suspect
susceptible
to
some
sort
of
strategic
behavior.
D
D
They
are
spreading
around
their
contributions
and
they
have
also
a
small
ratio,
of
course,
so
they
are
basically
yeah
splitting
their
contributions
up.
It
also
has
some
sort
of
a
spiral
network
effects,
seeing
this
is
a
nice
graph
of
you
know
which
one
is
contributing
to
what
so.
This
is
all
the
relations
at
the
12.
This
is
in
the
middle.
This
is
on
the
12
000
time
step.
D
A
B
So
I'll
represent
this
this
thing
essentially,
and
it's
it's
presenting
the
methodology
behind
the
collusion
detection
that
we
wanted
to
do
with
a
group
and
to
just
present,
let's
say
to
begin
with
the
problem
of
collusion
detection,
which
is
mainly
that
we
don't
have
labels,
which
means
that
we
need
to
somehow
figure
out
a
way
to
represent
the
the
nodes
numerically
and
also
in
the
end,
to
to
detect
the
attack
vectors.
The
collusion.
B
So
these
are,
let's
say
three
questions
that
that
we
had
to
answer
in
order
to
come
up
with
the
solution
of
of
node
to
vac.
So
the
first
one
is
how
to
build
a
feature
set.
That's
basically
using
an
unsupervised
learning
technique
and
then
the
second
one
is
how
to
present
more
numerically
automatically.
E
E
F
B
So
these
are
the
three
questions
that
I
that
I
presented
and
the
approach
that
that
we
took
was
basically
no
to
vac,
which
is
for
the
people
that
are
more
familiar.
Let's
say
with
where
to
vac
it's
pretty
much
worth
to
vac,
but
for
for
networks,
let's
say
so.
We
can
do
math
such
as
woman,
minus
man
plus
king
equals
queen.
So
that's
basically
like
how
can
we
kind
of
like
contextualize
the
network
topology
like
how
different
nodes
interact
with
each
other
with
with
the
edges
right?
So
that's.
B
The
biggest
thing
is
how
how
can
we
numerically
represent
this?
So
we
can
so.
We
can
use
some
mathematical
operations
to
compare
different
nodes
and
the
in
the
end.
The
idea
is
that
we
inject
an
attack
vector-
that's
basically
taken
from
from
block
science,
borrow
from
block
science
research
and
then
calculating
a
similarity
between
the
effect
vector
and
the
the
empirical
nodes
from
the
bitcoin
grants
right.
B
Obviously
not
everything
is
automated,
and
this
is
the
ml
workflow,
the
metallo,
the
methodology,
which
is
something
that
sean
will
present
more.
But
the
idea
is
that
we
create
the
embeddings
on
the
graph
data
and
then
we
then
we
calculate
a
similar,
a
similarity
measure
of
the
on
of
the
embedding
between
the
attack,
vectors,
the
the
attack
vector
and
all
the
all
the
empirical
nodes,
and
then
we
can
investigate
the
malicious
activity
so
and
then
the
the
future
extensions.
But
that's
that's
less
relevant.
A
Yes,
okay,
so
building
off
of
the
work
of
mark
and
yan,
so
we
we
were
seeing
the
ratio,
the
contribution
ratio
that
mark
was
highlighting
through
the
gap
minder
plot
and
as
he
mentioned,
this
came
up
in
the
math
working
group
that
there
is
a
case
there's
some
evidence
for
an
optimal
strategy
which
is
essentially
spreading
out
your
budget
to
as
many
colluders
as
possible
and
having
equal
contributions
to
the
grant,
that's
being
colluded
upon.
So
it
indicates
this
idea
that
polluters
are
more
likely
to
use
small
donation
amounts
than
large
ones.
A
A
So
what
we
can
do
is
we
can
see
the
distribution
of
civil
score
according
to
the
amount
that
is
being
donated.
So
then
we
can
start
to
zoom
in
so
I
I
don't
know
this.
I
didn't
double
check,
but
I
think
a
high
civil
score
is
someone
that
we
want
to
investigate.
So
let's
just
go
with
that
assumption
for
this
presentation,
so
we
have
the
cool.
Colors
are
very
low,
sible
score
and
the
very
hot
colors
are
high
cible
score,
so
we're
these
are
the
suspicious
ones.
A
B
A
Anyways
this
allows
you
to
sort
of
zoom
in
on
different
contribution
amounts
and
then
what
we
get
from
that
is
we
from
this.
This
dashboard
object.
We
get
these,
it
has
a
function
called
get
suspect,
and
that
gives
us
all
the
contributions
that
are
in
the
range
that
we're
currently
analyzing
and
then
we're
going
to
use
yawn's
note
embedding.
So
we
take
this
subset
so
here
we
only
have
463
contributions
that
we're
looking
at
and.
A
So
this
is
the
two-dimensional
spatial
embedding
of
all
of
the
nodes
that
are
suspect,
and
here
we
actually
inject
an
attack
vector
also-
and
we
check
the
spatial
similarity
between
all
of
these
suspect
grants
and
the
attack
vector.
So
so
here
are
the
contributions
made
to
the
attack
vector,
and
so
we
can
see
of
these
suspicious
grants.
There
is
one
that
is
most
similar
to
the
attack
factor
and
it's
called
learning
data
science
on
the
ethereum
blockchain
with
omni
analytics.
So
we
get
this
sort
of
ranking
distribution
of
similarity
to
the
attack
vector.
E
Awesome
I
mean,
I
know
we're
gonna
have
to
jump
to
the
next
thing.
Quick,
so
we're
not
gonna
have
a
ton
of
time
for
q
a,
but
I
think
it
might
be
really
cool
to
coordinate
offline,
about
making
sure
that
all
of
the
repos
that
are
that
people
have
worked
on
are
in
a
place
that
others
can
find,
because,
obviously
this
is
like
the
start
of
a
flywheel
where
people
can
like
build
off
of
each
other,
which
you
guys
have
already
demonstrated
and
how
the
work
streams
were
interwoven.
C
G
G
One
is
that
the
the
commons
community
ensures
that
those
affected
by
the
rules
participate
in
the
rule
making
and
then
the
second
one
that
I'm
particularly
interested
in
is
that
we
should
try
to
develop
a
system-
that's
carried
out
by
the
community
members
for
monitoring
the
behavior,
because
that
allows
us
to
participate
in
the
rulemaking,
and
this
is
really
what
I
focused
on
was:
how
can
we?
How
can
we
encourage
the
community
to
be
involved
in
in
the
data,
because
this
data
is
really
quite
complicated,
so
I
built
a
tool.
G
G
G
I'm
a
little
concerned
about
that,
because
if
the
only
way
to
get
the
data
is
to
pay
for
it's,
not
very
community
oriented,
but
I
built
this
tool
called
shifra
and
what
schieffer
lets
me
do
it's
it's
a
collection
of
tools
that
lets
me
do
all
kinds
of
different
things
with
this
ethereum
archive
node
in
particular.
It
lets
me
scrape.
The
first
thing
that
I
can
do
is
scrape
the
data
and
scraping
the
data.
G
Runs
this
runs
continually
and
extracts
from
the
chain.
It
extracts
a
list
of
every
appearance
of
every
address
in
every
block
and
builds
an
index
of
that
data
locally
on
my
machine
and
what
this
does
it
gives
me
the
ability
to
get
directly
at
the
data
that
I
want
for
any
particular
address,
and
I
ran
this
scraper
against
all
eighteen
hundred
bitcoin
grant
addresses
and
I
used
shifa
to
extract
all
of
that
data
into
separate
data
files.
G
And
then
this
is
the
transactional
data
where
I've
limited
the
out.
The
output
of
the
data
to
only
the
donation
sent
data
for
for
the
bitcoin
grant,
so
we
can
use
different
shifa
commands
to
extract
exactly
what
we
want.
In
particular,
I
can
type
shifra
names,
I'll
use
rocky
as
an
example,
so
I
can
say
sh,
that's
the
address
for
the
rocky
grant
and
then
I
can
say
she
for
list,
and
that
is
scraping
this
index
that
we
built
and
it's
going
to
come
up
with.
G
If
I
search
for
rot
key
here,
it's
going
to
come
up
with
this
list
of
appearance.
We
call
these
appearances,
so
there
was
a
1006
places
on
the
blockchain
where
that
address
appeared,
and
these
are
those
places
and
then
we
can
look
at
all
of
get
rocky's
donations
here
and
we
can
do
that
using
another
command
called
export
here,
and
that
is
every
one
of
those
1000
and
transactions,
and
then
we
can
do
things
like
export.
G
G
G
G
We're
building
some
simple
charts-
and
I
just
want
to
show
one
other
thing
here,
so
this
is
now
looking
deep
into
each
transaction
for
rocky
and
we
can
see
exactly
what
happened
on
each
of
these
transactions,
including
token
accounting
for
each
transaction,
and
one
of
the
things
that
I
think
is
interesting
is
if
I,
as
a
donor,
am
going
to
give
money
to
rocky
and
I'm
happy
to
do
that.
I
kind
of
want
to
see
what
he's
using
the
money
for
I'm
not
sure
how
people
feel
about
that.
G
G
They
go
off
the
next
day
after
having
collected,
500
or
something
and
they're
buying
gambling
web
they're
going
to
gambling
sites,
and
we
can
see
that
in
the
data
and
then
the
other
thing
that
I
learned
that
I
wasn't
aware
of
is
that
the
layer
2
data
is
actually
very
hidden
from
what
you
might
call
an
open
data
environment.
And
this
is
a
consideration.
I
think
we
need
to
take
into
account
too,
because
it
kind
of
destroys
the
ability
for
the
community
to
carry
out
its
own
monitoring.
E
I'd
just
like
to
chime
in
that
I'm
I'm
really
thrilled
to
see
the
discussion
as
an
interplay
between
the
the
more
technical
and
what
more
social
components.
Tj's
observation
and
sort
of
attachment
to
this
to
the
awesome
principles
is
something
that
I
think
we
need
more
of
because
we're
facing
an
increasing
necessity
for
a
norm.
Setting
like
to
the
point
about
privacy
versus
like
community
monitoring.
E
A
lot
of
that
stuff
can
only
be
set
through
the
norm,
formation
and
sort
of
the
community
kind
of
establishing
some
rough
consensus
about
where
we
belong
on
these
spectra,
and
you
can't
really
establish
that
rough
consensus.
If
you
don't
first
make
visible
the
fact
that
that
this
is
a
question
so
like
it's,
it's
really
easy
to
run
over
a
topic
if
it's
not
ever
expressed-
and
I
think
I
really
appreciate
the
efforts
to
make
this
explicit
so
the
community
can
participate
in
that
norm.
Formation
process.
C
C
C
Now,
let's
continue
with
the
next
presentation,
so
we
are
now
starting
with
the
math
working
group
and
in
we
had
overall
three
different
topics:
octopus,
andrew
matt
and
jonathan
were
working
on,
and
now
you
please
help
me.
I
think
the
first
one
is
linear,
algebra
reformulation
of
quadratic
funding
or
what
what
should
be
first.
Yes,.
I
C
I
C
F
I
I
All
right,
I'm
gonna,
start
talking
because
we're
a
lot
of
time
andrew.
Hopefully
you
jump
back
in
okay,
so
for
our
for
our
work,
we
wanted
to
break
down
the
problem
to
be
really
simple,
so
we
sort
of
took
the
idea
of
looking
at
the
bipartite
graph
view
of
the
the
bitcoin
grants
and
then
see
if
we
could
apply
some
linear
algebra
to
it.
I
So
this
is
sort
of
the
traditional
way
at
looking
at
users
and
grants,
and
so
you
know
we
have
a
user
and
then
there's
the
edge
between
the
nodes
is
the
the
weight
of
the
donation,
so
basically
the
another
way
to
represent
this
is
with
the
buy
adjacency
matrix.
So
if
we
imagine
that
every
node
has
like
an
edge
to
every
grant
node,
then
we
can
just
say
you
know,
people
that
donate
that
don't
donate
anything
is
weighted
as
zero.
I
This
is
nice
because
it
helps
the
problem
be
continuous
and
we
can
sort
of
it's
a
little
bit
easier
to
solve
statically
like
mathematically,
so
this
is
sort
of
the
frame
of
view,
hopefully
they're
not
butchering
andrew's
squad.
Hopefully
he
comes
back
so
yeah,
so
ordinarily
by
adjacency
matrix,
it
wouldn't
be
square
root,
but
the
funding
algorithms
will
eventually
take
the
square
root
of
the
entries.
So
it's
more
efficient
to
just
do
this
once
the
beginning.
Basically
we
looked
at
the
instead
of
the
perspective
of
contribution.
I
So
how
does
this
help
us?
I?
My
presentation
goes
into
this.
I
know
that
jonathan
does
too
there's
a
lot
of
useful
tools
out
there
and
algorithms
for
helping
some
of
these
teams
so
like
optimization
on
manifolds,
is
going
to
come
up
later
in
the
presentation.
So
this
is
a
really
useful
way
for
formulating
the
problem
and
applying
maybe
some
algorithms
that
we
haven't
seen
before
so
yeah,
so
rows
and
columns
make
sure
these
are
vectors.
So,
basically,
we
have
different
vectors
to
describe
sort
of
like
contributions
to
a
grant.
I
Sorry
about
the
background
noise
construction
yeah.
So
we
can
sort
of
look
at
things
like
angle,
distance,
norm,
change
of
basis
if
you're
familiar
with
vectors,
trying
to
zoom
pretty
quick
here
so
matrix
based
methods
are
often
faster
than
other
approaches.
This
is
like
sort
of
our
impetus
for
like
going
going
this
route
and
looking
at
these
algorithms,
so
yeah,
like
you
know,
we
can
speed
up
things
via
python.
Numpy
and
andrew
show
some
examples
of
this.
I
So
basically
you
know
if
there's
a
four
loop
over
an
array
which
is
what
we
see
in
the
clr
algorithm
as
it
currently
stands,
there's
a
good
chance
that
we
can
replace
it
with
some
built-in
numpy
functions.
Yes,
this
is
just
more
like
motivation
and
then
you
know,
matrix-based
methods
are
faster.
This
is
some
code
from
a
project
that
andrew
did
where
he
felt
like
a
355
times,
speed
up
just
using
like
a
numpy
library
over
some
other
stuff,
so
yeah
teaching,
you
know
great
examples
of
this-
is
pretty
straightforward.
I
I
So,
yes,
it's
a
starting
point:
proof
of
concept.
We
haven't
like
again
tried
to
like
optimize
the
code
itself
to
run
faster
and
like
that,
we're
just
trying
to
apply
a
new
algorithm
just
to
get
a
starting
point,
so
I
think
that's
it
for
like
the
introduction,
slides
and
hopefully
I'm
not
blowing
this.
I
So
then,
let's
actually
get
into
the
work
that
we
did
so
optimization
for
quadratic
funding
algorithms.
So
we
looked
at
constrained
maximization
problems,
that's
what
we're
trying
to
do
right,
we're
trying
to
say
how
can
we
look
at
the
way
that
polluters
want
to
optimize
the
match
output
of
like
given
a
certain
strategy?
So
how
can
they?
You
know
jack
up
the
match
for
a
specific
grant
or
a
setup
grant,
and
the
constraint
is
obviously
there's
some
concern
on
the
money
and
the
way
they
share
it
between
each
other.
I
So
I
don't
know
what
the
plans
are
here
to
fill
in.
But
the
way
I
think
of
constraint,
maximization
for
straight
optimization,
is
there's
a
cost
or
objective
function
which
in
this
case,
would
be
our
clr
like
match
and
then
there's
an
objective
or
a
constraint
function
which,
basically
for
us
is,
is
the
budget,
so
in
general
we're
thinking
of
global
maximum,
so
there
may
be
other
local,
maximums
and
minimums
that
occur.
I
So
this
can
be
a
hard
part
of
the
problem
is
knowing
whether
you're
at
a
local
master
of
global
max-
and
this
comes
up
very
very
soon
in
our
research,
so
there's
a
basic
optimization
example
of
a
hundred
feet
event.
Honestly,
I'm
gonna
skip
through
this,
because
I
think
that
we're
getting
short
on
time.
I
I
want
to
get
to
the
stuff
that
we
actually
did
so
now
to
get
to,
like
our
like
civil
optimization,
the
formulation
that
we
looked
at
so
a
user
has
two
accounts
and
one
he's
available
to
donate,
to
grant
what's
the
maximum
matching
funds
that
he
can
achieve
for
a
single
grant,
given
a
single
given
grant
a
so
this
is
sort
of
the
the
basic
basic
formulation
of
the
problem,
and
then
I
guess
here's
like
another
example
yeah.
Now
we
can.
H
The
the
key
thing,
the
key
reason
we
started
with
this
really
basic
problem-
is
that
this
problem
that
you
may
have
seen
in
calculus,
one
actually
has
many
of
the
same
features
as
the
problem
of
trying
to
determine
what
optimal
collusion
or
optimal
symbols
would
look
like.
So
I
want
to
highlight
some
of
those
properties
next
slide.
H
Please
so,
and
next
slide
again
so
notice
that
we
have
l,
which
is
linked
to
the
fence
w,
which
is
the
width
of
the
fence,
and
the
area
is
l
times
w
and
the
constraints
are
2l
plus
2w
equals
100..
You'll
probably
understand
that
fairly
well,
go
to
the
next
slide,
hello,
everyone
and
welcome
back
and
up.
F
H
A
H
H
And
so
that
means
that
this
optimal
solution
occurs
when
the
two
variables
are
equal
slide.
Please,
so
we're
going
to
go
back
to
this
and
look
at
get
coin
as
a
constrained,
optimization
problem
from
the
perspective
of
users
who
might
be
behaving
strategically
to
try
to
maximize
their
gains
next
slide,
please.
H
Here's
this
nice
picture,
where
you
can
interpret
the
matching
amounts
in
a
geometric
context
as
areas
of
rectangles,
so
go
ahead
to
the
next
slide.
Please-
and
my
comment
here,
is
that
you
can
look
at
the
accounts
as
the
farmers
and
you
can
look
at
the
contributions
as
the
green,
the
area
of
the
green
squares,
then
the
user
interactions
are
sort
of
like
the
sides
of
the
fences
and
these
rectangular
areas
in
yellow
those
are
the
matching
funds
that
the
users
get
from
the
system
system
next
slide.
Please!
H
So,
then,
if
we
think
of
this
through
our
matrix
setup
slide
and
you
actually
plug
it
into
the
formula,
you
get
this
looking
interesting,
looking
formula
that
you're
actually
trying
to
optimize
and
just
believe
me
on
the
details,
if
you
work
through
it,
you
get
the
next
slide
please
and
we're
going
to
look
for
optimal
collusion
strategy.
So
what
maximizes
that
next
next
slide?
H
You
also
have
column
permutations,
which
would
just
take
the
amounts
but
switch
them
around
different
grants.
The
grants
are
ultimately
benefiting
the
same
malicious
users.
It
would
still
be
the
same
benefit
so
next
slide.
Please
so
there's
a
theorem
next
slide,
please.
It
says
when
you're
in
this
situation,
you're
going
to
be
looking
for
the
optimal
strategies
as
things
that
have
this
kind
of
symmetry,
where,
when
you
swap
the
rows
or
swap
the
column,
the
strategy
doesn't
slide.
Please
so
for
right
away.
H
You
can
look
at
some
strategies
and
you
can
say
well
if
I
gave
one
third
of
my
budget
to
each
of
the
three
accounts
and
then
had
them
all,
give
it
to
grant
a
one
that
that
would
represent
a
a
really
good
strategy
or
a
really
bad
strategy,
and
the
question
is
which
one?
So,
by
applying
this
theorem
and
using
the
symmetry,
you
don't
have
to
compute
to
look
for
optimal
strategies.
You
can
recognize
and
recognize
many
of
them
by
noticing
that
they
obey
this
extra
next
slide.
H
Please
so
we're
going
to
focus
on
two
questions:
what
is
the
maximum
amount
of
matching
fun?
The
collection
of
accounts
and
grants
could
earn
through
strategic,
and
the
second
is:
how
could
we
recognize
these
trainings
that
are
optimized
in
some
way
and
my
colleague
will
describe
how
we
use
this
formulation
to
actually
investigate
these
questions.
I
F
I
So,
starting
from
right
where
andrew
left
off,
we
came
up
with
an
optimal
collusion
hypothesis
and
basically,
we
came
up
with
a
closed
form
solution
to
figure
out
the
maximum
of
what
we
think
should
be
the
maximum
amount
of
match
that
malicious
users
could
get
out
of
a
polluted
system.
So
colluders
contribute
equal
amounts
to
target
grants
and
then
what's
the
most
massive
they
could
generate,
and
we
found
some
really
really
interesting
results.
I
mean
just
having
a
closed
form
solution
is
super
simple
b.
I
Is
the
budget
x
is
the
number
of
users
and
we
so
we
can
compute
quickly.
This
is
the
maximum
match
obtained
and
we're
actually
going
to
show
empirically
that
that
holds
up
the
the
really
cool
thing.
Was
it
doesn't
matter
the
number
of
grants
that
these
guys
spread
their
their
money
out
across
they
can
achieve
the
same
overall
combined
match
when
we
add
these
sort
of
the
output
of
f
up
across
so
yeah.
I
If
we
run
it
through
this,
if
we
run
it
through
this
close
resolution,
we
see
that
that
maximum
match
they
could
achieve
is
three-fourths
so
and
this
so
obviously
we're
using
our
own
form
solution.
But
we
validated
this
against
like
the
clr
formula
and
we'll
show
that
in
in
the
coming
slides,
but
so
this
is
an
example
of
the
type
of
collusion
that
we're
looking
at
and
it
turns
out.
This
is
super
interesting.
I
There's.
These
three
users
want
to
maximize
the
match
across
z
and
y,
the
total
combined
match
when
they
split
their
funding
up
accordingly,
so
the
strategy,
the
optimal
strategy,
still
holds-
and
we
see
some
really
interesting
results
but
like
the
the
overall
achieve
match,
is
still
the
same,
so
the
shape
of
the
match
function
so
basically
did
a
service
plot
of
sd
across
user
contributions
for
grant.
So
now
we're
looking
at
there's
two
users
and
they
want
to
contribute
they
want
to
maximize
the
total
match
across
two
grand.
I
What
does
that
look
like?
So
we
found
this
really
really
interesting
result
where
this
thing
ends
up
being
a
manifold,
and
I'm
going
to
talk
about
that
in
the
next
slide
a
little
bit,
but
we
get
this
cool
surface
plot,
where
it
looks
like
there's
actually
a
bunch
of
like
optimal
points
along
the
top
of
this,
the
top
of
this
curve,
and
it's
a
little
bit
weird.
If
you
look
at
the
x-axis,
it
looks
like
so
it
says
user
one
contribution
to
grant
a
used
to
contribution
to
grant
a.
I
So
it
looks
in
like
at
the
zero
zero
point,
like
that's
a
maximum
match,
and
it
turns
out
that
it
is.
This
is
the
part
to
like
wrap
your
mind
a
little
bit.
It
turns
out
that
it
is
because,
basically,
the
the
contribution
to
grant
b
is
one
minus
the
contribution
of
grant
a.
So
this
goes
back.
This
goes
back
to
the
column
permutation
that
andrew
had
talked
about
in
his
last
live.
I
I
This
becomes
a
sphere
and
that's
super
cool,
because
there's
a
python
library
that
helps
us
solve
that
optimization
problem
for
the
maximum
point
along
that
sphere,
and
we
showed
exactly
what
what
our
sort
of
hypothesis
was
was
that
the
maximum
achievable
match
is
always
lines
up
with
this.
The
output
of
of
that
closed
form
solution,
but
this
library,
if
you
notice
here
on
the
right
side,
it
spits
out
a
different.
So
this
is,
you
know,
contribution
of
user
one
to
a
of
two
to
a
of
one,
to
b
of
two
to
b.
I
If
you
go
along,
if
you
go
along
that
vector
the
row
vector
of
the
output-
and
you
see
that
you
get
two
different
solutions
every
time,
but
the
maximum
match
achieved
is
the
same
and
it's
some
of
the
total
contributions.
So
we
validated
okay.
This
is
a
line
segment
and
we
have
this
analogy:
it's
sort
of
like
the
lines
on
the
basketball
moving
across
this
manifold.
I
It's
actually
a
quarter
of
a
basketball,
because
negative
contributions
aren't
possible,
but
this
sort
of
validated
our
hypothesis,
that
is,
the
maximal
like
the
optimal
or
the
globally
optimal
match
that
they
could
output,
and
then
I
threw
in
here
some
slide
like
this-
is
sort
of
a
2d
look
to
gain
intuition.
So
you
can
think
about
this
as
the
line
segment
traversing
like
as
you
take
money
from
grant
a
and
contribute
to
grant
b,
keeping
that
same
symmetric
strategy,
the
optimal
match
is,
is
flat
and
then
so
the.
I
If
you
look
at
the
other
slice
we
sort
of
wanted
to
look
at.
How
does
the
sub
optimal
strategies?
How
does
it
make
the
match
drop
off?
So
in
the
last
plot,
because
I'm
moving
quick,
we
actually
show
that
people
who
want
to
hide
that
they're
saluting
say.
We
know
that
this
is
the
optimal
subgraph
we
if
they
move
away
from
this
strategy
relatively
far
like
splitting
the
money
like
half
and
half
so
you
contribute.
You
know
25
percent,
like
25
cents,
25
cents
to
a
grant.
I
You
would
still
get
like
80
of
the
match
by
moving
down
to
like
you
know,
it
would
be,
I
guess,
9
cents
and
41
cents
like
in
this
example.
So
you
can
move
pretty
far
like
you
can
hide
your
collusion
reasonably
well
without
affecting
the
overall
match
in
terms
of
like
a
percentage
too
much.
So
that
was
interesting
and
I
think
that
segways
to
jonathan
he's
going
to
talk
about
you
know
the
next
step
of
that.
F
J
E
J
Cool,
so
this
is
just
looking
at
some
experimentation
with
the
optimality
gap
using
octopus's
code,
and
so
here's
just
you
know
a
sort
of
packaged
up
use
of
the
of
the
code
looking
at
optimality
gaps
so
on
this
little
unlabeled
plot.
Here
these
are
gaps.
There's
your
sort
of
three
three
and
a
bit
score
here
for
a
bunch
of
grants,
in
this
case
we're
using
five
grams.
J
So
to
look
at
how
we
can
just
two
ways
that
the
the
optimality
gap
metric
can
be
gained.
The
metric
that
we've
that
octopus
devised,
we
need
to
talk
about
the
yeah
selection
of
the
subgraph,
which
is
the
part
the
part
of
the
graph
that
is
used
to
calculate
the
optimality
gap
around
a
certain
grant,
and
so
I
drew
a
couple
of
graphs.
J
So
here's
a
here's,
a
very
simple
looking
example
graph
and
we're
going
to
identify
around
this
guy
here,
grant
a
the
way
that
the
sub
graph
is
identified
is
by
just
taking
three
steps
back.
So
I
just
highlighted
sort
of
walking
steps
back
along
the
edges
and
yeah.
Here
you
can
see
so
one
two
three
can
get
us
to
this.
Node
here-
and
that
gives
us
our
entire
sub
graph
by
taking
the
three
steps.
J
Similarly,
but
but
I
would
suspect,
to
a
lesser
degree,
a
non-colluder,
so
just
some
random,
honest
contributor,
making
a
donation
to
the
target
of
the
colluding
users
also
opens
up
the
grant
in
a
similar
kind
of
way,
so
using
octopuses
code
and
some
other
details
which
I
won't
get
into.
Because
I
didn't
have
time.
J
So
we
have
a
clean
collusion
scenario
where
it's
only
the
colluders
granting
to
only
the
target
grant
and
then
the
two
other
situations,
the
scenarios
where
the
optimality
gap
can
be
gamed,
and
so
I
just
printed
out
the
results
here
forget
the
rest
of
numbers.
It's
this
last
column
that
we
really
want
to
look
at
this
last
column.
Here
is
grant
e
and
you
can
see
the
optimality
score
goes
from
0.1
to
0.9.
J
J
This
is
done
in
it's
supposedly
done
in
percentage
of
the
budget,
but
adding
a
really
tiny
portion
of
the
budget
as
a
sort
of
misleading
contribution
can
really
change
the
score.
Yeah.
Some
pretty
pictures
which
you
can
really
quickly
interpret.
I
guess
optimality
scores
of
the
clean
optimality
of
a
colluder
making
a
misleading
grant,
and
this
is
the
other
situation.
E
This
is,
this
is
great
work,
sorry
that
we're
running
the
chart
on
time.
I
wish
we
we
had.
We
had
more,
I
I
don't
want
to
eat
time
up
either,
but
I
just
want
to
like
say
thank
you,
because
I
think
this
is
really
important
and
that
we
should
figure
out
the
best
way
to
continue
and
honestly,
given
what
I've
seen.
E
F
F
K
All
right,
so
I
I
took
kind
of
what
like
tj,
tj's
tools
are
made
of
and,
like
you
know,
reverse
the
way
of
thinking
right.
So
it's
like
you
know,
analyzing
the
chain
right
so
by
checking
out
where
the
funds
are
coming
from,
we
can
determine
like
a
depth
of
how
far
they've
traveled,
so
in
every
collusion,
usually
like
what's
gonna
happen
is
like
you're
gonna
have
one
wallet,
that's
giving
like
a
few
people
funds
and
then
those
people
are
gonna
collude
right.
K
So
why
don't
we
actually
take
a
look
and
try
to
see
if
we
can
actually
find
that
wallet
and
see
if
there's
a
depth
right.
So
in
this
case,
like
binance,
would
be
saying
two
people,
some
ethereum
and
since
the
finance
actually
uses
like
the
same
ethereum
address
for
when
you're
withdrawing
and
receiving
consistently,
then
you
can
have
like
a
depth
of
one.
K
K
So
what's
the
depth
threshold,
you
know
one
two,
three
one,
two
n!
It's
up
to
you
right
cool,
so
I
mean
we
can
just
reverse
the
ledger
kind
of
and
see
like
where
the
transaction
that
fulfilling
the
sent
amount
to
the
gitlin
grants
is
coming
from
and
and
then
actually
use
use
that
to
determine
who
else
that's
going
to
and
then
kind
of,
determine
whether
we
want
to
accept
that
or
not.
C
So
here's
another
proposal
for
another
approach,
thanks
niko,
for
sharing
briefly
yeah,
so
I
guess
we
should
follow
up
on
how
to
well
make
make
the
results
more
accessible,
we'll
definitely
take
care
to
to
capture
the
work
in
in
write-ups
and
yeah
we're
happy
to
discuss
any
follow-ups
rocky
joe.
I
think
this
is
really
has
been
a
great
kickoff
for
community
co-research
and
education
for
yeah.
The
next
phase
of
bitcoin
grants
basically.
F
Yeah,
absolutely
this
is
really
good.
Thank
you
to
everybody
yeah.
Thank
you!
So
much
I
mean
I
just
quadratic
funding
is
just
so
important
to
these
this
ecosystem
and
to
me,
and
the
fact
that
it's
got
this
like
achilles
heel
of
sybil
and
collusion
has
been
really
keeping
me
up
at
night
and
and
like
literally
staring
at
2
a.m
at
the
ceiling.
F
Thinking
like
how
are
we
gonna
detect
this
adversarial
behavior
and
just
I'm
just
blown
away
by
the
quality
of
these
presentations,
and
I
and
really
just
touched
that
people
care
enough
about
this
to
work
on
it.
So
I
I
mean
I
think
I
need
to
hit
work
with
z
and
with
this
group
in
order
to
figure
out
how
we
put
some
of
this,
this
work
into
practice
and
how
we
support
this
work
and
and
so
looking
forward
to
having
those
discussions
in
the
future,
but
in
the
meantime,
tldr
I'm
blown
away.
F
E
E
Okay,
so
I
think
practicals,
then
a
couple
things
I'd
really
like
to
see
us
do
pull
together
some
sort
of
follow-up
write-up
about
this
like
little
cohort,
which
kind
of
came
together
impromptu.
In
a
way
I
mean
it
was
organized,
but
it
was
just
so
much
bigger
and
more
impressive
than
I
think
anybody
who
was
on
the
organizing
side
hoped
and
that
really
came
from
all
the
participants
so
yeah.
I
think
we're
going
to
want
to
try
to
do
some
sort
of
write-up
with
links
to
the
stuff
that
you
guys
produce.
E
So
your
slides
your
code,
your
github
repos,
let's,
like
you,
know
at
least
try
to
organize
it
so
that
we
have
links
to
all
of
them.
So
we
can,
you
know,
write
something
nice
about
this
work
but
then
also
going
forward.
I
mean,
obviously
this
is
practical.
Aren't
this
is
like
applied
research
right.
So
the
question
is
like:
how
do
we
continue
moving
forward
to
apply
it
and
have
more
positive
impact
on
this
ecosystem
that
we
all
care
about?
So
I
definitely
think
we
should
stay.