def prove(Eq):
n = Symbol.n(domain=Interval(2, oo, integer=True))
S = Symbol.S(dtype=dtype.integer * n)
x = Symbol.x(**S.element_symbol().dtype.dict)
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
w = Symbol.w(integer=True,
shape=(n, n, n, n),
definition=LAMBDA[j:n, i:n](Swap(n, i, j)))
k = Symbol.k(integer=True)
given = ForAll[x:S](Contains(LAMBDA[k:n](x[(w[i, j] @ LAMBDA[k:n](k))[k]]),
S))
Eq.P_definition, Eq.w_definition, Eq.swap, Eq.axiom = apply(given)
Eq << algebre.matrix.elementary.swap.identity.apply(x, w)
Eq << Eq.swap.subs(Eq[-1])
Eq << swapn.permutation.apply(Eq[-1])
def apply(n, d):
Q = Symbol.Q(shape=(n, d), real=True)
K = Symbol.K(shape=(n, d), real=True)
V = Symbol.V(shape=(n, d), real=True)
S = Symbol.S(shape=(n, d), definition=softmax(Q @ K.T / sympy.sqrt(d)) @ V)
return Equality(S[0], softmax(Q[0] @ K.T / sympy.sqrt(d)) @ V)
def prove(Eq):
S = Symbol.S(dtype=dtype.integer)
e = Symbol.e(integer=True)
Eq << apply(NotContains(e, S))
Eq << sets.notcontains.imply.equality.emptyset.apply(Eq[0])
Eq << sets.equality.imply.equality.given.emptyset.complement.apply(Eq[-1])
def prove(Eq):
n = Symbol.n(domain=Interval(2, oo, integer=True))
S = Symbol.S(dtype=dtype.integer * n)
x = Symbol.x(**S.element_symbol().dtype.dict)
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
given = [
ForAll[j:1:n - 1, x:S](Contains(
LAMBDA[i:n](Piecewise((x[0], Equality(i, j)),
(x[j], Equality(i, 0)), (x[i], True))), S)),
ForAll[x:S](Equality(abs(x.set_comprehension()), n))
]
Eq << apply(given)
Eq << discrete.combinatorics.permutation.adjacent.swap2.general.apply(
Eq[0])
Eq.permutation = discrete.combinatorics.permutation.adjacent.swapn.permutation.apply(
Eq[-1])
Eq << Eq.permutation.limits[0][1].this.definition
Eq << discrete.combinatorics.permutation.factorial.definition.apply(n)
Eq << Eq[-1].this.lhs.arg.limits_subs(Eq[-1].lhs.arg.variable,
Eq[-2].rhs.variable)
Eq <<= Eq[-1] & Eq[-2].abs()
F = Function.F(nargs=(), dtype=dtype.integer * n)
F.eval = lambda e: conditionset(x, Equality(x.set_comprehension(), e), S)
e = Symbol.e(dtype=dtype.integer)
Eq << Subset(F(e), S, plausible=True)
Eq << Eq[-1].this.lhs.definition
Eq << sets.subset.forall.imply.forall.apply(Eq[-1], Eq.permutation)
Eq.forall_x = ForAll(Contains(Eq[-1].lhs, F(e)),
*Eq[-1].limits,
plausible=True)
Eq << Eq.forall_x.definition.split()
P = Eq[-1].limits[0][1]
Eq << sets.imply.conditionset.apply(P)
Eq << Eq[-1].apply(sets.equality.imply.equality.permutation, x)
Eq.equality_e = Eq[-3] & Eq[-1]
Eq << sets.imply.conditionset.apply(F(e)).reversed
def prove(Eq):
n = Symbol.n(domain=Interval(2, oo, integer=True))
S = Symbol.S(dtype=dtype.integer * n)
x = Symbol.x(**S.element_symbol().dtype.dict)
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
w = Symbol.w(integer=True, shape=(n, n, n, n), definition=LAMBDA[j:n, i:n](Swap(n, i, j)))
given = ForAll[x:S](Contains(w[0, j] @ x, S))
Eq << apply(given)
Eq.given_i = given.subs(j, i)
Eq << given.subs(x, Eq.given_i.function.lhs)
Eq << (Eq.given_i & Eq[-1]).split()[-1]
Eq << Eq.given_i.subs(x, Eq[-1].function.lhs)
Eq.final_statement = (Eq[-2] & Eq[-1]).split()[0]
Eq << swap2.equality.apply(n, w)
Eq << Eq[-1] @ x
Eq << Eq[-1].forall((Eq[-1].limits[0].args[1].args[1].arg,))
Eq.i_complement = Eq.final_statement.subs(Eq[-1])
Eq.plausible = ForAll(Contains(w[i, j] @ x, S), (x, S), (j, Interval(1, n - 1, integer=True)), plausible=True)
Eq << Eq.plausible.bisect(i.set, wrt=j)
Eq.i_complement, Eq.i_intersection = Eq[-1].split()
Eq << sets.imply.equality.intersection.apply(i, Interval(1, n - 1, integer=True))
Eq << Eq.i_intersection.this.limits[1].subs(Eq[-1])
Eq << Eq[-1].subs(w[i, i].equality_defined())
Eq << (Eq.i_complement & Eq.i_intersection)
Eq << elementary.swap.transpose.apply(w).subs(j, 0)
Eq << Eq.given_i.subs(Eq[-1].reversed)
Eq << (Eq[-1] & Eq.plausible)
def prove(Eq):
S = Symbol.S(dtype=dtype.integer)
Eq << apply(Equality(abs(S), 1))
Eq << StrictGreaterThan(abs(S), 0, plausible=True)
Eq << Eq[-1].subs(Eq[0])
Eq << sets.strict_greater_than.imply.inequality.apply(Eq[-1])
Eq << sets.inequality.imply.exists.contains.apply(Eq[-1])
Eq << Eq[-1].apply(sets.contains.imply.subset, simplify=False)
Eq << Eq[-1].apply(sets.subset.equality.imply.equality, Eq[0])
def prove(Eq):
n = Symbol.n(domain=Interval(2, oo, integer=True))
S = Symbol.S(dtype=dtype.integer * n)
x = Symbol.x(**S.element_symbol().dtype.dict)
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
given = ForAll(
Contains(
LAMBDA[i:n](Piecewise((x[0], Equality(i, j)),
(x[j], Equality(i, 0)), (x[i], True))), S),
(j, 1, n - 1), (x, S))
Eq << apply(given)
w = Eq[0].lhs.base
Eq << swap1.utility.apply(x, w[0])
Eq << Eq[-1].reference(*Eq[-1].limits)
Eq.given = Eq[1].subs(Eq[-1].reversed)
Eq << axiom.algebre.matrix.elementary.swap.identity.apply(x, w)
Eq << Eq[-1].subs(Eq[-1].rhs.args[0].indices[0], 0)
Eq << Eq[-1].this.lhs.limits_subs(Eq[-1].lhs.variable, i)
Eq << Eq[-1].this.lhs.function.indices[0].args[1].limits_subs(
Eq[-1].lhs.function.indices[0].args[1].variable, i)
Eq << Eq[-1].subs(Eq[-1].rhs.args[0].indices[1], j)
Eq.given = Eq.given.subs(Eq[-1])
Eq << Eq.given.limits_swap()
Eq << ForAll[x:S](Eq[-1].function.subs(j, 0), plausible=True)
Eq << Eq[-1].subs(w[0, 0].this.definition)
Eq <<= Eq[-1] & Eq[-2]
Eq << combinatorics.permutation.adjacent.swap2.contains.apply(Eq[-1])
def prove(Eq):
n = Symbol.n(domain=Interval(2, oo, integer=True))
S = Symbol.S(dtype=dtype.integer * n)
x = Symbol.x(**S.element_symbol().dtype.dict)
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
k = Symbol.k(integer=True)
e = Symbol.e(dtype=dtype.integer, given=True)
p = Symbol.p(shape=(oo, ), integer=True, nonnegative=True)
P = Symbol.P(dtype=dtype.integer * n,
definition=conditionset(
p[:n],
Equality(p[:n].set_comprehension(),
Interval(0, n - 1, integer=True))))
Eq << apply(ForAll[x:S](Equality(x.set_comprehension(), e)),
ForAll[x:S, p[:n]:P](Contains(LAMBDA[k:n](x[p[k]]), S)),
Equality(abs(e), n))
def prove(Eq):
n = Symbol.n(domain=Interval(2, oo, integer=True))
S = Symbol.S(dtype=dtype.integer * n, given=True)
x = Symbol.x(shape=(oo, ), integer=True)
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
w = Symbol.w(definition=LAMBDA[j:n, i:n](Swap(n, i, j)))
given = ForAll[x[:n]:S](Contains(w[i, j] @ x[:n], S))
Eq.P_definition, Eq.w_definition, Eq.swap, Eq.axiom = apply(given)
Eq << factorization.apply(n)
*_, b_i = Eq[-1].rhs.args[1].function.args
b, _i = b_i.args
Eq << Eq.w_definition.subs(j, b[_i]).subs(i, _i)
Eq << Eq[-2].subs(Eq[-1].reversed)
k = Eq.axiom.lhs.variable
Eq << Eq[-1][k]
Eq << Eq[-1].this.function.function.rhs.args[0].limits_subs(_i, k)
Eq << swapn.utility.apply(x[:n], b[:n], w)
Eq << Eq[-1].subs(Eq[-2].reversed)
Eq.plausible = Eq.axiom.subs(Eq[-1])
Eq << swapn.mat_product.apply(Eq.swap.T, n, b)
Eq << Eq.plausible.this.function.as_ForAll()
def prove(Eq):
n = Symbol.n(domain=Interval(2, oo, integer=True))
S = Symbol.S(dtype=dtype.integer * n, given=True)
x = Symbol.x(shape=(n,), integer=True)
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
w = Symbol.w(definition=LAMBDA[j:n, i:n](Swap(n, i, j)))
given = ForAll[x[:n]:S](Contains(x[:n] @ w[i, j], S))
Eq.w_definition, Eq.swap, Eq.mat_product = apply(given)
i, _, m_1 = Eq.mat_product.function.lhs.args[1].limits[0]
m = m_1 + 1
b = Eq.mat_product.function.lhs.args[1].function.indices[1].base
Eq << Eq.mat_product.subs(m, 0)
Eq << Eq.mat_product.subs(m, m + 1)
Eq << Eq[-1].function.lhs.args[1].this.bisect(Slice[-1:])
Eq << x @ Eq[-1]
Eq << Eq.swap.subs(i, m).subs(j, b[m])
Eq << Eq[-1].subs(x, Eq[2].rhs.func(*Eq[2].rhs.args[:2]))
Eq << Eq[-1].forall((x, S))
Eq << (Eq[-1] & Eq.mat_product).split()
Eq << Eq[-1].subs(Eq[2].reversed)
