►
B
B
You
know
every
every
beat
right,
you're
running
something
happens
right
and
that's
that
yeah,
that's
like
every
commit,
you
know,
or
every
change
right
and
so
we're
gonna
get
down
to
these
granular
levels
where
we're
treating
a
project
like
a
thought
right
and
a
train
of
thought
like
the
commits
in
a
project,
that's
moving
the
system
context
or
the
system
state,
and
so
we
need
our
traceability.
So
we're
putting
this
thing
on
on
chain
on
chain.
They
came
up
with
a
pretty
good,
pretty
good,
that's
a
catchy
little
term
there.
B
I
like
that,
okay,
so
the
open
architecture.
What
were
we
talking
about
for
the
open
architecture?
So
I
I
always
I
did
some
thinking
afterwards
after
last
video-
and
I
was
thinking
well
what
what
is
this?
What
are
we
saying
here?
Well
we're
saying
that
there
should
be
this
architecture,
so
how
do
we
relate
basically
the
open
architecture
to
blockchain
right,
because
you
know
we.
We
know
that
there's
this
thing.
B
We
know
there's
this
need
for
the
standard
description
of
architecture
right,
so
that
we
can
have
standard
threat
models
and
and
and
and
tie
in
our
s-bombs
right.
We
know
this
right,
like
I
mean
so,
if
you
have
a
solution,
please
speak
up
so,
but
as
far
as
I
can
tell
that's
not
a
thing.
So
what
we
want
for
is
for
it
to
be
a
thing
right,
and
we
said
that
you
know
it
should
probably
be
like
an
rfc.
B
It
looks
like
the
odap
that
is
an
rfc,
and
that
is
you
know
the
way
that
we
want
to
store
our
our
data
right
and
what's
the
data
we're
going
to
store
within
there?
Well,
it's
going
to
be
you
know
the
open,
open
architecture.
You
know
the
data
for
the
open
architecture
right,
so
we're
going
to
look
at
odap
as
the
way
that
we're
going
to
connect
or
odap-
or
you
know
the
pure
dids
right.
B
All
of
this,
I
think
odap
is,
is
maybe
for
getting
data
on
and
off
chain
and
then
documents
the
fact
that
we're
storing
it
in
the
did
format,
right
and
and
all
of
that
type
of
stuff.
But
you
know
it's
sort
of
sort
of
overarching
encompassing
thing
for
all
of
that
right.
So
so
you
know,
we
know
we're
using
dids
and,
and
my
understanding
is
that
odap
will
help
us
proxy,
the
blockchain
formats
down
to
the
one
we
want,
which
is
the
did
based
format.
So
basically
we're
gonna.
B
You
know
input
data
in
there
right,
that's
what
we've
been
doing
so
well.
What
is
so?
What
are?
What
are
we
saying
here?
Really
so
there's
smart
contracts
right,
but
smart
contracts
operate
on
chain
right,
and
so
we
need
like
there's
these
oracles
and
the
oracles
are
the
parties
that
we
trust
to
put
information
on
chain
right
so
that
then
we
can
operate
and
do
do
smart
contracts
with
with
the
knowledge
that
that
that
we,
you
know,
except
from
oracle's-
that's
you
know
already
already
yeah
already
unchained.
B
So
so
what
we're
doing
here
is
you
know
we're
looking
at
these
on-ramps
and
off-ramps
of
this,
this
blockchain
as
this
that
as
the
infrastructure
and
the
highway
right
and
so
and
and-
and
you
know,
we've
said
that
alice
is
is-
is
both
the
entity,
the
the
commodity
and
the
infrastructure
rate,
because
she
is
this
this
this
way
of
getting
things
on
and
off
chain
right
in
that
she
inc
incorporates
odap.
Is
it.
A
A
B
B
Sort
of
like
are
are
mapping
to
almost
like
these
conceptual
understandings
right
where
we're
layering
and
there's
these
layers
of
feature
extraction
right
and-
and
so
the
very
most
extracted
features
like
that.
The
farthest
the
leaf
nodes
in
your
directed
acyclic
graphs
when
you're
doing
feature
extraction,
are
your
your
base
features,
and
then
your
conceptual
levels
are
everything
that
lead
up
to
that
and
as
in
including
on
the
other
side
of
the
feature
extraction.
B
So
then
you
know.
Finally,
you
may
have
you
know
whatever
your
strategic
principles
are
up
here
right
and
those
strategic
principles
are
going
to
be
specific
through
the
lens
at
which
you're
looking
at
the
problem
right.
So
this
is
your
essentially
your
your
your
phylogeny
right,
and
so,
if
you
had
a
single
common
like
if
you,
if
you
distilled
all
those
strategic
principles
into
good
bad
good
decision,
bad
decision
right
that
would
be
sort
of
you,
you
would
have
kind
of
this
yeah.
B
You
would
have
like
this
philosophy,
where
you're
classifying
based
on
the
strategic
principles
and
cl
plans
as
you
go
down
through
to
you
know,
I
believe,
and
so
then
we
can
basically
map
that.
So
we
can.
We
can
effectively
so
take
that
take
this
now
turn
it
here
now
introduce
another
one
over
here:
okay,
now
map
across
the
space
map
across
the
space
by
building
models,
we're
basically
just
doing
a
brute
force
approach.
Okay,
now
we're
going
to
build
models
and
these
models
essentially
like
high
we're
going
to
analyze
the
accuracy
of
the
these.
B
These.
What
are
effectively
like
multi-output
in
the
case
of
the
permutations
that
have
multiple
output,
features,
encoder
models
right
and
we're
then
going
to
identify
the
importance
that
the
the
predicting
feature
so
we're
going
to
have
the
feature
set
in
plane,
a
so
plane
a
and
plane
b
right.
So
feature
set
in
plane
a
understand
what
conceptual
levels
in
feature
set
plane
b
those
map
to
right.
B
So
we
understand
what
conceptual
levels
those
map
to
in
plane
a
you're
doing
this
for
both
planes
you're
doing
everything
for
all
planes
right
so
because
you're
doing
a
brute
force
approach
and
you
can
you're
doing
a
brute
force
approach
but
you're
using
the
prioritizer
you're
going
to
basically
issue
a
dispatch
for
every
brute
force
approach.
That's
a
valid
system
of
context.
B
Now
the
prioritizer
will
decide
which
approaches
to
pursue,
based
on
dynamic
analysis
and
reanalysis
of
what
approaches
are
you
know,
seeing
results
right
so
you're
doing
this
sort
of
like
you're
doing
like
you're,
getting
more
accurate
about
your
activities
when
you're
trying
to
understand
what
relates
to
what
right
and
then
because,
once
you
understand
how
your
your
template
state
your
kubernetes
right.
So
once
you
understand
how
your
template
relates
to
your
desired
in
state
right,
then
you
can
begin
to
tweak
your
level
now
you
understand.
What
are
your
levers
right?
Alice
knows.
B
B
Using
these
models
map
from
plane
a
to
plane,
b
right,
then
she
can
go
through
and
you
know:
she'll
execute
them
and
she'll
measure
their
metrics,
the
outputs
and
then
she'll
recalculate
and
re-prioritize
dynamically
to
see
if
it's
really
driving
those
those
strategic
principles
as
they
relate
within
this
other
domain
right,
because
we're
mapping
the
strategic,
we're
mapping
our
understanding
to
these
new
domains
right
to
say
what
is
our
our
understanding
of
the
in
state
right?
That's
the
strategic
principles.
B
What's
the
understanding
of
the
current
state
right,
that's
the
feature,
exchange
abstraction
in
plane,
a
and
then
what's
the
understanding
of
the
in
state
right,
so
the
in
state
effectively
we
have
our!
So
we
have
it's
almost
like
you're
doing
one
of
those
one
of
those
math
problems
right
where
you've
got
two
fractions
right
and
so
you've
got
your
fraction
up
here
or
you've
got
your
your
numerator,
your
numerator,
your
denominator
and
your
denominator
and
you've
got
equals
in
the
middle
right.
So
one
of
these
states
right
down
here.
B
So
this
is
known
principles
plane.
A
known
principle
is
plane
b,
known
principles,
plane,
plane
or
waves.
Sorry
known
principles,
plane
a
known
features,
plane
a
known
principles,
plane
b
right
so
start
principle,
state
in
principle,
state
and
then
start
feature
state.
We
know
what
that
is.
We
can
do
feature
extraction
right
now
in
state.
The
question
is
in
state
right:
what
is
the
in
state
or
what
is
the
series
of
system
contexts
that
take
us
to
the
end
state
right
now,
because
we
have
these
models.
B
We
could,
because
we
can
understand
when
a
system
context
is
valid
by
relating
it
by
by
building
this,
this
brute
force
approach
to
model
map
to
mapping
the
different
planes
we
can,
then
we
should
then
be
able
to
essentially
solve
for
this
number
down
here,
which
is
what
do
the
values
for
the
features
the
extracted
features
right.
Basically,
the
unencoded
system
context
look
like
for
the
in
state
right.
B
So
this
is,
and
so
in
that
way,
this
is
the
generic
sort
of
the
generic
way,
which
alice
moves
state
a
to
state
b
right.
So
she
she
understands,
you
know
she
first
discovers
right.
What
might
those
strategic
principles
be
right?
Okay,
so
we
want
to
have
more
security
right,
okay,
so
well,
let's
find
some,
let's
find
some
strategic
plans
that
output
a
metric
of
security
right-
okay,
great
all
right!
So
now
we
want
to
have
more
of
that
right.
So
now,
let's
go.
B
Let's
go
and
analyze
all
historical
system,
contexts
which
have
security
as
an
output
right.
An
executed
state
executed
state,
not
hypothesized
state
right.
So
this
is
our
training
data
set
right
now
we
do
you
know
whatever
our
split
on
our
training
data
set
is
right
and
then
we
go
through
and
we
look
at
related
system
context
right
so
trees
right.
So
we
want
to
look
at
start
state
to
end
state
right
and
then
we
go
through.
B
We
run
these
mapping
models
plane
a
to
plane,
b
right
and
now
we've
developed
our
data
set
our
generic
translation
model
that
allows
us
to
get
from
state
a
to
state
b
for
any
given
problem
space
right
because
we've
we've
analyzed,
we've
analyzed
the
previous
data,
which
is,
which
is
you
know,
ideally
on
chain,
because
you're
going
to
need
a
lot
of
data
for
to
do
this
for
every
problem.
Space
right
so,
okay,
great
all
right,
so
I'll,
be
right
back.