name
stringlengths 3
112
| file
stringlengths 21
116
| statement
stringlengths 17
8.64k
| state
stringlengths 7
205k
| tactic
stringlengths 3
4.55k
| result
stringlengths 7
205k
| id
stringlengths 16
16
|
|---|---|---|---|---|---|---|
Filter.liminf_sdiff
|
Mathlib/Order/LiminfLimsup.lean
|
theorem liminf_sdiff [NeBot f] (a : α) : liminf u f \ a = liminf (fun b => u b \ a) f
|
α : Type u_1
β : Type u_2
inst✝¹ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
inst✝ : f.NeBot
a : α
⊢ liminf u f \ a = liminf (fun b => u b \ a) f
|
simp only [sdiff_eq, inf_comm _ aᶜ, inf_liminf]
|
no goals
|
3142b483c8bd7f08
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.blastDivSubtractShift_decl_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.lean
|
theorem blastDivSubtractShift_decl_eq (aig : AIG α) (falseRef trueRef : AIG.Ref aig)
(n d : AIG.RefVec aig w) (wn wr : Nat) (q r : AIG.RefVec aig w) :
∀ (idx : Nat) (h1) (h2),
(blastDivSubtractShift aig falseRef trueRef n d wn wr q r).aig.decls[idx]'h2 = aig.decls[idx]'h1
|
case h2.h.h.h.h
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
falseRef trueRef : aig.Ref
n d : aig.RefVec w
wn wr : Nat
q r : aig.RefVec w
res : BlastDivSubtractShiftOutput aig w
hres :
{
aig :=
(AIG.RefVec.ite
(AIG.RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref.cast
⋯,
lhs :=
(((((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig,
wn := wn - 1, wr := wr + 1,
q :=
(AIG.RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).vec.cast
⋯,
r :=
(AIG.RefVec.ite
(AIG.RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref.cast
⋯,
lhs :=
(((((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).vec,
hle := ⋯ } =
res
idx✝ : Nat
h1✝ : idx✝ < aig.decls.size
h2✝ :
idx✝ <
{
aig :=
(AIG.RefVec.ite
(AIG.RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref.cast
⋯,
lhs :=
(((((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig,
wn := wn - 1, wr := wr + 1,
q :=
(AIG.RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).vec.cast
⋯,
r :=
(AIG.RefVec.ite
(AIG.RefVec.ite
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref,
lhs :=
(((blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).aig
{
discr :=
(BVPred.mkUlt
(blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).aig
{
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }).ref.cast
⋯,
lhs :=
(((((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast
⋯).cast
⋯).cast
⋯,
rhs :=
((blastSub
(blastShiftConcat
(blastShiftConcat
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig
{ lhs := (q.cast ⋯).cast ⋯, bit := (trueRef.cast ⋯).cast ⋯ }).aig
{
lhs :=
((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast
⋯).cast
⋯,
rhs := ((d.cast ⋯).cast ⋯).cast ⋯ }).vec.cast
⋯).cast
⋯ }).vec,
hle := ⋯ }.aig.decls.size
⊢ idx✝ < aig.decls.size
|
assumption
|
no goals
|
76230fc57d8c20e2
|
Submodule.goursatFst_prod_goursatSnd_le
|
Mathlib/LinearAlgebra/Goursat.lean
|
lemma goursatFst_prod_goursatSnd_le : L.goursatFst.prod L.goursatSnd ≤ L
|
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
L : Submodule R (M × N)
⊢ L.goursatFst.prod L.goursatSnd ≤ L
|
simpa only [← toAddSubgroup_le, goursatFst_toAddSubgroup, goursatSnd_toAddSubgroup]
using L.toAddSubgroup.goursatFst_prod_goursatSnd_le
|
no goals
|
006e5b2502a4ed1e
|
MeasureTheory.hasFDerivAt_convolution_right_with_param
|
Mathlib/Analysis/Convolution.lean
|
theorem hasFDerivAt_convolution_right_with_param {g : P → G → E'} {s : Set P} {k : Set G}
(hs : IsOpen s) (hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
(hf : LocallyIntegrable f μ) (hg : ContDiffOn 𝕜 1 (↿g) (s ×ˢ univ)) (q₀ : P × G)
(hq₀ : q₀.1 ∈ s) :
HasFDerivAt (fun q : P × G => (f ⋆[L, μ] g q.1) q.2)
((f ⋆[L.precompR (P × G), μ] fun x : G => fderiv 𝕜 (↿g) (q₀.1, x)) q₀.2) q₀
|
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
F : Type uF
P : Type uP
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup E'
inst✝¹¹ : NormedAddCommGroup F
f : G → E
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 E'
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedSpace 𝕜 F
inst✝⁵ : MeasurableSpace G
inst✝⁴ : NormedAddCommGroup G
inst✝³ : BorelSpace G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup P
inst✝ : NormedSpace 𝕜 P
μ : Measure G
L : E →L[𝕜] E' →L[𝕜] F
g : P → G → E'
s : Set P
k : Set G
hs : IsOpen s
hk : IsCompact k
hgs : ∀ (p : P) (x : G), p ∈ s → x ∉ k → g p x = 0
hf : LocallyIntegrable f μ
hg : ContDiffOn 𝕜 1 (↿g) (s ×ˢ univ)
q₀ : P × G
hq₀ : q₀.1 ∈ s
g' : P × G → P × G →L[𝕜] E' := fderiv 𝕜 ↿g
A : ∀ p ∈ s, Continuous (g p)
A' : ∀ (q : P × G), q.1 ∈ s → s ×ˢ univ ∈ 𝓝 q
p : P
x : G
hp : p ∈ s
hx : x ∉ k
⊢ g' (p, x) = 0
|
refine (hasFDerivAt_zero_of_eventually_const 0 ?_).fderiv
|
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
F : Type uF
P : Type uP
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup E'
inst✝¹¹ : NormedAddCommGroup F
f : G → E
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 E'
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedSpace 𝕜 F
inst✝⁵ : MeasurableSpace G
inst✝⁴ : NormedAddCommGroup G
inst✝³ : BorelSpace G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup P
inst✝ : NormedSpace 𝕜 P
μ : Measure G
L : E →L[𝕜] E' →L[𝕜] F
g : P → G → E'
s : Set P
k : Set G
hs : IsOpen s
hk : IsCompact k
hgs : ∀ (p : P) (x : G), p ∈ s → x ∉ k → g p x = 0
hf : LocallyIntegrable f μ
hg : ContDiffOn 𝕜 1 (↿g) (s ×ˢ univ)
q₀ : P × G
hq₀ : q₀.1 ∈ s
g' : P × G → P × G →L[𝕜] E' := fderiv 𝕜 ↿g
A : ∀ p ∈ s, Continuous (g p)
A' : ∀ (q : P × G), q.1 ∈ s → s ×ˢ univ ∈ 𝓝 q
p : P
x : G
hp : p ∈ s
hx : x ∉ k
⊢ ↿g =ᶠ[𝓝 (p, x)] fun x => 0
|
681ec723c7fd0b70
|
MeasureTheory.Measure.integral_isMulLeftInvariant_isMulRightInvariant_combo
|
Mathlib/MeasureTheory/Measure/Haar/Unique.lean
|
/-- In a group with a left invariant measure `μ` and a right invariant measure `ν`, one can express
integrals with respect to `μ` as integrals with respect to `ν` up to a constant scaling factor
(given in the statement as `∫ x, g x ∂μ` where `g` is a fixed reference function) and an
explicit density `y ↦ 1/∫ z, g (z⁻¹ * y) ∂ν`. -/
@[to_additive]
lemma integral_isMulLeftInvariant_isMulRightInvariant_combo
{μ ν : Measure G} [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν]
[IsMulLeftInvariant μ] [IsMulRightInvariant ν] [IsOpenPosMeasure ν]
{f g : G → ℝ} (hf : Continuous f) (h'f : HasCompactSupport f)
(hg : Continuous g) (h'g : HasCompactSupport g) (g_nonneg : 0 ≤ g) {x₀ : G} (g_pos : g x₀ ≠ 0) :
∫ x, f x ∂μ = (∫ y, f y * (∫ z, g (z⁻¹ * y) ∂ν)⁻¹ ∂ν) * ∫ x, g x ∂μ
|
case h'f
G : Type u_1
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : IsTopologicalGroup G
inst✝⁶ : MeasurableSpace G
inst✝⁵ : BorelSpace G
μ ν : Measure G
inst✝⁴ : IsFiniteMeasureOnCompacts μ
inst✝³ : IsFiniteMeasureOnCompacts ν
inst✝² : μ.IsMulLeftInvariant
inst✝¹ : ν.IsMulRightInvariant
inst✝ : ν.IsOpenPosMeasure
f g : G → ℝ
hf : Continuous f
h'f : HasCompactSupport f
hg : Continuous g
h'g : HasCompactSupport g
g_nonneg : 0 ≤ g
x₀ : G
g_pos : g x₀ ≠ 0
Hf : LocallyCompactSpace G
D : G → ℝ := fun x => ∫ (y : G), g (y⁻¹ * x) ∂ν
D_cont : Continuous D
D_pos : ∀ (x : G), 0 < D x
K : Set G := tsupport f
K_comp : IsCompact K
⊢ HasCompactSupport (uncurry fun x y => f x * (D x)⁻¹ * g (y⁻¹ * x))
|
let L := tsupport g
|
case h'f
G : Type u_1
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : IsTopologicalGroup G
inst✝⁶ : MeasurableSpace G
inst✝⁵ : BorelSpace G
μ ν : Measure G
inst✝⁴ : IsFiniteMeasureOnCompacts μ
inst✝³ : IsFiniteMeasureOnCompacts ν
inst✝² : μ.IsMulLeftInvariant
inst✝¹ : ν.IsMulRightInvariant
inst✝ : ν.IsOpenPosMeasure
f g : G → ℝ
hf : Continuous f
h'f : HasCompactSupport f
hg : Continuous g
h'g : HasCompactSupport g
g_nonneg : 0 ≤ g
x₀ : G
g_pos : g x₀ ≠ 0
Hf : LocallyCompactSpace G
D : G → ℝ := fun x => ∫ (y : G), g (y⁻¹ * x) ∂ν
D_cont : Continuous D
D_pos : ∀ (x : G), 0 < D x
K : Set G := tsupport f
K_comp : IsCompact K
L : Set G := tsupport g
⊢ HasCompactSupport (uncurry fun x y => f x * (D x)⁻¹ * g (y⁻¹ * x))
|
6b9d060f3308d3d5
|
mem_adjoin_of_smul_prime_smul_of_minpoly_isEisensteinAt
|
Mathlib/RingTheory/Polynomial/Eisenstein/IsIntegral.lean
|
theorem mem_adjoin_of_smul_prime_smul_of_minpoly_isEisensteinAt {B : PowerBasis K L}
(hp : Prime p) (hBint : IsIntegral R B.gen) {z : L} (hzint : IsIntegral R z)
(hz : p • z ∈ adjoin R ({B.gen} : Set L)) (hei : (minpoly R B.gen).IsEisensteinAt 𝓟) :
z ∈ adjoin R ({B.gen} : Set L)
|
case neg.hi.convert_2.intro
R : Type u
K : Type v
L : Type z
p : R
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : Algebra K L
inst✝⁶ : Algebra R L
inst✝⁵ : Algebra R K
inst✝⁴ : IsScalarTower R K L
inst✝³ : Algebra.IsSeparable K L
inst✝² : IsDomain R
inst✝¹ : IsFractionRing R K
inst✝ : IsIntegrallyClosed R
B : PowerBasis K L
hp : _root_.Prime p
hBint : IsIntegral R B.gen
z : L
hzint : IsIntegral R z
this✝ : Module.Finite K L
P : R[X] := minpoly R B.gen
hei : P.IsEisensteinAt (Submodule.span R {p})
hndiv : ¬p ^ 2 ∣ P.coeff 0
hP : P = minpoly R B.gen
n : ℕ
hn : B.dim = n.succ
this : NoZeroSMulDivisors R L
x✝ : L[X] := Polynomial.map (algebraMap R L) P
Q₁ : R[X]
Q : R[X] := Q₁ %ₘ P
hQ₁ : Q = Q₁ %ₘ P
hQzero : ¬Q = 0
j : ℕ
hj : j + 1 ∈ range (Q.natDegree + 1)
H : j + 1 + 1 ≤ P.natDegree
Hj : Q.natDegree + 1 = j + 1 + (Q.natDegree - j)
g : ℕ → R
hg : ∀ k ∈ range (j + 1), Q.coeff k • B.gen ^ k = (algebraMap R L) p * g k • B.gen ^ k
f : ℕ → L
hf :
∀ (i : ℕ),
(Polynomial.map (algebraMap R L) (minpoly R B.gen)).natDegree ≤ i →
f i ∈ adjoin R {B.gen} ∧ (algebraMap R L) p * f i = B.gen ^ i
hf₁ :
∀ k ∈ (range (Q.natDegree - j)).erase 0,
Q.coeff (j + 1 + k) • B.gen ^ (j + 1 + k) * B.gen ^ (P.natDegree - (j + 2)) =
(algebraMap R L) p * Q.coeff (j + 1 + k) • f (k + P.natDegree - 1)
hQ :
(Algebra.norm K) ((algebraMap R L) (Q.coeff (j + 1)) * B.gen ^ (j + 1 + (P.natDegree - (j + 2)))) =
(Algebra.norm K)
(p • z * B.gen ^ (P.natDegree - (j + 2)) -
(algebraMap R L) p *
(∑ i ∈ (range (Q.natDegree - j)).erase 0, Q.coeff (j + 1 + i) • f (i + P.natDegree - 1) +
∑ i ∈ range (j + 1), g i • B.gen ^ i * B.gen ^ (P.natDegree - (j + 2))))
hintsum :
IsIntegral R
(z * B.gen ^ (P.natDegree - (j + 2)) -
(∑ x ∈ (range (Q.natDegree - j)).erase 0, Q.coeff (j + 1 + x) • f (x + P.natDegree - 1) +
∑ x ∈ range (j + 1), g x • B.gen ^ x * B.gen ^ (P.natDegree - (j + 2))))
r : R
hr :
(algebraMap R K) r =
(Algebra.norm K)
(z * B.gen ^ (P.natDegree - (j + 2)) -
(∑ x ∈ (range (Q.natDegree - j)).erase 0, Q.coeff (j + 1 + x) • f (x + P.natDegree - 1) +
∑ x ∈ range (j + 1), g x • B.gen ^ x * B.gen ^ (P.natDegree - (j + 2))))
⊢ p ^ n.succ ∣ Q.coeff j.succ ^ n.succ * (minpoly R B.gen).coeff 0 ^ (j.succ + (P.natDegree - (j + 2)))
|
rw [Algebra.smul_def, mul_assoc, ← mul_sub, _root_.map_mul, algebraMap_apply R K L, map_pow,
Algebra.norm_algebraMap, _root_.map_mul, algebraMap_apply R K L, Algebra.norm_algebraMap,
finrank B, ← hr, PowerBasis.norm_gen_eq_coeff_zero_minpoly,
minpoly.isIntegrallyClosed_eq_field_fractions' K hBint, coeff_map,
show (-1 : K) = algebraMap R K (-1) by simp, ← map_pow, ← map_pow, ← _root_.map_mul, ←
map_pow, ← _root_.map_mul, ← map_pow, ← _root_.map_mul] at hQ
|
case neg.hi.convert_2.intro
R : Type u
K : Type v
L : Type z
p : R
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : Algebra K L
inst✝⁶ : Algebra R L
inst✝⁵ : Algebra R K
inst✝⁴ : IsScalarTower R K L
inst✝³ : Algebra.IsSeparable K L
inst✝² : IsDomain R
inst✝¹ : IsFractionRing R K
inst✝ : IsIntegrallyClosed R
B : PowerBasis K L
hp : _root_.Prime p
hBint : IsIntegral R B.gen
z : L
hzint : IsIntegral R z
this✝ : Module.Finite K L
P : R[X] := minpoly R B.gen
hei : P.IsEisensteinAt (Submodule.span R {p})
hndiv : ¬p ^ 2 ∣ P.coeff 0
hP : P = minpoly R B.gen
n : ℕ
hn : B.dim = n.succ
this : NoZeroSMulDivisors R L
x✝ : L[X] := Polynomial.map (algebraMap R L) P
Q₁ : R[X]
Q : R[X] := Q₁ %ₘ P
hQ₁ : Q = Q₁ %ₘ P
hQzero : ¬Q = 0
j : ℕ
hj : j + 1 ∈ range (Q.natDegree + 1)
H : j + 1 + 1 ≤ P.natDegree
Hj : Q.natDegree + 1 = j + 1 + (Q.natDegree - j)
g : ℕ → R
hg : ∀ k ∈ range (j + 1), Q.coeff k • B.gen ^ k = (algebraMap R L) p * g k • B.gen ^ k
f : ℕ → L
hf :
∀ (i : ℕ),
(Polynomial.map (algebraMap R L) (minpoly R B.gen)).natDegree ≤ i →
f i ∈ adjoin R {B.gen} ∧ (algebraMap R L) p * f i = B.gen ^ i
hf₁ :
∀ k ∈ (range (Q.natDegree - j)).erase 0,
Q.coeff (j + 1 + k) • B.gen ^ (j + 1 + k) * B.gen ^ (P.natDegree - (j + 2)) =
(algebraMap R L) p * Q.coeff (j + 1 + k) • f (k + P.natDegree - 1)
hintsum :
IsIntegral R
(z * B.gen ^ (P.natDegree - (j + 2)) -
(∑ x ∈ (range (Q.natDegree - j)).erase 0, Q.coeff (j + 1 + x) • f (x + P.natDegree - 1) +
∑ x ∈ range (j + 1), g x • B.gen ^ x * B.gen ^ (P.natDegree - (j + 2))))
r : R
hQ :
(algebraMap R K)
(Q.coeff (j + 1) ^ B.dim * ((-1) ^ B.dim * (minpoly R B.gen).coeff 0) ^ (j + 1 + (P.natDegree - (j + 2)))) =
(algebraMap R K) (p ^ B.dim * r)
hr :
(algebraMap R K) r =
(Algebra.norm K)
(z * B.gen ^ (P.natDegree - (j + 2)) -
(∑ x ∈ (range (Q.natDegree - j)).erase 0, Q.coeff (j + 1 + x) • f (x + P.natDegree - 1) +
∑ x ∈ range (j + 1), g x • B.gen ^ x * B.gen ^ (P.natDegree - (j + 2))))
⊢ p ^ n.succ ∣ Q.coeff j.succ ^ n.succ * (minpoly R B.gen).coeff 0 ^ (j.succ + (P.natDegree - (j + 2)))
|
fa4f10e8cbdbb4c7
|
CategoryTheory.mem_essImage_of_unit_isSplitMono
|
Mathlib/CategoryTheory/Adjunction/Reflective.lean
|
theorem mem_essImage_of_unit_isSplitMono [Reflective i] {A : C}
[IsSplitMono ((reflectorAdjunction i).unit.app A)] : i.essImage A
|
C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
i : D ⥤ C
inst✝¹ : Reflective i
A : C
inst✝ : IsSplitMono ((reflectorAdjunction i).unit.app A)
η : 𝟭 C ⟶ reflector i ⋙ i := (reflectorAdjunction i).unit
this✝¹ : IsIso (η.app (i.obj ((reflector i).obj A)))
this✝ : Epi (η.app A)
this : IsIso (η.app A)
⊢ i.essImage A
|
exact (reflectorAdjunction i).mem_essImage_of_unit_isIso A
|
no goals
|
78eecab7fff04ed5
|
HNNExtension.NormalWord.unitsSMul_cancels_iff
|
Mathlib/GroupTheory/HNNExtension.lean
|
theorem unitsSMul_cancels_iff (u : ℤˣ) (w : NormalWord d) :
Cancels (-u) (unitsSMul φ u w) ↔ ¬ Cancels u w
|
case pos.cons
G : Type u_1
inst✝ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
d : TransversalPair G A B
u : ℤˣ
g : G
u' : ℤˣ
w : NormalWord d
h1 : w.head ∈ d.set u'
h2 : ∀ u'_1 ∈ Option.map Prod.fst w.toList.head?, w.head ∈ toSubgroup A B u' → u' = u'_1
a✝ : ∀ (h : Cancels u w), ¬Cancels (-u) (unitsSMulWithCancel φ u w ⋯)
h✝ : Cancels u (cons g u' w h1 h2)
hc : Cancels (-u) (unitsSMulWithCancel φ u (cons g u' w h1 h2) ⋯)
h : g ∈ toSubgroup A B u ∧ u' = -u
⊢ Cancels u' w
|
cases h.2
|
case pos.cons.refl
G : Type u_1
inst✝ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
d : TransversalPair G A B
u : ℤˣ
g : G
w : NormalWord d
a✝ : ∀ (h : Cancels u w), ¬Cancels (-u) (unitsSMulWithCancel φ u w ⋯)
h1 : w.head ∈ d.set (-u)
h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ toSubgroup A B (-u) → -u = u'
h✝ : Cancels u (cons g (-u) w h1 h2)
hc : Cancels (-u) (unitsSMulWithCancel φ u (cons g (-u) w h1 h2) ⋯)
h : g ∈ toSubgroup A B u ∧ -u = -u
⊢ Cancels (-u) w
|
b3a9a1f389e0c3f6
|
AlgebraicGeometry.genericPoint_eq_of_isOpenImmersion
|
Mathlib/AlgebraicGeometry/FunctionField.lean
|
theorem genericPoint_eq_of_isOpenImmersion {X Y : Scheme} (f : X ⟶ Y) [H : IsOpenImmersion f]
[hX : IrreducibleSpace X] [IrreducibleSpace Y] :
f.base (genericPoint X) = genericPoint Y
|
case h.e'_4
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
hX : IrreducibleSpace ↑↑X.toPresheafedSpace
inst✝ : IrreducibleSpace ↑↑Y.toPresheafedSpace
⊢ Set.univ = closure (⇑(ConcreteCategory.hom f.base) '' Set.univ)
|
symm
|
case h.e'_4
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
hX : IrreducibleSpace ↑↑X.toPresheafedSpace
inst✝ : IrreducibleSpace ↑↑Y.toPresheafedSpace
⊢ closure (⇑(ConcreteCategory.hom f.base) '' Set.univ) = Set.univ
|
1e9165b2d519e678
|
List.Perm.pmap
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Perm.lean
|
theorem Perm.pmap {p : α → Prop} (f : ∀ a, p a → β) {l₁ l₂ : List α} (p : l₁ ~ l₂) {H₁ H₂} :
pmap f l₁ H₁ ~ pmap f l₂ H₂
|
α : Type u_1
β : Type u_2
p✝ : α → Prop
f : (a : α) → p✝ a → β
l₁ l₂ : List α
p : l₁ ~ l₂
H₁ : ∀ (a : α), a ∈ l₁ → p✝ a
H₂ : ∀ (a : α), a ∈ l₂ → p✝ a
⊢ List.pmap f l₁ H₁ ~ List.pmap f l₂ H₂
|
induction p with
| nil => simp
| cons x _p IH => simp [IH, Perm.cons]
| swap x y => simp [swap]
| trans _p₁ p₂ IH₁ IH₂ => exact IH₁.trans (IH₂ (H₁ := fun a m => H₂ a (p₂.subset m)))
|
no goals
|
b6857377dabdd618
|
ContinuousLinearMap.opNorm_le_of_unit_norm
|
Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
|
theorem opNorm_le_of_unit_norm [NormedSpace ℝ E] [NormedSpace ℝ F] {f : E →L[ℝ] F} {C : ℝ}
(hC : 0 ≤ C) (hf : ∀ x, ‖x‖ = 1 → ‖f x‖ ≤ C) : ‖f‖ ≤ C
|
E : Type u_4
F : Type u_5
inst✝³ : SeminormedAddCommGroup E
inst✝² : SeminormedAddCommGroup F
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
C : ℝ
hC : 0 ≤ C
hf : ∀ (x : E), ‖x‖ = 1 → ‖f x‖ ≤ C
⊢ ‖f‖ ≤ C
|
refine opNorm_le_bound' f hC fun x hx => ?_
|
E : Type u_4
F : Type u_5
inst✝³ : SeminormedAddCommGroup E
inst✝² : SeminormedAddCommGroup F
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
C : ℝ
hC : 0 ≤ C
hf : ∀ (x : E), ‖x‖ = 1 → ‖f x‖ ≤ C
x : E
hx : ‖x‖ ≠ 0
⊢ ‖f x‖ ≤ C * ‖x‖
|
7859156de0e60578
|
FirstOrder.Language.Substructure.cg_iff_empty_or_exists_nat_generating_family
|
Mathlib/ModelTheory/FinitelyGenerated.lean
|
theorem cg_iff_empty_or_exists_nat_generating_family {N : L.Substructure M} :
N.CG ↔ N = (∅ : Set M) ∨ ∃ s : ℕ → M, closure L (range s) = N
|
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ S, S.Countable ∧ (closure L).toFun S = N) ↔ ↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N
|
constructor
|
case mp
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ S, S.Countable ∧ (closure L).toFun S = N) → ↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N
case mpr
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N) → ∃ S, S.Countable ∧ (closure L).toFun S = N
|
9cbb3eaa8b379543
|
HurwitzZeta.hurwitzZetaEven_one_sub
|
Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
|
/-- If `s` is not in `-ℕ`, and either `a ≠ 0` or `s ≠ 1`, then
`hurwitzZetaEven a (1 - s)` is an explicit multiple of `cosZeta s`. -/
lemma hurwitzZetaEven_one_sub (a : UnitAddCircle) {s : ℂ}
(hs : ∀ (n : ℕ), s ≠ -n) (hs' : a ≠ 0 ∨ s ≠ 1) :
hurwitzZetaEven a (1 - s) = 2 * (2 * π) ^ (-s) * Gamma s * cos (π * s / 2) * cosZeta a s
|
a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
hs' : a ≠ 0 ∨ s ≠ 1
⊢ a ≠ 0 ∨ 1 - s ≠ 0
|
simpa [sub_eq_zero, eq_comm (a := s)] using hs'
|
no goals
|
ba1c42484b38c301
|
SSet.horn.hom_ext
|
Mathlib/AlgebraicTopology/SimplicialSet/Horn.lean
|
/-- Two morphisms from a horn are equal if they are equal on all suitable faces. -/
protected
lemma hom_ext {n : ℕ} {i : Fin (n+2)} {S : SSet} (σ₁ σ₂ : Λ[n+1, i] ⟶ S)
(h : ∀ (j) (h : j ≠ i), σ₁.app _ (face i j h) = σ₂.app _ (face i j h)) :
σ₁ = σ₂
|
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app (op ⦋n⦌) (face i j h) = σ₂.app (op ⦋n⦌) (face i j h)
m : ℕ
f : Λ[n + 1, i] _⦋m⦌
f' : unop (op ⦋m⦌) ⟶ ⦋n + 1⦌
hf : (stdSimplex.objEquiv ⦋n + 1⦌ (op ⦋m⦌)).symm f' = ↑f
⊢ ∃ j, ¬j = i ∧ ∀ (k : Fin ((unop (op ⦋m⦌)).len + 1)), (Hom.toOrderHom f') k ≠ j
|
obtain ⟨f, hf'⟩ := f
|
case mk
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app (op ⦋n⦌) (face i j h) = σ₂.app (op ⦋n⦌) (face i j h)
m : ℕ
f' : unop (op ⦋m⦌) ⟶ ⦋n + 1⦌
f : Δ[n + 1] _⦋m⦌
hf' : Set.range ⇑(asOrderHom f) ∪ {i} ≠ Set.univ
hf : (stdSimplex.objEquiv ⦋n + 1⦌ (op ⦋m⦌)).symm f' = ↑⟨f, hf'⟩
⊢ ∃ j, ¬j = i ∧ ∀ (k : Fin ((unop (op ⦋m⦌)).len + 1)), (Hom.toOrderHom f') k ≠ j
|
81aed7a2f2a51d1a
|
Sylow.mapSurjective_surjective
|
Mathlib/GroupTheory/Sylow.lean
|
theorem mapSurjective_surjective (p : ℕ) [Fact p.Prime] :
Function.Surjective (Sylow.mapSurjective hf : Sylow p G → Sylow p G')
|
G : Type u_1
inst✝³ : Group G
inst✝² : Finite G
G' : Type u_2
inst✝¹ : Group G'
f : G →* G'
hf : Function.Surjective ⇑f
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ Function.Surjective (mapSurjective hf)
|
have : Finite G' := Finite.of_surjective f hf
|
G : Type u_1
inst✝³ : Group G
inst✝² : Finite G
G' : Type u_2
inst✝¹ : Group G'
f : G →* G'
hf : Function.Surjective ⇑f
p : ℕ
inst✝ : Fact (Nat.Prime p)
this : Finite G'
⊢ Function.Surjective (mapSurjective hf)
|
0fc3ef39797b02b0
|
VectorFourier.norm_fourierPowSMulRight_iteratedFDeriv_fourierIntegral_le
|
Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
|
theorem norm_fourierPowSMulRight_iteratedFDeriv_fourierIntegral_le [FiniteDimensional ℝ V]
{μ : Measure V} [Measure.IsAddHaarMeasure μ] {K N : ℕ∞} (hf : ContDiff ℝ N f)
(h'f : ∀ (k n : ℕ), k ≤ K → n ≤ N → Integrable (fun v ↦ ‖v‖^k * ‖iteratedFDeriv ℝ n f v‖) μ)
{k n : ℕ} (hk : k ≤ K) (hn : n ≤ N) {w : W} :
‖fourierPowSMulRight (-L.flip)
(iteratedFDeriv ℝ k (fourierIntegral 𝐞 μ L.toLinearMap₂ f)) w n‖ ≤
(2 * π) ^ k * (2 * k + 2) ^ n * ‖L‖ ^ k * ∑ p ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1),
∫ v, ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ ∂μ
|
E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : NormedSpace ℝ V
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝³ : MeasurableSpace V
inst✝² : BorelSpace V
inst✝¹ : FiniteDimensional ℝ V
μ : Measure V
inst✝ : μ.IsAddHaarMeasure
K N : ℕ∞
hf : ContDiff ℝ (↑N) f
h'f : ∀ (k n : ℕ), ↑k ≤ K → ↑n ≤ N → Integrable (fun v => ‖v‖ ^ k * ‖iteratedFDeriv ℝ n f v‖) μ
k n : ℕ
hk : ↑k ≤ K
hn : ↑n ≤ N
w : W
I : ∀ p ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1), Integrable (fun v => ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖) μ
v : V
⊢ ∀ i ≤ n,
∀ j ≤ k,
‖v‖ ^ j * ‖iteratedFDeriv ℝ i f v‖ ≤
∑ i ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1), ‖v‖ ^ i.1 * ‖iteratedFDeriv ℝ i.2 f v‖
|
intro i hi j hj
|
E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : NormedSpace ℝ V
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝³ : MeasurableSpace V
inst✝² : BorelSpace V
inst✝¹ : FiniteDimensional ℝ V
μ : Measure V
inst✝ : μ.IsAddHaarMeasure
K N : ℕ∞
hf : ContDiff ℝ (↑N) f
h'f : ∀ (k n : ℕ), ↑k ≤ K → ↑n ≤ N → Integrable (fun v => ‖v‖ ^ k * ‖iteratedFDeriv ℝ n f v‖) μ
k n : ℕ
hk : ↑k ≤ K
hn : ↑n ≤ N
w : W
I : ∀ p ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1), Integrable (fun v => ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖) μ
v : V
i : ℕ
hi : i ≤ n
j : ℕ
hj : j ≤ k
⊢ ‖v‖ ^ j * ‖iteratedFDeriv ℝ i f v‖ ≤
∑ i ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1), ‖v‖ ^ i.1 * ‖iteratedFDeriv ℝ i.2 f v‖
|
8318f0ae43be69ad
|
UpperHalfPlane.contMDiffAt_ofComplex
|
Mathlib/Analysis/Complex/UpperHalfPlane/Manifold.lean
|
lemma contMDiffAt_ofComplex {n : WithTop ℕ∞} {z : ℂ} (hz : 0 < z.im) :
ContMDiffAt 𝓘(ℂ) 𝓘(ℂ) n ofComplex z
|
case left
n : WithTop ℕ∞
z : ℂ
hz : 0 < z.im
⊢ Tendsto (Subtype.val ∘ ↑ofComplex) (nhds z) (nhds ↑(↑ofComplex z))
|
refine Tendsto.congr' (eventuallyEq_coe_comp_ofComplex hz).symm ?_
|
case left
n : WithTop ℕ∞
z : ℂ
hz : 0 < z.im
⊢ Tendsto id (nhds z) (nhds ↑(↑ofComplex z))
|
99c8225fb9438f5f
|
subsingleton_floorSemiring
|
Mathlib/Algebra/Order/Floor.lean
|
theorem subsingleton_floorSemiring {α} [LinearOrderedSemiring α] :
Subsingleton (FloorSemiring α)
|
α : Type u_4
inst✝ : LinearOrderedSemiring α
H₁ H₂ : FloorSemiring α
this✝ : FloorSemiring.ceil = FloorSemiring.ceil
this : FloorSemiring.floor = FloorSemiring.floor
⊢ H₁ = H₂
|
cases H₁
|
case mk
α : Type u_4
inst✝ : LinearOrderedSemiring α
H₂ : FloorSemiring α
floor✝ ceil✝ : α → ℕ
floor_of_neg✝ : ∀ {a : α}, a < 0 → floor✝ a = 0
gc_floor✝ : ∀ {a : α} {n : ℕ}, 0 ≤ a → (n ≤ floor✝ a ↔ ↑n ≤ a)
gc_ceil✝ : GaloisConnection ceil✝ Nat.cast
this✝ : FloorSemiring.ceil = FloorSemiring.ceil
this : FloorSemiring.floor = FloorSemiring.floor
⊢ { floor := floor✝, ceil := ceil✝, floor_of_neg := floor_of_neg✝, gc_floor := gc_floor✝, gc_ceil := gc_ceil✝ } = H₂
|
6d1650047452147a
|
EisensteinSeries.r1_aux_bound
|
Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean
|
/-- For `c, d ∈ ℝ` with `1 ≤ d ^ 2`, we have `r1 z ≤ |c * z + d| ^ 2`. -/
lemma r1_aux_bound (c : ℝ) {d : ℝ} (hd : 1 ≤ d ^ 2) :
r1 z ≤ (c * z.re + d) ^ 2 + (c * z.im) ^ 2
|
z : ℍ
c d : ℝ
hd : 1 ≤ d ^ 2
⊢ r1 z ≤ (c * z.re + d) ^ 2 + (c * z.im) ^ 2
|
have H1 : (c * z.re + d) ^ 2 + (c * z.im) ^ 2 =
c ^ 2 * (z.re ^ 2 + z.im ^ 2) + d * 2 * c * z.re + d ^ 2 := by ring
|
z : ℍ
c d : ℝ
hd : 1 ≤ d ^ 2
H1 : (c * z.re + d) ^ 2 + (c * z.im) ^ 2 = c ^ 2 * (z.re ^ 2 + z.im ^ 2) + d * 2 * c * z.re + d ^ 2
⊢ r1 z ≤ (c * z.re + d) ^ 2 + (c * z.im) ^ 2
|
9235d86a26f3640b
|
Turing.ToPartrec.code_is_ok
|
Mathlib/Computability/TMConfig.lean
|
theorem code_is_ok (c) : Code.Ok c
|
case cons.e_a.h
f fs : Code
IHf : f.Ok
IHfs : fs.Ok
k : Cont
v✝ v : List ℕ
⊢ eval step ?m.141342 = do
let x ← fs.eval v✝
eval step (Cfg.ret k (v.headI :: x))
case cons.e_a.h
f fs : Code
IHf : f.Ok
IHfs : fs.Ok
k : Cont
v✝ v : List ℕ
⊢ Reaches step (Cfg.ret (Cont.cons₁ fs v✝ k) v) ?m.141342
f fs : Code
IHf : f.Ok
IHfs : fs.Ok
k : Cont
v✝ v : List ℕ
⊢ Cfg
|
swap
|
case cons.e_a.h
f fs : Code
IHf : f.Ok
IHfs : fs.Ok
k : Cont
v✝ v : List ℕ
⊢ Reaches step (Cfg.ret (Cont.cons₁ fs v✝ k) v) ?m.141342
case cons.e_a.h
f fs : Code
IHf : f.Ok
IHfs : fs.Ok
k : Cont
v✝ v : List ℕ
⊢ eval step ?m.141342 = do
let x ← fs.eval v✝
eval step (Cfg.ret k (v.headI :: x))
f fs : Code
IHf : f.Ok
IHfs : fs.Ok
k : Cont
v✝ v : List ℕ
⊢ Cfg
|
1263cc60b426aeed
|
IsExposed.eq_inter_halfSpace
|
Mathlib/Analysis/Convex/Exposed.lean
|
theorem eq_inter_halfSpace [Nontrivial 𝕜] {A B : Set E} (hAB : IsExposed 𝕜 A B) :
∃ l : E →L[𝕜] 𝕜, ∃ a, B = { x ∈ A | a ≤ l x }
|
case inl
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
inst✝ : Nontrivial 𝕜
A : Set E
hAB : IsExposed 𝕜 A ∅
⊢ ∅ = {x | x ∈ A ∧ 1 ≤ 0 x}
|
rw [eq_comm, eq_empty_iff_forall_not_mem]
|
case inl
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
inst✝ : Nontrivial 𝕜
A : Set E
hAB : IsExposed 𝕜 A ∅
⊢ ∀ (x : E), x ∉ {x | x ∈ A ∧ 1 ≤ 0 x}
|
8f4e1e362f92e274
|
Algebra.Extension.CotangentSpace.map_comp
|
Mathlib/RingTheory/Kaehler/CotangentComplex.lean
|
lemma map_comp (f : Hom P P') (g : Hom P' P'') :
CotangentSpace.map (g.comp f) =
(CotangentSpace.map g).restrictScalars S ∘ₗ CotangentSpace.map f
|
case h.tmul
R : Type u
S : Type v
inst✝²² : CommRing R
inst✝²¹ : CommRing S
inst✝²⁰ : Algebra R S
P : Extension R S
R' : Type u'
S' : Type v'
inst✝¹⁹ : CommRing R'
inst✝¹⁸ : CommRing S'
inst✝¹⁷ : Algebra R' S'
P' : Extension R' S'
inst✝¹⁶ : Algebra R R'
inst✝¹⁵ : Algebra S S'
inst✝¹⁴ : Algebra R S'
inst✝¹³ : IsScalarTower R R' S'
R'' : Type u''
S'' : Type v''
inst✝¹² : CommRing R''
inst✝¹¹ : CommRing S''
inst✝¹⁰ : Algebra R'' S''
P'' : Extension R'' S''
inst✝⁹ : Algebra R R''
inst✝⁸ : Algebra S S''
inst✝⁷ : Algebra R S''
inst✝⁶ : IsScalarTower R R'' S''
inst✝⁵ : Algebra R' R''
inst✝⁴ : Algebra S' S''
inst✝³ : Algebra R' S''
inst✝² : IsScalarTower R' R'' S''
inst✝¹ : IsScalarTower R R' R''
inst✝ : IsScalarTower S S' S''
f : P.Hom P'
g : P'.Hom P''
x : S
y : Ω[P.Ring⁄R]
⊢ (CotangentSpace.map (g.comp f)) (x ⊗ₜ[P.Ring] y) =
(↑S (CotangentSpace.map g) ∘ₗ CotangentSpace.map f) (x ⊗ₜ[P.Ring] y)
|
obtain ⟨y, rfl⟩ := KaehlerDifferential.tensorProductTo_surjective _ _ y
|
case h.tmul.intro
R : Type u
S : Type v
inst✝²² : CommRing R
inst✝²¹ : CommRing S
inst✝²⁰ : Algebra R S
P : Extension R S
R' : Type u'
S' : Type v'
inst✝¹⁹ : CommRing R'
inst✝¹⁸ : CommRing S'
inst✝¹⁷ : Algebra R' S'
P' : Extension R' S'
inst✝¹⁶ : Algebra R R'
inst✝¹⁵ : Algebra S S'
inst✝¹⁴ : Algebra R S'
inst✝¹³ : IsScalarTower R R' S'
R'' : Type u''
S'' : Type v''
inst✝¹² : CommRing R''
inst✝¹¹ : CommRing S''
inst✝¹⁰ : Algebra R'' S''
P'' : Extension R'' S''
inst✝⁹ : Algebra R R''
inst✝⁸ : Algebra S S''
inst✝⁷ : Algebra R S''
inst✝⁶ : IsScalarTower R R'' S''
inst✝⁵ : Algebra R' R''
inst✝⁴ : Algebra S' S''
inst✝³ : Algebra R' S''
inst✝² : IsScalarTower R' R'' S''
inst✝¹ : IsScalarTower R R' R''
inst✝ : IsScalarTower S S' S''
f : P.Hom P'
g : P'.Hom P''
x : S
y : P.Ring ⊗[R] P.Ring
⊢ (CotangentSpace.map (g.comp f)) (x ⊗ₜ[P.Ring] (D R P.Ring).tensorProductTo y) =
(↑S (CotangentSpace.map g) ∘ₗ CotangentSpace.map f) (x ⊗ₜ[P.Ring] (D R P.Ring).tensorProductTo y)
|
36b1f3e0f0214876
|
Ideal.isPrime_ideal_prod_top
|
Mathlib/RingTheory/Ideal/Prod.lean
|
theorem isPrime_ideal_prod_top {I : Ideal R} [h : I.IsPrime] : (prod I (⊤ : Ideal S)).IsPrime
|
case mem_or_mem'.mk.mk.intro
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I : Ideal R
h : I.IsPrime
r₁ : R
s₁ : S
r₂ : R
s₂ : S
h₁ : (r₁, s₁) * (r₂, s₂) ∈ ↑(comap (RingHom.fst R S) I)
right✝ : (r₁, s₁) * (r₂, s₂) ∈ ↑(comap (RingHom.snd R S) ⊤)
⊢ (r₁, s₁) ∈ I.prod ⊤ ∨ (r₂, s₂) ∈ I.prod ⊤
|
rcases h.mem_or_mem h₁ with h | h
|
case mem_or_mem'.mk.mk.intro.inl
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I : Ideal R
h✝ : I.IsPrime
r₁ : R
s₁ : S
r₂ : R
s₂ : S
h₁ : (r₁, s₁) * (r₂, s₂) ∈ ↑(comap (RingHom.fst R S) I)
right✝ : (r₁, s₁) * (r₂, s₂) ∈ ↑(comap (RingHom.snd R S) ⊤)
h : (r₁, s₁).1 ∈ I
⊢ (r₁, s₁) ∈ I.prod ⊤ ∨ (r₂, s₂) ∈ I.prod ⊤
case mem_or_mem'.mk.mk.intro.inr
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I : Ideal R
h✝ : I.IsPrime
r₁ : R
s₁ : S
r₂ : R
s₂ : S
h₁ : (r₁, s₁) * (r₂, s₂) ∈ ↑(comap (RingHom.fst R S) I)
right✝ : (r₁, s₁) * (r₂, s₂) ∈ ↑(comap (RingHom.snd R S) ⊤)
h : (r₂, s₂).1 ∈ I
⊢ (r₁, s₁) ∈ I.prod ⊤ ∨ (r₂, s₂) ∈ I.prod ⊤
|
e99515d75b39b235
|
CategoryTheory.NonPreadditiveAbelian.σ_comp
|
Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
|
theorem σ_comp {X Y : C} (f : X ⟶ Y) : σ ≫ f = Limits.prod.map f f ≫ σ
|
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ ⋯).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ ⋯) ≫ g = prod.map f f ≫ σ
⊢ prod.lift (𝟙 X) 0 ≫ σ ≫ g = g
|
rw [← Category.assoc, lift_σ, Category.id_comp]
|
no goals
|
b7d15c6a05369a0f
|
CategoryTheory.IsCofilteredOrEmpty.of_exists_of_isCofiltered_of_fullyFaithful
|
Mathlib/CategoryTheory/Filtered/Final.lean
|
theorem IsCofilteredOrEmpty.of_exists_of_isCofiltered_of_fullyFaithful [IsCofilteredOrEmpty D]
[F.Full] [F.Faithful] (h : ∀ d, ∃ c, Nonempty (F.obj c ⟶ d)) : IsCofilteredOrEmpty C
|
case intro.intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
c : C
f : F.obj c ⟶ unop d
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
|
exact ⟨op c, ⟨f.op⟩⟩
|
no goals
|
a95d8844f0cff275
|
Finset.ofColex_ne_ofColex
|
Mathlib/Combinatorics/Colex.lean
|
lemma ofColex_ne_ofColex {s t : Colex α} : ofColex s ≠ ofColex t ↔ s ≠ t
|
α : Type u_1
s t : Colex α
⊢ s.ofColex ≠ t.ofColex ↔ s ≠ t
|
simp
|
no goals
|
4a3884f9aa9180f8
|
Nat.mod_def
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Div/Basic.lean
|
theorem mod_def (m k : Nat) : m % k = m - k * (m / k)
|
m k : Nat
⊢ m % k = m - k * (m / k)
|
rw [Nat.sub_eq_of_eq_add]
|
m k : Nat
⊢ m = m % k + k * (m / k)
|
f10f5dd1b2641e77
|
PrimeSpectrum.existsUnique_idempotent_basicOpen_eq_of_isClopen
|
Mathlib/RingTheory/Spectrum/Prime/Topology.lean
|
@[stacks 00EE]
lemma existsUnique_idempotent_basicOpen_eq_of_isClopen {s : Set (PrimeSpectrum R)}
(hs : IsClopen s) : ∃! e : R, IsIdempotentElem e ∧ s = basicOpen e
|
case refine_1.inr.intro.intro.intro.intro.intro.intro.intro.intro.intro
R : Type u
inst✝ : CommSemiring R
s : Set (PrimeSpectrum R)
hs : IsClopen s
h✝ : Nontrivial R
I : Ideal R
hI : I.FG
J : Ideal R
hJ : J.FG
hI' : zeroLocus ↑I = sᶜ
hJ' : zeroLocus ↑J = s
this : I * J ≤ nilradical R
n : ℕ
hn : I ^ n * J ^ n ≤ ⊥
hnz : n ≠ 0
x : R
hx : x ∈ I ^ n
y : R
hy : y ∈ J ^ n
e : x + y = 1
⊢ ∃ x, IsIdempotentElem x ∧ s = ↑(basicOpen x)
|
refine ⟨x, ?_, subset_antisymm ?_ ?_⟩
|
case refine_1.inr.intro.intro.intro.intro.intro.intro.intro.intro.intro.refine_1
R : Type u
inst✝ : CommSemiring R
s : Set (PrimeSpectrum R)
hs : IsClopen s
h✝ : Nontrivial R
I : Ideal R
hI : I.FG
J : Ideal R
hJ : J.FG
hI' : zeroLocus ↑I = sᶜ
hJ' : zeroLocus ↑J = s
this : I * J ≤ nilradical R
n : ℕ
hn : I ^ n * J ^ n ≤ ⊥
hnz : n ≠ 0
x : R
hx : x ∈ I ^ n
y : R
hy : y ∈ J ^ n
e : x + y = 1
⊢ IsIdempotentElem x
case refine_1.inr.intro.intro.intro.intro.intro.intro.intro.intro.intro.refine_2
R : Type u
inst✝ : CommSemiring R
s : Set (PrimeSpectrum R)
hs : IsClopen s
h✝ : Nontrivial R
I : Ideal R
hI : I.FG
J : Ideal R
hJ : J.FG
hI' : zeroLocus ↑I = sᶜ
hJ' : zeroLocus ↑J = s
this : I * J ≤ nilradical R
n : ℕ
hn : I ^ n * J ^ n ≤ ⊥
hnz : n ≠ 0
x : R
hx : x ∈ I ^ n
y : R
hy : y ∈ J ^ n
e : x + y = 1
⊢ s ⊆ ↑(basicOpen x)
case refine_1.inr.intro.intro.intro.intro.intro.intro.intro.intro.intro.refine_3
R : Type u
inst✝ : CommSemiring R
s : Set (PrimeSpectrum R)
hs : IsClopen s
h✝ : Nontrivial R
I : Ideal R
hI : I.FG
J : Ideal R
hJ : J.FG
hI' : zeroLocus ↑I = sᶜ
hJ' : zeroLocus ↑J = s
this : I * J ≤ nilradical R
n : ℕ
hn : I ^ n * J ^ n ≤ ⊥
hnz : n ≠ 0
x : R
hx : x ∈ I ^ n
y : R
hy : y ∈ J ^ n
e : x + y = 1
⊢ ↑(basicOpen x) ⊆ s
|
f72a236e53847d1c
|
BitVec.DivModState.umod_eq_of_lawful
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
|
theorem DivModState.umod_eq_of_lawful {qr : DivModState w}
(h : DivModState.Lawful {n, d} qr)
(h_final : qr.wn = 0) :
n % d = qr.r
|
w : Nat
n d : BitVec w
qr : DivModState w
h : Lawful { n := n, d := d } qr
h_final✝ : qr.wn = 0
h_final : True
hdiv : n.toNat >>> 0 = d.toNat * qr.q.toNat + qr.r.toNat
⊢ d.toNat * BitVec.toNat ?m.63092 + qr.r.toNat = n.toNat
w : Nat
n d : BitVec w
qr : DivModState w
h : Lawful { n := n, d := d } qr
h_final : qr.wn = 0
⊢ BitVec w
|
exact hdiv.symm
|
no goals
|
0b594396734385e1
|
Multiset.sub_add_eq_sub_sub
|
Mathlib/Data/Multiset/AddSub.lean
|
protected lemma sub_add_eq_sub_sub : s - (t + u) = s - t - u
|
case a
α : Type u_1
inst✝ : DecidableEq α
s t u : Multiset α
a✝ : α
⊢ count a✝ (s - (t + u)) = count a✝ (s - t - u)
|
simp [Nat.sub_add_eq]
|
no goals
|
f6dd2d36c336bc75
|
MulAction.movedBy_mem_fixedBy_of_commute
|
Mathlib/GroupTheory/GroupAction/FixedPoints.lean
|
theorem movedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
(fixedBy α g)ᶜ ∈ fixedBy (Set α) h
|
α : Type u_1
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
g h : G
comm : Commute g h
⊢ (fixedBy α g)ᶜ ∈ fixedBy (Set α) h
|
rw [mem_fixedBy, Set.smul_set_compl, fixedBy_mem_fixedBy_of_commute comm]
|
no goals
|
94f70af15c35631c
|
Ideal.Quotient.index_eq_zero
|
Mathlib/Algebra/CharP/Quotient.lean
|
theorem Ideal.Quotient.index_eq_zero {R : Type*} [CommRing R] (I : Ideal R) :
(↑I.toAddSubgroup.index : R ⧸ I) = 0
|
R : Type u_1
inst✝ : CommRing R
I : Ideal R
⊢ ↑(if x : Finite (R ⧸ Submodule.toAddSubgroup I) then Fintype.card (R ⧸ Submodule.toAddSubgroup I) else 0) = 0
|
split_ifs with hq
|
case pos
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : Finite (R ⧸ Submodule.toAddSubgroup I)
⊢ ↑(Fintype.card (R ⧸ Submodule.toAddSubgroup I)) = 0
case neg
R : Type u_1
inst✝ : CommRing R
I : Ideal R
hq : ¬Finite (R ⧸ Submodule.toAddSubgroup I)
⊢ ↑0 = 0
|
64a79a192da7e338
|
Dioph.ex_dioph
|
Mathlib/NumberTheory/Dioph.lean
|
theorem ex_dioph {S : Set (α ⊕ β → ℕ)} : Dioph S → Dioph {v | ∃ x, v ⊗ x ∈ S}
| ⟨γ, p, pe⟩ =>
⟨β ⊕ γ, p.map ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr), fun v =>
⟨fun ⟨x, hx⟩ =>
let ⟨t, ht⟩ := (pe _).1 hx
⟨x ⊗ t, by
simp; rw [show (v ⊗ x ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr) = (v ⊗ x) ⊗ t from
funext fun s => by rcases s with a | b <;> try { cases a <;> rfl }; rfl]
exact ht⟩,
fun ⟨t, ht⟩ =>
⟨t ∘ inl,
(pe _).2
⟨t ∘ inr, by
simp only [Poly.map_apply] at ht
rwa [show (v ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr) = (v ⊗ t ∘ inl) ⊗ t ∘ inr from
funext fun s => by rcases s with a | b <;> try { cases a <;> rfl }; rfl] at ht⟩⟩⟩⟩
|
case inr
α β : Type u
S : Set (α ⊕ β → ℕ)
γ : Type u
p : Poly ((α ⊕ β) ⊕ γ)
pe : ∀ (v : α ⊕ β → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
v : α → ℕ
x✝ : {v | ∃ x, v ⊗ x ∈ S} v
x : β → ℕ
hx : v ⊗ x ∈ S
t : γ → ℕ
ht : p ((v ⊗ x) ⊗ t) = 0
b : γ
⊢ ((v ⊗ x ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr)) (inr b) = ((v ⊗ x) ⊗ t) (inr b)
|
rfl
|
no goals
|
c388e394bd185bab
|
t2Space_of_properSMul_of_t2Group
|
Mathlib/Topology/Algebra/ProperAction/Basic.lean
|
theorem t2Space_of_properSMul_of_t2Group [h_proper : ProperSMul G X] [T2Space G] : T2Space X
|
case refine_2
G : Type u_1
X : Type u_2
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalSpace X
h_proper : ProperSMul G X
inst✝ : T2Space G
f : X → G × X := fun x => (1, x)
this : range f = {1} ×ˢ univ
⊢ IsClosed (range f)
|
rw [this]
|
case refine_2
G : Type u_1
X : Type u_2
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalSpace X
h_proper : ProperSMul G X
inst✝ : T2Space G
f : X → G × X := fun x => (1, x)
this : range f = {1} ×ˢ univ
⊢ IsClosed ({1} ×ˢ univ)
|
e99ce87ed540aaac
|
Std.Tactic.BVDecide.BVExpr.bitblast.go_decl_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.lean
|
theorem bitblast.go_decl_eq (aig : AIG BVBit) (expr : BVExpr w) :
∀ (idx : Nat) (h1) (h2), (go aig expr).val.aig.decls[idx]'h2 = aig.decls[idx]'h1
|
case shiftRight
w idx m✝ n✝ : Nat
lhs : BVExpr m✝
rhs : BVExpr n✝
lih :
∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
(go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
(go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.shiftRight rhs)).val.aig.decls.size
⊢ (blastShiftRight (go (go aig lhs).1.aig rhs).1.aig
{ n := n✝, target := (go aig lhs).1.vec.cast ⋯,
distance := (go (go aig lhs).1.aig rhs).1.vec }).aig.decls[idx] =
aig.decls[idx]
|
have := (bitblast.go aig lhs).property
|
case shiftRight
w idx m✝ n✝ : Nat
lhs : BVExpr m✝
rhs : BVExpr n✝
lih :
∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
(go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
(go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.shiftRight rhs)).val.aig.decls.size
this : aig.decls.size ≤ (go aig lhs).val.aig.decls.size
⊢ (blastShiftRight (go (go aig lhs).1.aig rhs).1.aig
{ n := n✝, target := (go aig lhs).1.vec.cast ⋯,
distance := (go (go aig lhs).1.aig rhs).1.vec }).aig.decls[idx] =
aig.decls[idx]
|
f92988d5a1595b39
|
ProbabilityTheory.iteratedDeriv_two_cgf
|
Mathlib/Probability/Moments/MGFAnalytic.lean
|
lemma iteratedDeriv_two_cgf (h : v ∈ interior (integrableExpSet X μ)) :
iteratedDeriv 2 (cgf X μ) v
= μ[fun ω ↦ (X ω)^2 * exp (v * X ω)] / mgf X μ v - deriv (cgf X μ) v ^ 2
|
case e_a
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
v : ℝ
h : v ∈ interior (integrableExpSet X μ)
hμ : ¬μ = 0
h_mem : ∀ᶠ (y : ℝ) in 𝓝 v, y ∈ interior (integrableExpSet X μ)
h_d_cgf : deriv (cgf X μ) =ᶠ[𝓝 v] fun u => (∫ (x : Ω), (fun ω => X ω * rexp (u * X ω)) x ∂μ) / mgf X μ u
h_d_mgf : deriv (mgf X μ) =ᶠ[𝓝 v] fun u => ∫ (x : Ω), (fun ω => X ω * rexp (u * X ω)) x ∂μ
⊢ mgf X μ v ≠ 0
|
exact (mgf_pos' hμ (interior_subset (s := integrableExpSet X μ) h)).ne'
|
no goals
|
24002d4e2edb89d3
|
MeasureTheory.upcrossings_lt_top_iff
|
Mathlib/Probability/Martingale/Upcrossing.lean
|
theorem upcrossings_lt_top_iff :
upcrossings a b f ω < ∞ ↔ ∃ k, ∀ N, upcrossingsBefore a b f N ω ≤ k
|
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
this : upcrossings a b f ω < ⊤ ↔ ∃ k, upcrossings a b f ω ≤ ↑k
⊢ (∃ k, ∀ (i : ℕ), ↑(upcrossingsBefore a b f i ω) ≤ ↑k) ↔ ∃ k, ∀ (N : ℕ), upcrossingsBefore a b f N ω ≤ k
|
constructor <;> rintro ⟨k, hk⟩
|
case mp.intro
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
this : upcrossings a b f ω < ⊤ ↔ ∃ k, upcrossings a b f ω ≤ ↑k
k : ℝ≥0
hk : ∀ (i : ℕ), ↑(upcrossingsBefore a b f i ω) ≤ ↑k
⊢ ∃ k, ∀ (N : ℕ), upcrossingsBefore a b f N ω ≤ k
case mpr.intro
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
this : upcrossings a b f ω < ⊤ ↔ ∃ k, upcrossings a b f ω ≤ ↑k
k : ℕ
hk : ∀ (N : ℕ), upcrossingsBefore a b f N ω ≤ k
⊢ ∃ k, ∀ (i : ℕ), ↑(upcrossingsBefore a b f i ω) ≤ ↑k
|
ad04e390c118cf1b
|
LiouvilleWith.add_rat
|
Mathlib/NumberTheory/Transcendental/Liouville/LiouvilleWith.lean
|
theorem add_rat (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (x + r)
|
case intro.intro.intro.intro.intro
p x : ℝ
h : LiouvilleWith p x
r : ℚ
C : ℝ
_hC₀ : 0 < C
hC : ∃ᶠ (n : ℕ) in atTop, 1 ≤ n ∧ ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < C / ↑n ^ p
n : ℕ
hn : 1 ≤ n
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : |x - ↑m / ↑n| < C / ↑n ^ p
⊢ ∃ m, x + ↑r ≠ ↑m / ↑(r.den • id n) ∧ |x + ↑r - ↑m / ↑(r.den • id n)| < ↑r.den ^ p * C / ↑(r.den • id n) ^ p
|
have : (↑(r.den * m + r.num * n : ℤ) / ↑(r.den • id n) : ℝ) = m / n + r := by
rw [Algebra.id.smul_eq_mul, id]
nth_rewrite 4 [← Rat.num_div_den r]
push_cast
rw [add_div, mul_div_mul_left _ _ (by positivity), mul_div_mul_right _ _ (by positivity)]
|
case intro.intro.intro.intro.intro
p x : ℝ
h : LiouvilleWith p x
r : ℚ
C : ℝ
_hC₀ : 0 < C
hC : ∃ᶠ (n : ℕ) in atTop, 1 ≤ n ∧ ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < C / ↑n ^ p
n : ℕ
hn : 1 ≤ n
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : |x - ↑m / ↑n| < C / ↑n ^ p
this : ↑(↑r.den * m + r.num * ↑n) / ↑(r.den • id n) = ↑m / ↑n + ↑r
⊢ ∃ m, x + ↑r ≠ ↑m / ↑(r.den • id n) ∧ |x + ↑r - ↑m / ↑(r.den • id n)| < ↑r.den ^ p * C / ↑(r.den • id n) ^ p
|
7652465b354d5b90
|
NNRat.addSubmonoid_closure_range_pow
|
Mathlib/Data/Rat/Star.lean
|
@[simp] lemma addSubmonoid_closure_range_pow {n : ℕ} (hn₀ : n ≠ 0) :
closure (range fun x : ℚ≥0 ↦ x ^ n) = ⊤
|
n : ℕ
hn₀ : n ≠ 0
x : ℚ≥0
⊢ x = (x.num * x.den ^ (n - 1)) • (↑x.den)⁻¹ ^ n
|
rw [nsmul_eq_mul]
|
n : ℕ
hn₀ : n ≠ 0
x : ℚ≥0
⊢ x = ↑(x.num * x.den ^ (n - 1)) * (↑x.den)⁻¹ ^ n
|
7fc9ce8a3377d839
|
Bimod.TensorBimod.left_assoc'
|
Mathlib/CategoryTheory/Monoidal/Bimod.lean
|
theorem left_assoc' :
(R.mul ▷ _) ≫ actLeft P Q = (α_ R.X R.X _).hom ≫ (R.X ◁ actLeft P Q) ≫ actLeft P Q
|
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
inst✝¹ : HasCoequalizers C
R S T : Mon_ C
P : Bimod R S
Q : Bimod S T
inst✝ : ∀ (X : C), PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
⊢ (α_ (R.X ⊗ R.X) P.X Q.X).inv ≫
((α_ R.X R.X P.X).hom ▷ Q.X ≫ (R.X ◁ P.actLeft) ▷ Q.X ≫ P.actLeft ▷ Q.X) ≫
coequalizer.π (P.actRight ▷ Q.X) ((α_ P.X S.X Q.X).hom ≫ P.X ◁ Q.actLeft) =
(α_ R.X R.X (P.X ⊗ Q.X)).hom ≫
R.X ◁ (α_ R.X P.X Q.X).inv ≫
(((α_ R.X (R.X ⊗ P.X) Q.X).inv ≫ (R.X ◁ P.actLeft) ▷ Q.X) ≫ P.actLeft ▷ Q.X) ≫
coequalizer.π (P.actRight ▷ Q.X) ((α_ P.X S.X Q.X).hom ≫ P.X ◁ Q.actLeft)
|
monoidal
|
no goals
|
bad1b93937126f5d
|
ENNReal.lintegral_mul_le_one_of_lintegral_rpow_eq_one
|
Mathlib/MeasureTheory/Integral/MeanInequalities.lean
|
theorem lintegral_mul_le_one_of_lintegral_rpow_eq_one {p q : ℝ} (hpq : p.IsConjExponent q)
{f g : α → ℝ≥0∞} (hf : AEMeasurable f μ) (hf_norm : ∫⁻ a, f a ^ p ∂μ = 1)
(hg_norm : ∫⁻ a, g a ^ q ∂μ = 1) : (∫⁻ a, (f * g) a ∂μ) ≤ 1
|
case hf
α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p q : ℝ
hpq : p.IsConjExponent q
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_norm : ∫⁻ (a : α), f a ^ p ∂μ = 1
hg_norm : ∫⁻ (a : α), g a ^ q ∂μ = 1
⊢ AEMeasurable (fun a => f a ^ p * (ENNReal.ofReal p)⁻¹) μ
|
exact (hf.pow_const _).mul_const _
|
no goals
|
bea204bbfdd8c8d8
|
Algebra.pow_smul_mem_of_smul_subset_of_mem_adjoin
|
Mathlib/RingTheory/Adjoin/Basic.lean
|
theorem pow_smul_mem_of_smul_subset_of_mem_adjoin [CommSemiring B] [Algebra R B] [Algebra A B]
[IsScalarTower R A B] (r : A) (s : Set B) (B' : Subalgebra R B) (hs : r • s ⊆ B') {x : B}
(hx : x ∈ adjoin R s) (hr : algebraMap A B r ∈ B') : ∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ B'
|
R : Type uR
A : Type uA
B : Type uB
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : Algebra R A
inst✝³ : CommSemiring B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
r : A
s : Set B
B' : Subalgebra R B
hs : r • s ⊆ ↑B'
hr : (algebraMap A B) r ∈ B'
l : ↑↑(Submonoid.closure s) →₀ R
n₁ : ↥(Submonoid.closure s) → ℕ
n₂ : ∀ (x : ↥(Submonoid.closure s)), r ^ n₁ x • ↑x ∈ Submonoid.closure (r • s)
n : ℕ
hn : n ≥ l.support.sup n₁
a : ↑↑(Submonoid.closure s)
ha : a ∈ l.support
this : n ≥ n₁ a
⊢ r ^ n₁ a • ↑a ∈ Submonoid.closure ↑B'.toSubmonoid
|
apply Submonoid.closure_mono hs (n₂ a)
|
no goals
|
c0ccc6b7c63e5bab
|
Array.flatMap_mkArray
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem flatMap_mkArray {β} (f : α → Array β) : (mkArray n a).flatMap f = (mkArray n (f a)).flatten
|
α : Type u_1
n : Nat
a : α
β : Type u_2
f : α → Array β
⊢ flatMap f (mkArray n a) = (mkArray n (f a)).flatten
|
rw [← toList_inj]
|
α : Type u_1
n : Nat
a : α
β : Type u_2
f : α → Array β
⊢ (flatMap f (mkArray n a)).toList = (mkArray n (f a)).flatten.toList
|
3ca0b1f8e526e2cc
|
List.Chain.rel
|
Mathlib/Data/List/Chain.lean
|
theorem Chain.rel [IsTrans α R] (hl : l.Chain R a) (hb : b ∈ l) : R a b
|
α : Type u
R : α → α → Prop
l : List α
a b : α
inst✝ : IsTrans α R
hl : Pairwise R (a :: l)
hb : b ∈ l
⊢ R a b
|
exact rel_of_pairwise_cons hl hb
|
no goals
|
72301b273c3b93a5
|
Matrix.Pivot.exists_list_transvec_mul_mul_list_transvec_eq_diagonal_induction
|
Mathlib/LinearAlgebra/Matrix/Transvection.lean
|
theorem exists_list_transvec_mul_mul_list_transvec_eq_diagonal_induction
(IH :
∀ M : Matrix (Fin r) (Fin r) 𝕜,
∃ (L₀ L₀' : List (TransvectionStruct (Fin r) 𝕜)) (D₀ : Fin r → 𝕜),
(L₀.map toMatrix).prod * M * (L₀'.map toMatrix).prod = diagonal D₀)
(M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜) :
∃ (L L' : List (TransvectionStruct (Fin r ⊕ Unit) 𝕜)) (D : Fin r ⊕ Unit → 𝕜),
(L.map toMatrix).prod * M * (L'.map toMatrix).prod = diagonal D
|
𝕜 : Type u_3
inst✝ : Field 𝕜
r : ℕ
IH :
∀ (M : Matrix (Fin r) (Fin r) 𝕜),
∃ L₀ L₀' D₀, (List.map toMatrix L₀).prod * M * (List.map toMatrix L₀').prod = diagonal D₀
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
L₁ L₁' : List (TransvectionStruct (Fin r ⊕ Unit) 𝕜)
hM : ((List.map toMatrix L₁).prod * M * (List.map toMatrix L₁').prod).IsTwoBlockDiagonal
M' : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜 := (List.map toMatrix L₁).prod * M * (List.map toMatrix L₁').prod
M'' : Matrix (Fin r) (Fin r) 𝕜 := M'.toBlocks₁₁
L₀ L₀' : List (TransvectionStruct (Fin r) 𝕜)
D₀ : Fin r → 𝕜
h₀ : (List.map toMatrix L₀).prod * M'' * (List.map toMatrix L₀').prod = diagonal D₀
c : 𝕜 := M' (inr ()) (inr ())
this :
(List.map (toMatrix ∘ sumInl Unit) L₀).prod * M' * (List.map (toMatrix ∘ sumInl Unit) L₀').prod =
diagonal (Sum.elim D₀ fun x => c)
⊢ (List.map toMatrix (List.map (sumInl Unit) L₀ ++ L₁)).prod * M *
(List.map toMatrix (L₁' ++ List.map (sumInl Unit) L₀')).prod =
diagonal (Sum.elim D₀ fun x => M' (inr ()) (inr ()))
|
simpa [M', c, Matrix.mul_assoc]
|
no goals
|
1db945989babbcf8
|
Polynomial.coeff_divByMonic_X_sub_C
|
Mathlib/Algebra/Polynomial/Div.lean
|
theorem coeff_divByMonic_X_sub_C (p : R[X]) (a : R) (n : ℕ) :
(p /ₘ (X - C a)).coeff n = ∑ i ∈ Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i
|
case inr
R : Type u
inst✝ : Ring R
p : R[X]
a : R
n : ℕ
this :
∀ (n : ℕ), p.natDegree ≤ n → (p /ₘ (X - C a)).coeff n = ∑ i ∈ Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i
h : ¬p.natDegree ≤ n
⊢ (p /ₘ (X - C a)).coeff n = ∑ i ∈ Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i
|
refine Nat.decreasingInduction' (fun n hn _ ih ↦ ?_) (le_of_not_le h) ?_
|
case inr.refine_1
R : Type u
inst✝ : Ring R
p : R[X]
a : R
n✝ : ℕ
this :
∀ (n : ℕ), p.natDegree ≤ n → (p /ₘ (X - C a)).coeff n = ∑ i ∈ Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i
h : ¬p.natDegree ≤ n✝
n : ℕ
hn : n < p.natDegree
x✝ : n✝ ≤ n
ih : (p /ₘ (X - C a)).coeff (n + 1) = ∑ i ∈ Icc (n + 1 + 1) p.natDegree, a ^ (i - (n + 1 + 1)) * p.coeff i
⊢ (p /ₘ (X - C a)).coeff n = ∑ i ∈ Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i
case inr.refine_2
R : Type u
inst✝ : Ring R
p : R[X]
a : R
n : ℕ
this :
∀ (n : ℕ), p.natDegree ≤ n → (p /ₘ (X - C a)).coeff n = ∑ i ∈ Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i
h : ¬p.natDegree ≤ n
⊢ (p /ₘ (X - C a)).coeff p.natDegree = ∑ i ∈ Icc (p.natDegree + 1) p.natDegree, a ^ (i - (p.natDegree + 1)) * p.coeff i
|
b5156308e39e2482
|
Ordnode.Valid'.map_aux
|
Mathlib/Data/Ordmap/Ordset.lean
|
theorem Valid'.map_aux {β} [Preorder β] {f : α → β} (f_strict_mono : StrictMono f) {t a₁ a₂}
(h : Valid' a₁ t a₂) :
Valid' (Option.map f a₁) (map f t) (Option.map f a₂) ∧ (map f t).size = t.size
|
case node.intro.intro.sz.left
α : Type u_1
inst✝¹ : Preorder α
β : Type u_2
inst✝ : Preorder β
f : α → β
f_strict_mono : StrictMono f
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
a₁ : WithBot α
a₂ : WithTop α
h : Valid' a₁ (Ordnode.node size✝ l✝ x✝ r✝) a₂
t_l_valid : Valid' (Option.map f a₁) (map f l✝) (Option.map f ↑x✝)
t_l_size : (map f l✝).size = l✝.size
t_r_valid : Valid' (Option.map f ↑x✝) (map f r✝) (Option.map f a₂)
t_r_size : (map f r✝).size = r✝.size
⊢ size✝ = (map f l✝).size + (map f r✝).size + 1
|
rw [t_l_size, t_r_size]
|
case node.intro.intro.sz.left
α : Type u_1
inst✝¹ : Preorder α
β : Type u_2
inst✝ : Preorder β
f : α → β
f_strict_mono : StrictMono f
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
a₁ : WithBot α
a₂ : WithTop α
h : Valid' a₁ (Ordnode.node size✝ l✝ x✝ r✝) a₂
t_l_valid : Valid' (Option.map f a₁) (map f l✝) (Option.map f ↑x✝)
t_l_size : (map f l✝).size = l✝.size
t_r_valid : Valid' (Option.map f ↑x✝) (map f r✝) (Option.map f a₂)
t_r_size : (map f r✝).size = r✝.size
⊢ size✝ = l✝.size + r✝.size + 1
|
ff36f5e3d5092df5
|
PiTensorProduct.lifts_add
|
Mathlib/LinearAlgebra/PiTensorProduct.lean
|
/-- If elements `p,q` of `FreeAddMonoid (R × Π i, s i)` lift elements `x,y` of `⨂[R] i, s i`
respectively, then `p + q` lifts `x + y`.
-/
lemma lifts_add {x y : ⨂[R] i, s i} {p q : FreeAddMonoid (R × Π i, s i)}
(hp : p ∈ lifts x) (hq : q ∈ lifts y) : p + q ∈ lifts (x + y)
|
ι : Type u_1
R : Type u_4
inst✝² : CommSemiring R
s : ι → Type u_7
inst✝¹ : (i : ι) → AddCommMonoid (s i)
inst✝ : (i : ι) → Module R (s i)
x y : ⨂[R] (i : ι), s i
p q : FreeAddMonoid (R × ((i : ι) → s i))
hp : p ∈ x.lifts
hq : q ∈ y.lifts
⊢ ↑p + ↑q = x + y
|
rw [hp, hq]
|
no goals
|
d4629aec80161898
|
FreeAlgebra.adjoin_range_ι
|
Mathlib/Algebra/FreeAlgebra.lean
|
theorem adjoin_range_ι : Algebra.adjoin R (Set.range (ι R : X → FreeAlgebra R X)) = ⊤
|
case h_add
R : Type u_1
inst✝ : CommSemiring R
X : Type u_2
S : Subalgebra R (FreeAlgebra R X) := Algebra.adjoin R (Set.range (ι R))
x y : FreeAlgebra R X
hx : x ∈ S
hy : y ∈ S
⊢ x + y ∈ S
|
exact S.add_mem hx hy
|
no goals
|
cec84737beae3660
|
AffineSubspace.direction_mk'
|
Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Defs.lean
|
theorem direction_mk' (p : P) (direction : Submodule k V) :
(mk' p direction).direction = direction
|
case h.mp.intro.intro.intro.intro.intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : P
direction : Submodule k V
v : V
p₁ : P
v₁ : V
hv₁ : v₁ ∈ direction
hp₁ : p₁ = v₁ +ᵥ p
p₂ : P
hv : v = p₁ -ᵥ p₂
v₂ : V
hv₂ : v₂ ∈ direction
hp₂ : p₂ = v₂ +ᵥ p
⊢ v ∈ direction
|
rw [hv, hp₁, hp₂, vadd_vsub_vadd_cancel_right]
|
case h.mp.intro.intro.intro.intro.intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : P
direction : Submodule k V
v : V
p₁ : P
v₁ : V
hv₁ : v₁ ∈ direction
hp₁ : p₁ = v₁ +ᵥ p
p₂ : P
hv : v = p₁ -ᵥ p₂
v₂ : V
hv₂ : v₂ ∈ direction
hp₂ : p₂ = v₂ +ᵥ p
⊢ v₁ - v₂ ∈ direction
|
4871a469895a4a3c
|
zpow_right_anti₀
|
Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
|
lemma zpow_right_anti₀ (ha₀ : 0 < a) (ha₁ : a ≤ 1) : Antitone fun n : ℤ ↦ a ^ n
|
G₀ : Type u_2
inst✝⁴ : GroupWithZero G₀
inst✝³ : PartialOrder G₀
inst✝² : ZeroLEOneClass G₀
inst✝¹ : PosMulReflectLT G₀
a : G₀
inst✝ : PosMulMono G₀
ha₀ : 0 < a
ha₁ : a ≤ 1
n : ℤ
⊢ a ^ n * a ≤ a ^ n
|
exact mul_le_of_le_one_right (zpow_nonneg ha₀.le _) ha₁
|
no goals
|
0b4c6dc9e11e8a54
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_invariant_helper
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.lean
|
theorem confirmRupHint_preserves_invariant_helper {n : Nat} (f : DefaultFormula n)
(f_assignments_size : f.assignments.size = n)
(acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool) (hsize : acc.1.size = n)
(l : Literal (PosFin n)) (ih : DerivedLitsInvariant f f_assignments_size acc.1 hsize acc.2.1)
(h : ¬hasAssignment l.snd acc.fst[l.fst.val]! = true) :
have hsize' : (Array.modify acc.1 l.1.1 (addAssignment l.snd)).size = n
|
case isTrue
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool
hsize : acc.fst.size = n
l : Literal (PosFin n)
ih : f.DerivedLitsInvariant f_assignments_size acc.fst hsize acc.snd.fst
hsize'✝ : (acc.fst.modify l.fst.val (addAssignment l.snd)).size = n :=
Eq.mpr (id (congrArg (fun _a => _a = n) (Array.size_modify acc.fst l.fst.val (addAssignment l.snd)))) hsize
i : Fin n
i_in_bounds : ↑i < acc.fst.size
l_in_bounds : l.fst.val < acc.fst.size
j1 j2 : Fin (List.length acc.snd.fst)
j1_eq_i : (List.get acc.snd.fst j1).fst.val = ↑i
j2_eq_i : (List.get acc.snd.fst j2).fst.val = ↑i
j1_eq_true : (List.get acc.snd.fst j1).snd = true
j2_eq_false : (List.get acc.snd.fst j2).snd = false
h1 : acc.fst[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin (List.length acc.snd.fst)), k ≠ j1 → k ≠ j2 → (List.get acc.snd.fst k).fst.val ≠ ↑i
j1_succ_in_bounds : ↑j1 + 1 < (l :: acc.snd.fst).length
j2_succ_in_bounds : ↑j2 + 1 < (l :: acc.snd.fst).length
j1_succ : Fin (l :: acc.snd.fst).length := ⟨↑j1 + 1, j1_succ_in_bounds⟩
j2_succ : Fin (l :: acc.snd.fst).length := ⟨↑j2 + 1, j2_succ_in_bounds⟩
l_eq_i : l.fst.val = ↑i
h✝ : l.snd = true
h : acc.fst[l.fst.val]!.hasPosAssignment = false
⊢ False
case isFalse
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool
hsize : acc.fst.size = n
l : Literal (PosFin n)
ih : f.DerivedLitsInvariant f_assignments_size acc.fst hsize acc.snd.fst
hsize'✝ : (acc.fst.modify l.fst.val (addAssignment l.snd)).size = n :=
Eq.mpr (id (congrArg (fun _a => _a = n) (Array.size_modify acc.fst l.fst.val (addAssignment l.snd)))) hsize
i : Fin n
i_in_bounds : ↑i < acc.fst.size
l_in_bounds : l.fst.val < acc.fst.size
j1 j2 : Fin (List.length acc.snd.fst)
j1_eq_i : (List.get acc.snd.fst j1).fst.val = ↑i
j2_eq_i : (List.get acc.snd.fst j2).fst.val = ↑i
j1_eq_true : (List.get acc.snd.fst j1).snd = true
j2_eq_false : (List.get acc.snd.fst j2).snd = false
h1 : acc.fst[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin (List.length acc.snd.fst)), k ≠ j1 → k ≠ j2 → (List.get acc.snd.fst k).fst.val ≠ ↑i
j1_succ_in_bounds : ↑j1 + 1 < (l :: acc.snd.fst).length
j2_succ_in_bounds : ↑j2 + 1 < (l :: acc.snd.fst).length
j1_succ : Fin (l :: acc.snd.fst).length := ⟨↑j1 + 1, j1_succ_in_bounds⟩
j2_succ : Fin (l :: acc.snd.fst).length := ⟨↑j2 + 1, j2_succ_in_bounds⟩
l_eq_i : l.fst.val = ↑i
h✝ : ¬l.snd = true
h : acc.fst[l.fst.val]!.hasNegAssignment = false
⊢ False
|
all_goals
simp +decide [getElem!, l_eq_i, i_in_bounds, h1, decidableGetElem?] at h
|
no goals
|
02ca1706b397b254
|
maximalIdeal_isPrincipal_of_isDedekindDomain
|
Mathlib/RingTheory/DiscreteValuationRing/TFAE.lean
|
theorem maximalIdeal_isPrincipal_of_isDedekindDomain [IsLocalRing R] [IsDomain R]
[IsDedekindDomain R] : (maximalIdeal R).IsPrincipal
|
case pos
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsLocalRing R
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
ne_bot : maximalIdeal R = ⊥
⊢ Submodule.IsPrincipal ⊥
|
infer_instance
|
no goals
|
e801db6f819d1797
|
SimpleGraph.triangle_split_helper
|
Mathlib/Combinatorics/SimpleGraph/Triangle/Counting.lean
|
/-- A subset of the triangles constructed in a weird way to make them easy to count. -/
private lemma triangle_split_helper [DecidableEq α] :
(s \ (badVertices G ε s t ∪ badVertices G ε s u)).biUnion
(fun x ↦ (G.interedges {y ∈ t | G.Adj x y} {y ∈ u | G.Adj x y}).image (x, ·)) ⊆
(s ×ˢ t ×ˢ u).filter (fun (x, y, z) ↦ G.Adj x y ∧ G.Adj x z ∧ G.Adj y z)
|
case mk.mk
α : Type u_1
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
s t u : Finset α
inst✝ : DecidableEq α
x : α
hx : x ∈ s
y z : α
hy : y ∈ t
xy : G.Adj x y
hz : z ∈ u
xz : G.Adj x z
yz : G.Adj y z
⊢ x ∈ s ∧ y ∈ t ∧ z ∈ u ∧ G.Adj x y ∧ G.Adj x z ∧ G.Adj y z
|
exact ⟨hx, hy, hz, xy, xz, yz⟩
|
no goals
|
a4679bcedf9587ce
|
ProfiniteGrp.denseRange_toLimit
|
Mathlib/Topology/Algebra/Category/ProfiniteGrp/Limits.lean
|
theorem denseRange_toLimit (P : ProfiniteGrp.{u}) : DenseRange (toLimit P)
|
case h
P : ProfiniteGrp.{u}
U : Set ↑(limit (P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u})).toProfinite.toTop
s :
Set
((j : OpenNormalSubgroup ↑P.toProfinite.toTop) →
↑((P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u}).obj j).toProfinite.toTop)
hsO : IsOpen s
hsv : Subtype.val ⁻¹' s = U
spc :
(j : OpenNormalSubgroup ↑P.toProfinite.toTop) →
↑((P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u}).obj j).toProfinite.toTop
hspc : spc ∈ limitConePtAux (P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u})
uDefaultSpec : spc ∈ s
J : Finset (OpenNormalSubgroup ↑P.toProfinite.toTop)
fJ :
(a : OpenNormalSubgroup ↑P.toProfinite.toTop) →
Set ↑((P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u}).obj a).toProfinite.toTop
hJ1 : ∀ a ∈ J, IsOpen (fJ a) ∧ spc a ∈ fJ a
hJ2 : (↑J).pi fJ ⊆ s
M : Subgroup ↑P.toProfinite.toTop := ⨅ j, ↑(↑j).toOpenSubgroup
hM : M.Normal
hMOpen : IsOpen ↑M
m : OpenNormalSubgroup ↑P.toProfinite.toTop := { toSubgroup := M, isOpen' := hMOpen, isNormal' := ⋯ }
origin : ↑P.toProfinite.toTop
horigin : (QuotientGroup.mk' M) origin = spc m
⊢ (Hom.hom P.toLimit) origin ∈ Subtype.val ⁻¹' s
|
apply hJ2
|
case h.a
P : ProfiniteGrp.{u}
U : Set ↑(limit (P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u})).toProfinite.toTop
s :
Set
((j : OpenNormalSubgroup ↑P.toProfinite.toTop) →
↑((P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u}).obj j).toProfinite.toTop)
hsO : IsOpen s
hsv : Subtype.val ⁻¹' s = U
spc :
(j : OpenNormalSubgroup ↑P.toProfinite.toTop) →
↑((P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u}).obj j).toProfinite.toTop
hspc : spc ∈ limitConePtAux (P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u})
uDefaultSpec : spc ∈ s
J : Finset (OpenNormalSubgroup ↑P.toProfinite.toTop)
fJ :
(a : OpenNormalSubgroup ↑P.toProfinite.toTop) →
Set ↑((P.toFiniteQuotientFunctor ⋙ forget₂ FiniteGrp.{u} ProfiniteGrp.{u}).obj a).toProfinite.toTop
hJ1 : ∀ a ∈ J, IsOpen (fJ a) ∧ spc a ∈ fJ a
hJ2 : (↑J).pi fJ ⊆ s
M : Subgroup ↑P.toProfinite.toTop := ⨅ j, ↑(↑j).toOpenSubgroup
hM : M.Normal
hMOpen : IsOpen ↑M
m : OpenNormalSubgroup ↑P.toProfinite.toTop := { toSubgroup := M, isOpen' := hMOpen, isNormal' := ⋯ }
origin : ↑P.toProfinite.toTop
horigin : (QuotientGroup.mk' M) origin = spc m
⊢ ↑((Hom.hom P.toLimit) origin) ∈ (↑J).pi fJ
|
8969731dd4e83c84
|
ProbabilityTheory.Kernel.compProd_eq_sum_compProd_right
|
Mathlib/Probability/Kernel/Composition/CompProd.lean
|
theorem compProd_eq_sum_compProd_right (κ : Kernel α β) (η : Kernel (α × β) γ)
[IsSFiniteKernel η] : κ ⊗ₖ η = Kernel.sum fun n => κ ⊗ₖ seq η n
|
case pos
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
hκ : IsSFiniteKernel κ
⊢ κ ⊗ₖ η = Kernel.sum fun n => κ ⊗ₖ η.seq n
case neg
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
hκ : ¬IsSFiniteKernel κ
⊢ κ ⊗ₖ η = Kernel.sum fun n => κ ⊗ₖ η.seq n
|
swap
|
case neg
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
hκ : ¬IsSFiniteKernel κ
⊢ κ ⊗ₖ η = Kernel.sum fun n => κ ⊗ₖ η.seq n
case pos
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
hκ : IsSFiniteKernel κ
⊢ κ ⊗ₖ η = Kernel.sum fun n => κ ⊗ₖ η.seq n
|
95e47d4c49db6f31
|
Array.mapIdx_set
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/MapIdx.lean
|
theorem mapIdx_set {l : Array α} {i : Nat} {h : i < l.size} {a : α} :
(l.set i a).mapIdx f = (l.mapIdx f).set i (f i a) (by simpa)
|
case mk
α : Type u_1
α✝ : Type u_2
f : Nat → α → α✝
i : Nat
a : α
l : List α
h : i < { toList := l }.size
⊢ mapIdx f ({ toList := l }.set i a h) = (mapIdx f { toList := l }).set i (f i a) ⋯
|
simp [List.mapIdx_set]
|
no goals
|
6b94a1f6965c8a48
|
hasFPowerSeriesAt_iff
|
Mathlib/Analysis/Analytic/Basic.lean
|
theorem hasFPowerSeriesAt_iff :
HasFPowerSeriesAt f p z₀ ↔ ∀ᶠ z in 𝓝 0, HasSum (fun n => z ^ n • p.coeff n) (f (z₀ + z))
|
case intro.intro.refine_1.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
z₀ : 𝕜
r : ℝ
r_pos : r > 0
h : ∀ ⦃y : 𝕜⦄, dist y 0 < r → HasSum (fun n => y ^ n • p.coeff n) (f (z₀ + y))
z : 𝕜
z_pos : 0 < ‖z‖
le_z : ‖z‖ < r
this : ↑‖z‖₊ ≤ p.radius
⊢ 0 < ↑‖z‖₊
|
simp only [ENNReal.coe_pos]
|
case intro.intro.refine_1.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
z₀ : 𝕜
r : ℝ
r_pos : r > 0
h : ∀ ⦃y : 𝕜⦄, dist y 0 < r → HasSum (fun n => y ^ n • p.coeff n) (f (z₀ + y))
z : 𝕜
z_pos : 0 < ‖z‖
le_z : ‖z‖ < r
this : ↑‖z‖₊ ≤ p.radius
⊢ 0 < ‖z‖₊
|
72d24d0576ad9ebc
|
Finset.subset_set_biUnion_of_mem
|
Mathlib/Order/CompleteLattice/Finset.lean
|
theorem subset_set_biUnion_of_mem {s : Finset α} {f : α → Set β} {x : α} (h : x ∈ s) :
f x ⊆ ⋃ y ∈ s, f y :=
show f x ≤ ⨆ y ∈ s, f y from le_iSup_of_le x <| by simp only [h, iSup_pos, le_refl]
|
α : Type u_2
β : Type u_3
s : Finset α
f : α → Set β
x : α
h : x ∈ s
⊢ f x ≤ ⨆ (_ : x ∈ s), f x
|
simp only [h, iSup_pos, le_refl]
|
no goals
|
1b7e0d4a1b062cd4
|
IsCoprime.add_mul_left_right
|
Mathlib/RingTheory/Coprime/Basic.lean
|
theorem add_mul_left_right {x y : R} (h : IsCoprime x y) (z : R) : IsCoprime x (y + x * z)
|
R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (y + x * z)
|
rw [isCoprime_comm]
|
R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (y + x * z) x
|
8e203d872b104c31
|
CochainComplex.HomComplex.Cochain.rightUnshift_smul
|
Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
|
@[simp]
lemma rightUnshift_smul {n' a : ℤ} (γ : Cochain K (L⟦a⟧) n') (n : ℤ) (hn : n' + a = n) (x : R) :
(x • γ).rightUnshift n hn = x • γ.rightUnshift n hn
|
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L : CochainComplex C ℤ
n' a : ℤ
γ : Cochain K ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj L) n'
n : ℤ
hn : n' + a = n
x : R
⊢ (x • γ).rightUnshift n hn = x • γ.rightUnshift n hn
|
change (rightShiftLinearEquiv R K L n a n' hn).symm (x • γ) = _
|
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L : CochainComplex C ℤ
n' a : ℤ
γ : Cochain K ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj L) n'
n : ℤ
hn : n' + a = n
x : R
⊢ (rightShiftLinearEquiv R K L n a n' hn).symm (x • γ) = x • γ.rightUnshift n hn
|
d2ca77d274bb6190
|
Real.tendsto_toNNReal_atTop_iff
|
Mathlib/Topology/Instances/NNReal/Lemmas.lean
|
theorem _root_.Real.tendsto_toNNReal_atTop_iff {l : Filter α} {f : α → ℝ} :
Tendsto (fun x ↦ (f x).toNNReal) l atTop ↔ Tendsto f l atTop
|
α : Type u_1
l : Filter α
f : α → ℝ
⊢ Tendsto (fun x => (f x).toNNReal) l atTop ↔ Tendsto f l atTop
|
rw [← Real.comap_toNNReal_atTop, tendsto_comap_iff, Function.comp_def]
|
no goals
|
b7641e2f4d27383b
|
Ideal.natAbs_det_basis_change
|
Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean
|
theorem natAbs_det_basis_change {ι : Type*} [Fintype ι] [DecidableEq ι] (b : Basis ι ℤ S)
(I : Ideal S) (bI : Basis ι ℤ I) : (b.det ((↑) ∘ bI)).natAbs = Ideal.absNorm I
|
S : Type u_1
inst✝⁶ : CommRing S
inst✝⁵ : Nontrivial S
inst✝⁴ : IsDedekindDomain S
inst✝³ : Module.Free ℤ S
inst✝² : Module.Finite ℤ S
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : Basis ι ℤ S
I : Ideal S
bI : Basis ι ℤ ↥I
⊢ (b.det (Subtype.val ∘ ⇑bI)).natAbs = absNorm I
|
let e := b.equiv bI (Equiv.refl _)
|
S : Type u_1
inst✝⁶ : CommRing S
inst✝⁵ : Nontrivial S
inst✝⁴ : IsDedekindDomain S
inst✝³ : Module.Free ℤ S
inst✝² : Module.Finite ℤ S
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : Basis ι ℤ S
I : Ideal S
bI : Basis ι ℤ ↥I
e : S ≃ₗ[ℤ] ↥I := b.equiv bI (Equiv.refl ι)
⊢ (b.det (Subtype.val ∘ ⇑bI)).natAbs = absNorm I
|
0271342b99129e4f
|
IsCoprime.prod_left_iff
|
Mathlib/RingTheory/Coprime/Lemmas.lean
|
theorem IsCoprime.prod_left_iff : IsCoprime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsCoprime (s i) x
|
R : Type u
I : Type v
inst✝ : CommSemiring R
x : R
s : I → R
t : Finset I
⊢ IsCoprime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsCoprime (s i) x
|
refine Finset.induction_on t (iff_of_true isCoprime_one_left fun _ ↦ by simp) fun b t hbt ih ↦ ?_
|
R : Type u
I : Type v
inst✝ : CommSemiring R
x : R
s : I → R
t✝ : Finset I
b : I
t : Finset I
hbt : b ∉ t
ih : IsCoprime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsCoprime (s i) x
⊢ IsCoprime (∏ i ∈ insert b t, s i) x ↔ ∀ i ∈ insert b t, IsCoprime (s i) x
|
9d3d4bcf53392746
|
Vector.map_eq_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Lemmas.lean
|
theorem map_eq_iff {f : α → β} {l : Vector α n} {l' : Vector β n} :
map f l = l' ↔ ∀ i (h : i < n), l'[i] = f l[i]
|
case mk.mk.mp
α : Type u_1
β : Type u_2
f : α → β
l : Array α
l' : Array β
h' : l'.size = l.size
⊢ (∀ (i : Nat), l'[i]? = Option.map f l[i]?) → ∀ (i : Nat) (h : i < l.size), l'[i] = f l[i]
|
intro w i h
|
case mk.mk.mp
α : Type u_1
β : Type u_2
f : α → β
l : Array α
l' : Array β
h' : l'.size = l.size
w : ∀ (i : Nat), l'[i]? = Option.map f l[i]?
i : Nat
h : i < l.size
⊢ l'[i] = f l[i]
|
9e0ae22d1d915b68
|
Batteries.RBNode.Ordered.unique
|
Mathlib/.lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean
|
theorem Ordered.unique [@TransCmp α cmp] (ht : Ordered cmp t)
(hx : x ∈ t) (hy : y ∈ t) (e : cmp x y = .eq) : x = y
|
case node.inr.inr.inr.inl
α : Type u_1
cmp : α → α → Ordering
x y : α
inst✝ : TransCmp cmp
e : cmp x y = Ordering.eq
c✝ : RBColor
l : RBNode α
v✝ : α
r : RBNode α
ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y
ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y
ht : Ordered cmp (node c✝ l v✝ r)
lx : All (fun x => cmpLT cmp x v✝) l
xr : All (fun x => cmpLT cmp v✝ x) r
hl : Ordered cmp l
hr : Ordered cmp r
hx : Any (fun x_1 => x = x_1) r
hy : Any (fun x => y = x) l
⊢ x = y
|
cases e.symm.trans <| OrientedCmp.cmp_eq_gt.2
((All_def.1 lx _ hy).trans (All_def.1 xr _ hx)).1
|
no goals
|
77450b4176612ab8
|
contractLeft_assoc_coevaluation'
|
Mathlib/LinearAlgebra/Coevaluation.lean
|
theorem contractLeft_assoc_coevaluation' :
(contractLeft K V).lTensor _ ∘ₗ
(TensorProduct.assoc K _ _ _).toLinearMap ∘ₗ (coevaluation K V).rTensor V =
(TensorProduct.rid K _).symm.toLinearMap ∘ₗ (TensorProduct.lid K _).toLinearMap
|
case H.h
K : Type u
inst✝³ : Field K
V : Type v
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
this : DecidableEq ↑(Basis.ofVectorSpaceIndex K V) := Classical.decEq ↑(Basis.ofVectorSpaceIndex K V)
j : ↑(Basis.ofVectorSpaceIndex K V)
⊢ (LinearMap.lTensor V (contractLeft K V))
((TensorProduct.assoc K V (Dual K V) V)
((LinearMap.rTensor V (coevaluation K V)) (1 ⊗ₜ[K] (Basis.ofVectorSpace K V) j))) =
(TensorProduct.rid K V).symm ((TensorProduct.lid K V) (1 ⊗ₜ[K] (Basis.ofVectorSpace K V) j))
|
rw [lid_tmul, one_smul, rid_symm_apply]
|
case H.h
K : Type u
inst✝³ : Field K
V : Type v
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
this : DecidableEq ↑(Basis.ofVectorSpaceIndex K V) := Classical.decEq ↑(Basis.ofVectorSpaceIndex K V)
j : ↑(Basis.ofVectorSpaceIndex K V)
⊢ (LinearMap.lTensor V (contractLeft K V))
((TensorProduct.assoc K V (Dual K V) V)
((LinearMap.rTensor V (coevaluation K V)) (1 ⊗ₜ[K] (Basis.ofVectorSpace K V) j))) =
(Basis.ofVectorSpace K V) j ⊗ₜ[K] 1
|
fa558da7fb2ef0c7
|
FermatLastTheoremForThreeGen.Solution.lambda_sq_div_u₅_mul
|
Mathlib/NumberTheory/FLT/Three.lean
|
private lemma lambda_sq_div_u₅_mul : λ ^ 2 ∣ S.u₅ * (λ ^ (S.multiplicity - 1) * S.X) ^ 3
|
K : Type u_1
inst✝² : Field K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
inst✝¹ : NumberField K
inst✝ : IsCyclotomicExtension {3} ℚ K
⊢ 3 * (S.multiplicity - 1) = 2 + (3 * S.multiplicity - 5)
|
have := S.two_le_multiplicity
|
K : Type u_1
inst✝² : Field K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
inst✝¹ : NumberField K
inst✝ : IsCyclotomicExtension {3} ℚ K
this : 2 ≤ S.multiplicity
⊢ 3 * (S.multiplicity - 1) = 2 + (3 * S.multiplicity - 5)
|
49199d47aec8e219
|
LinearMap.IsSymmetric.iSup_eigenspace_inf_eigenspace_of_commute
|
Mathlib/Analysis/InnerProductSpace/JointEigenspace.lean
|
theorem iSup_eigenspace_inf_eigenspace_of_commute (hB : B.IsSymmetric) (hAB : Commute A B) :
(⨆ γ, eigenspace A α ⊓ eigenspace B γ) = eigenspace A α
|
case e_p
𝕜 : Type u_1
E : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
α : 𝕜
A B : E →ₗ[𝕜] E
inst✝ : FiniteDimensional 𝕜 E
hB : B.IsSymmetric
hAB : Commute A B
⊢ ⨆ i, (genEigenspace (B.restrict ⋯) i) 1 = ⊤
|
simpa only [genEigenspace_eq_eigenspace, Submodule.orthogonal_eq_bot_iff]
using orthogonalComplement_iSup_eigenspaces_eq_bot <|
hB.restrict_invariant <| mapsTo_genEigenspace_of_comm hAB α 1
|
no goals
|
602f1bc013c8706e
|
norm_mk_lt'
|
Mathlib/Analysis/Normed/Group/Quotient.lean
|
theorem norm_mk_lt' (S : AddSubgroup M) (m : M) {ε : ℝ} (hε : 0 < ε) :
∃ s ∈ S, ‖m + s‖ < ‖mk' S m‖ + ε
|
case intro.intro
M : Type u_1
inst✝ : SeminormedAddCommGroup M
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε
|
use -m + n, hn
|
case right
M : Type u_1
inst✝ : SeminormedAddCommGroup M
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ‖m + (-m + n)‖ < ‖(mk' S) m‖ + ε
|
7e118629953e7ad0
|
PresentedMonoid.ext
|
Mathlib/Algebra/PresentedMonoid/Basic.lean
|
theorem ext {M : Type*} [Monoid M] (rels : FreeMonoid α → FreeMonoid α → Prop)
{φ ψ : PresentedMonoid rels →* M} (hx : ∀ (x : α), φ (.of rels x) = ψ (.of rels x)) :
φ = ψ
|
α : Type u_2
M : Type u_3
inst✝ : Monoid M
rels : FreeMonoid α → FreeMonoid α → Prop
φ ψ : PresentedMonoid rels →* M
hx : ∀ (x : α), φ (of rels x) = ψ (of rels x)
⊢ EqOn (⇑φ) (⇑ψ) (range (of rels))
|
apply eqOn_range.mpr
|
α : Type u_2
M : Type u_3
inst✝ : Monoid M
rels : FreeMonoid α → FreeMonoid α → Prop
φ ψ : PresentedMonoid rels →* M
hx : ∀ (x : α), φ (of rels x) = ψ (of rels x)
⊢ ⇑φ ∘ of rels = ⇑ψ ∘ of rels
|
4e13ad6c6062fd98
|
EuclideanGeometry.angle_const_sub
|
Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
|
theorem angle_const_sub (v : V) (v₁ v₂ v₃ : V) : ∠ (v - v₁) (v - v₂) (v - v₃) = ∠ v₁ v₂ v₃
|
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
v v₁ v₂ v₃ : V
⊢ ∠ (v - v₁) (v - v₂) (v - v₃) = ∠ v₁ v₂ v₃
|
simpa only [vsub_eq_sub] using angle_const_vsub v v₁ v₂ v₃
|
no goals
|
fb1bdb894af22abd
|
Nat.mul_pow
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
|
theorem mul_pow (a b n : Nat) : (a * b) ^ n = a ^ n * b ^ n
|
a b n : Nat
⊢ (a * b) ^ n = a ^ n * b ^ n
|
induction n with
| zero => rw [Nat.pow_zero, Nat.pow_zero, Nat.pow_zero, Nat.mul_one]
| succ _ ih => rw [Nat.pow_succ, Nat.pow_succ, Nat.pow_succ, Nat.mul_mul_mul_comm, ih]
|
no goals
|
a47bdc1fc08287a8
|
MulAction.zpow_smul_mod_minimalPeriod
|
Mathlib/Dynamics/PeriodicPts/Defs.lean
|
theorem zpow_smul_mod_minimalPeriod (n : ℤ) :
a ^ (n % (minimalPeriod (a • ·) b : ℤ)) • b = a ^ n • b
|
α : Type v
G : Type u
inst✝¹ : Group G
inst✝ : MulAction G α
a : G
b : α
n : ℤ
⊢ a ^ (n % ↑(minimalPeriod (fun x => a • x) b)) • b = a ^ n • b
|
rw [← period_eq_minimalPeriod, zpow_mod_period_smul]
|
no goals
|
4712540e5a9d4a97
|
comap_map_eq_map_of_isLocalization_algebraMapSubmonoid
|
Mathlib/RingTheory/Trace/Quotient.lean
|
lemma comap_map_eq_map_of_isLocalization_algebraMapSubmonoid :
(Ideal.map (algebraMap R Sₚ) p).comap (algebraMap S Sₚ) = pS
|
case intro
R : Type u_1
S : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
p : Ideal R
inst✝⁵ : p.IsMaximal
Sₚ : Type u_4
inst✝⁴ : CommRing Sₚ
inst✝³ : Algebra S Sₚ
inst✝² : Algebra R Sₚ
inst✝¹ : IsLocalization (Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ
inst✝ : IsScalarTower R S Sₚ
x : S
hx : x ∈ Ideal.comap (algebraMap S Sₚ) (Ideal.map (algebraMap S Sₚ) pS)
α : R
hα : α ∉ p
hαx : α • x ∈ pS
β : R
hβ : (Ideal.Quotient.mk p) β = ((Ideal.Quotient.mk p) α)⁻¹
⊢ ∃ β, ∃ γ ∈ p, β * α = 1 + γ
|
refine ⟨β, β * α - 1, ?_, ?_⟩
|
case intro.refine_1
R : Type u_1
S : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
p : Ideal R
inst✝⁵ : p.IsMaximal
Sₚ : Type u_4
inst✝⁴ : CommRing Sₚ
inst✝³ : Algebra S Sₚ
inst✝² : Algebra R Sₚ
inst✝¹ : IsLocalization (Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ
inst✝ : IsScalarTower R S Sₚ
x : S
hx : x ∈ Ideal.comap (algebraMap S Sₚ) (Ideal.map (algebraMap S Sₚ) pS)
α : R
hα : α ∉ p
hαx : α • x ∈ pS
β : R
hβ : (Ideal.Quotient.mk p) β = ((Ideal.Quotient.mk p) α)⁻¹
⊢ β * α - 1 ∈ p
case intro.refine_2
R : Type u_1
S : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
p : Ideal R
inst✝⁵ : p.IsMaximal
Sₚ : Type u_4
inst✝⁴ : CommRing Sₚ
inst✝³ : Algebra S Sₚ
inst✝² : Algebra R Sₚ
inst✝¹ : IsLocalization (Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ
inst✝ : IsScalarTower R S Sₚ
x : S
hx : x ∈ Ideal.comap (algebraMap S Sₚ) (Ideal.map (algebraMap S Sₚ) pS)
α : R
hα : α ∉ p
hαx : α • x ∈ pS
β : R
hβ : (Ideal.Quotient.mk p) β = ((Ideal.Quotient.mk p) α)⁻¹
⊢ β * α = 1 + (β * α - 1)
|
d6f88c93445b65e1
|
Prime.dvd_of_pow_dvd_pow_mul_pow_of_square_not_dvd
|
Mathlib/Algebra/Prime/Lemmas.lean
|
theorem Prime.dvd_of_pow_dvd_pow_mul_pow_of_square_not_dvd [CancelCommMonoidWithZero M] {p a b : M}
{n : ℕ} (hp : Prime p) (hpow : p ^ n.succ ∣ a ^ n.succ * b ^ n) (hb : ¬p ^ 2 ∣ b) : p ∣ a
|
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
p a : M
n : ℕ
hp : Prime p
x : M
hb : ¬p ^ 2 ∣ p * x
hbdiv : p ∣ (p * x) ^ n
y : M
hy : a ^ n.succ * (p * x) ^ n = p ^ n.succ * y
⊢ p ^ n * (a ^ n.succ * x ^ n) = p ^ n * (p * y)
|
rw [← mul_assoc _ p, ← pow_succ, ← hy, mul_pow, ← mul_assoc (a ^ n.succ), mul_comm _ (p ^ n),
mul_assoc]
|
no goals
|
a203319e403717ea
|
Tree.treesOfNumNodesEq_succ
|
Mathlib/Combinatorics/Enumerative/Catalan.lean
|
theorem treesOfNumNodesEq_succ (n : ℕ) :
treesOfNumNodesEq (n + 1) =
(antidiagonal n).biUnion fun ij =>
pairwiseNode (treesOfNumNodesEq ij.1) (treesOfNumNodesEq ij.2)
|
n : ℕ
⊢ ((antidiagonal n).attach.biUnion fun ijh => pairwiseNode (treesOfNumNodesEq (↑ijh).1) (treesOfNumNodesEq (↑ijh).2)) =
(antidiagonal n).biUnion fun ij => pairwiseNode (treesOfNumNodesEq ij.1) (treesOfNumNodesEq ij.2)
|
ext
|
case h
n : ℕ
a✝ : Tree Unit
⊢ (a✝ ∈
(antidiagonal n).attach.biUnion fun ijh =>
pairwiseNode (treesOfNumNodesEq (↑ijh).1) (treesOfNumNodesEq (↑ijh).2)) ↔
a✝ ∈ (antidiagonal n).biUnion fun ij => pairwiseNode (treesOfNumNodesEq ij.1) (treesOfNumNodesEq ij.2)
|
8ad380b3ed743c12
|
CategoryTheory.IsVanKampenColimit.whiskerEquivalence
|
Mathlib/CategoryTheory/Limits/VanKampen.lean
|
theorem IsVanKampenColimit.whiskerEquivalence {K : Type*} [Category K] (e : J ≌ K)
{F : K ⥤ C} {c : Cocone F} (hc : IsVanKampenColimit c) :
IsVanKampenColimit (c.whisker e.functor)
|
case h.e'_2.a.mpr
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
K : Type u_3
inst✝ : Category.{u_4, u_3} K
e : J ≌ K
F : K ⥤ C
c : Cocone F
hc : IsVanKampenColimit c
F' : J ⥤ C
c' : Cocone F'
α : F' ⟶ e.functor ⋙ F
f : c'.pt ⟶ (Cocone.whisker e.functor c).pt
e' : α ≫ (Cocone.whisker e.functor c).ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
H : ∀ (j : K), IsPullback (c'.ι.app (e.inverse.obj j)) (α.app (e.inverse.obj j) ≫ F.map (e.counit.app j)) f (c.ι.app j)
j : J
this : α.app j = F'.map (e.unit.app j) ≫ α.app ((e.functor ⋙ e.inverse).obj j) ≫ F.map (e.counit.app (e.functor.obj j))
⊢ IsPullback (c'.ι.app j) (F'.map (e.unit.app j)) (𝟙 c'.pt) (c'.ι.app (e.inverse.obj (e.functor.obj j)))
|
exact IsPullback.of_vert_isIso ⟨by simp⟩
|
no goals
|
04b6c653df528b06
|
AlgebraicTopology.DoldKan.PInfty_on_Γ₀_splitting_summand_eq_self
|
Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
|
theorem PInfty_on_Γ₀_splitting_summand_eq_self (K : ChainComplex C ℕ) {n : ℕ} :
((Γ₀.splitting K).cofan _).inj (Splitting.IndexSet.id (op ⦋n⦌)) ≫
(PInfty : K[Γ₀.obj K] ⟶ _).f n =
((Γ₀.splitting K).cofan _).inj (Splitting.IndexSet.id (op ⦋n⦌))
|
case succ
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
n : ℕ
⊢ ((Γ₀.splitting K).cofan (op ⦋n + 1⦌)).inj (Splitting.IndexSet.id (op ⦋n + 1⦌)) ≫ (P (n + 1)).f (n + 1) =
((Γ₀.splitting K).cofan (op ⦋n + 1⦌)).inj (Splitting.IndexSet.id (op ⦋n + 1⦌))
|
exact (HigherFacesVanish.on_Γ₀_summand_id K n).comp_P_eq_self
|
no goals
|
fdf1ba0fb1743d80
|
Order.exists_series_of_le_height
|
Mathlib/Order/KrullDimension.lean
|
/-- There exist a series ending in a element for any length up to the element’s height. -/
lemma exists_series_of_le_height (a : α) {n : ℕ} (h : n ≤ height a) :
∃ p : LTSeries α, p.last = a ∧ p.length = n
|
α : Type u_1
inst✝ : Preorder α
n m : ℕ
p : LTSeries α
hne : Nonempty { p_1 // RelSeries.last p_1 = RelSeries.last p }
ha : ∀ (p_1 : LTSeries α), RelSeries.last p_1 = RelSeries.last p → p_1.length ≠ n
hp : p.length = m
hnm : n < m
⊢ (RelSeries.drop p ⟨m - n, ⋯⟩).last = RelSeries.last p
|
simp
|
no goals
|
0e15cb2199a1ee03
|
hasFTaylorSeriesUpToOn_succ_iff_left
|
Mathlib/Analysis/Calculus/ContDiff/FTaylorSeries.lean
|
theorem hasFTaylorSeriesUpToOn_succ_iff_left {n : ℕ} :
HasFTaylorSeriesUpToOn (n + 1) f p s ↔
HasFTaylorSeriesUpToOn n f p s ∧
(∀ x ∈ s, HasFDerivWithinAt (fun y => p y n) (p x n.succ).curryLeft s x) ∧
ContinuousOn (fun x => p x (n + 1)) s
|
case neg
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type uE
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type uF
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
s : Set E
f : E → F
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
h :
HasFTaylorSeriesUpToOn (↑n) f p s ∧
(∀ x ∈ s, HasFDerivWithinAt (fun y => p y n) (p x n.succ).curryLeft s x) ∧ ContinuousOn (fun x => p x (n + 1)) s
m : ℕ
hm : ↑m ≤ ↑n + 1
h' : ¬m ≤ n
this : m = n + 1
⊢ ContinuousOn (fun x => p x (n + 1)) s
|
exact h.2.2
|
no goals
|
5ea2ef581950d21b
|
ascPochhammer_eval_neg_eq_descPochhammer
|
Mathlib/RingTheory/Polynomial/Pochhammer.lean
|
theorem ascPochhammer_eval_neg_eq_descPochhammer (r : R) : ∀ (k : ℕ),
(ascPochhammer R k).eval (-r) = (-1)^k * (descPochhammer R k).eval r
| 0 => by
rw [ascPochhammer_zero, descPochhammer_zero]
simp only [eval_one, pow_zero, mul_one]
| (k+1) => by
rw [ascPochhammer_succ_right, mul_add, eval_add, eval_mul_X, ← Nat.cast_comm, eval_natCast_mul,
Nat.cast_comm, ← mul_add, ascPochhammer_eval_neg_eq_descPochhammer r k, mul_assoc,
descPochhammer_succ_right, mul_sub, eval_sub, eval_mul_X, ← Nat.cast_comm, eval_natCast_mul,
pow_add, pow_one, mul_assoc ((-1)^k) (-1), mul_sub, neg_one_mul, neg_mul_eq_mul_neg,
Nat.cast_comm, sub_eq_add_neg, neg_one_mul, neg_neg, ← mul_add]
|
R : Type u
inst✝ : Ring R
r : R
⊢ eval (-r) (ascPochhammer R 0) = (-1) ^ 0 * eval r (descPochhammer R 0)
|
rw [ascPochhammer_zero, descPochhammer_zero]
|
R : Type u
inst✝ : Ring R
r : R
⊢ eval (-r) 1 = (-1) ^ 0 * eval r 1
|
91e878a9eb30688b
|
MonovaryOn.sum_smul_comp_perm_le_sum_smul
|
Mathlib/Algebra/Order/Rearrangement.lean
|
theorem MonovaryOn.sum_smul_comp_perm_le_sum_smul (hfg : MonovaryOn f g s)
(hσ : {x | σ x ≠ x} ⊆ s) : ∑ i ∈ s, f i • g (σ i) ≤ ∑ i ∈ s, f i • g i
|
case pos.inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : LinearOrderedSemiring α
inst✝³ : ExistsAddOfLE α
inst✝² : LinearOrderedCancelAddCommMonoid β
inst✝¹ : Module α β
inst✝ : PosSMulMono α β
s✝ : Finset ι
f : ι → α
g : ι → β
a : ι
s : Finset ι
has : a ∉ s
hamax : ∀ x ∈ s, toLex (g x, f x) ≤ toLex (g a, f a)
hind : ∀ {σ : Perm ι}, MonovaryOn f g ↑s → {x | σ x ≠ x} ⊆ ↑s → ∑ i ∈ s, f i • g (σ i) ≤ ∑ i ∈ s, f i • g i
σ : Perm ι
hfg : MonovaryOn f g ↑(insert a s)
hσ : {x | σ x ≠ x} ⊆ ↑(insert a s)
τ : Perm ι := Equiv.trans σ (Equiv.swap a (σ a))
hτ : τ = Equiv.trans σ (Equiv.swap a (σ a))
x : ι
h₁ : σ x = a
hx : ¬σ a = x
hax : x ≠ a
⊢ x ∈ ↑s
|
exact mem_of_mem_insert_of_ne (hσ fun h ↦ hax <| h.symm.trans h₁) hax
|
no goals
|
4fd7a15670de10aa
|
MeasureTheory.lintegral_smul_measure
|
Mathlib/MeasureTheory/Integral/Lebesgue.lean
|
theorem lintegral_smul_measure (c : ℝ≥0∞) (f : α → ℝ≥0∞) : ∫⁻ a, f a ∂c • μ = c * ∫⁻ a, f a ∂μ
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
f : α → ℝ≥0∞
⊢ ∫⁻ (a : α), f a ∂c • μ = c * ∫⁻ (a : α), f a ∂μ
|
simp only [lintegral, iSup_subtype', SimpleFunc.lintegral_smul, ENNReal.mul_iSup, smul_eq_mul]
|
no goals
|
c16ad3405766c04f
|
Order.le_succ_iff_eq_or_le
|
Mathlib/Order/SuccPred/Basic.lean
|
theorem le_succ_iff_eq_or_le : a ≤ succ b ↔ a = succ b ∨ a ≤ b
|
case pos
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : SuccOrder α
a b : α
hb : IsMax b
⊢ a ≤ succ b ↔ a = succ b ∨ a ≤ b
|
rw [hb.succ_eq, or_iff_right_of_imp le_of_eq]
|
no goals
|
ca762971dc330b2f
|
HasFPowerSeriesWithinOnBall.fderivWithin_of_mem_of_analyticOn
|
Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
|
theorem HasFPowerSeriesWithinOnBall.fderivWithin_of_mem_of_analyticOn
(hr : HasFPowerSeriesWithinOnBall f p s x r)
(h : AnalyticOn 𝕜 f s) (hs : UniqueDiffOn 𝕜 s) (hx : x ∈ s) :
HasFPowerSeriesWithinOnBall (fderivWithin 𝕜 f s) p.derivSeries s x r
|
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
f : E → F
x : E
s : Set E
hr : HasFPowerSeriesWithinOnBall f p s x r
h : AnalyticOn 𝕜 f s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
y : E
hy : x + y ∈ insert x s
h'y : y ∈ EMetric.ball 0 r
⊢ ↑‖y‖₊ < r
|
simpa [edist_zero_eq_enorm] using h'y
|
no goals
|
d39a108ffb050c55
|
List.zipIdxLE_trans
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Sort/Lemmas.lean
|
theorem zipIdxLE_trans (trans : ∀ a b c, le a b → le b c → le a c)
(a b c : α × Nat) : zipIdxLE le a b → zipIdxLE le b c → zipIdxLE le a c
|
case isTrue.isTrue.isTrue
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
a b c : α × Nat
ab₂ : le a.fst b.fst = true
ba₂ : le b.fst a.fst = true
bc₂ : le b.fst c.fst = true
ab₁ : a.snd ≤ b.snd
h : le c.fst b.fst = false ∨ b.snd ≤ c.snd
⊢ le c.fst a.fst = false ∨ a.snd ≤ c.snd
|
rcases h with (cd₂ | bc₁)
|
case isTrue.isTrue.isTrue.inl
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
a b c : α × Nat
ab₂ : le a.fst b.fst = true
ba₂ : le b.fst a.fst = true
bc₂ : le b.fst c.fst = true
ab₁ : a.snd ≤ b.snd
cd₂ : le c.fst b.fst = false
⊢ le c.fst a.fst = false ∨ a.snd ≤ c.snd
case isTrue.isTrue.isTrue.inr
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
a b c : α × Nat
ab₂ : le a.fst b.fst = true
ba₂ : le b.fst a.fst = true
bc₂ : le b.fst c.fst = true
ab₁ : a.snd ≤ b.snd
bc₁ : b.snd ≤ c.snd
⊢ le c.fst a.fst = false ∨ a.snd ≤ c.snd
|
4b08ab1e530cfafb
|
GroupWithZero.isOpen_singleton_zero
|
Mathlib/Topology/Algebra/Monoid.lean
|
lemma GroupWithZero.isOpen_singleton_zero [GroupWithZero M] [TopologicalSpace M]
[ContinuousMul M] [CompactSpace M] [T1Space M] :
IsOpen {(0 : M)}
|
case intro.intro.intro
M : Type u_3
inst✝⁴ : GroupWithZero M
inst✝³ : TopologicalSpace M
inst✝² : ContinuousMul M
inst✝¹ : CompactSpace M
inst✝ : T1Space M
U : Set M
hU : IsOpen U
h0U : 0 ∈ U
h1U : 1 ∉ U
⊢ IsOpen {0}
|
obtain ⟨W, hW, hW'⟩ := exists_mem_nhds_zero_mul_subset isCompact_univ (hU.mem_nhds h0U)
|
case intro.intro.intro.intro.intro
M : Type u_3
inst✝⁴ : GroupWithZero M
inst✝³ : TopologicalSpace M
inst✝² : ContinuousMul M
inst✝¹ : CompactSpace M
inst✝ : T1Space M
U : Set M
hU : IsOpen U
h0U : 0 ∈ U
h1U : 1 ∉ U
W : Set M
hW : W ∈ 𝓝 0
hW' : univ * W ⊆ U
⊢ IsOpen {0}
|
dc8e2a6913e2be45
|
Polynomial.sub_one_pow_totient_lt_cyclotomic_eval
|
Mathlib/RingTheory/Polynomial/Cyclotomic/Eval.lean
|
theorem sub_one_pow_totient_lt_cyclotomic_eval {n : ℕ} {q : ℝ} (hn' : 2 ≤ n) (hq' : 1 < q) :
(q - 1) ^ totient n < (cyclotomic n ℝ).eval q
|
case convert_6
n : ℕ
q : ℝ
hn' : 2 ≤ n
hq' : 1 < q
hn : 0 < n
hq : 0 < q
hfor : ∀ ζ' ∈ primitiveRoots n ℂ, q - 1 ≤ ‖↑q - ζ'‖
ζ : ℂ := Complex.exp (2 * ↑Real.pi * Complex.I / ↑n)
hζ : IsPrimitiveRoot ζ n
hex : ∃ ζ' ∈ primitiveRoots n ℂ, q - 1 < ‖↑q - ζ'‖
this : ¬eval (↑q) (cyclotomic n ℂ) = 0
⊢ ∃ i ∈ (primitiveRoots n ℂ).attach, Units.mk0 (q - 1).toNNReal ⋯ < Units.mk0 ‖↑q - ↑i‖₊ ⋯
|
simp only [Subtype.coe_mk, Finset.mem_attach, exists_true_left, Subtype.exists, ←
NNReal.coe_lt_coe, ← Units.val_lt_val, Units.val_mk0 _, coe_nnnorm]
|
case convert_6
n : ℕ
q : ℝ
hn' : 2 ≤ n
hq' : 1 < q
hn : 0 < n
hq : 0 < q
hfor : ∀ ζ' ∈ primitiveRoots n ℂ, q - 1 ≤ ‖↑q - ζ'‖
ζ : ℂ := Complex.exp (2 * ↑Real.pi * Complex.I / ↑n)
hζ : IsPrimitiveRoot ζ n
hex : ∃ ζ' ∈ primitiveRoots n ℂ, q - 1 < ‖↑q - ζ'‖
this : ¬eval (↑q) (cyclotomic n ℂ) = 0
⊢ ∃ a, ∃ (_ : a ∈ primitiveRoots n ℂ), True ∧ ↑(q - 1).toNNReal < ‖↑q - a‖
|
0ef7adcad44e6a5e
|
Finset.small_pos_neg_neg_mul
|
Mathlib/Combinatorics/Additive/SmallTripling.lean
|
@[to_additive]
private lemma small_pos_neg_neg_mul (hA : #(A ^ 3) ≤ K * #A) : #(A * A⁻¹ * A⁻¹) ≤ K ^ 2 * #A
|
G : Type u_1
inst✝¹ : DecidableEq G
inst✝ : Group G
A : Finset G
K : ℝ
hA : ↑(#(A ^ 3)) ≤ K * ↑(#A)
⊢ ↑(#(A * A⁻¹ * A⁻¹)) ≤ K ^ 2 * ↑(#A)
|
simpa using small_neg_pos_pos_mul (A := A⁻¹) (by simpa)
|
no goals
|
5a530b69a1256eb1
|
PrincipalSeg.top_rel_top
|
Mathlib/Order/InitialSeg.lean
|
theorem top_rel_top {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop} [IsWellOrder γ t]
(f : r ≺i s) (g : s ≺i t) (h : r ≺i t) : t h.top g.top
|
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder γ t
f : r ≺i s
g : s ≺i t
h : r ≺i t
⊢ t h.top g.top
|
rw [Subsingleton.elim h (f.trans g)]
|
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder γ t
f : r ≺i s
g : s ≺i t
h : r ≺i t
⊢ t (f.trans g).top g.top
|
e7eeb80e8731e3bf
|
hasSum_mellin_pi_mul_sq'
|
Mathlib/NumberTheory/LSeries/MellinEqDirichlet.lean
|
/-- Tailored version for odd Jacobi theta functions. -/
lemma hasSum_mellin_pi_mul_sq' {a : ι → ℂ} {r : ι → ℝ} {F : ℝ → ℂ} {s : ℂ} (hs : 0 < s.re)
(hF : ∀ t ∈ Ioi 0, HasSum (fun i ↦ a i * r i * rexp (-π * r i ^ 2 * t)) (F t))
(h_sum : Summable fun i ↦ ‖a i‖ / |r i| ^ s.re) :
HasSum (fun i ↦ Gammaℝ (s + 1) * a i * SignType.sign (r i) / |r i| ^ s)
(mellin F ((s + 1) / 2))
|
case h.e'_5.h
ι : Type u_1
inst✝ : Countable ι
a : ι → ℂ
r : ι → ℝ
F : ℝ → ℂ
s : ℂ
hs : 0 < s.re
hF : ∀ t ∈ Ioi 0, HasSum (fun i => if r i = 0 then 0 else a i * ↑(r i) * ↑(rexp (-π * r i ^ 2 * t))) (F t)
h_sum : Summable fun i => ‖a i‖ / |r i| ^ s.re
hs₁ : s ≠ 0
hs₂ : 0 < (s + 1).re
hs₃ : s + 1 ≠ 0
this :
∀ (i : ι) (t : ℝ),
a i * ↑(r i) * ↑(rexp (-π * r i ^ 2 * t)) = if r i = 0 then 0 else a i * ↑(r i) * ↑(rexp (-π * r i ^ 2 * t))
i : ι
⊢ (s + 1).Gammaℝ * a i * ↑(SignType.sign (r i)) / ↑|r i| ^ s = (s + 1).Gammaℝ * (a i * ↑(r i)) / ↑|r i| ^ (s + 1)
|
rcases eq_or_ne (r i) 0 with h | h
|
case h.e'_5.h.inl
ι : Type u_1
inst✝ : Countable ι
a : ι → ℂ
r : ι → ℝ
F : ℝ → ℂ
s : ℂ
hs : 0 < s.re
hF : ∀ t ∈ Ioi 0, HasSum (fun i => if r i = 0 then 0 else a i * ↑(r i) * ↑(rexp (-π * r i ^ 2 * t))) (F t)
h_sum : Summable fun i => ‖a i‖ / |r i| ^ s.re
hs₁ : s ≠ 0
hs₂ : 0 < (s + 1).re
hs₃ : s + 1 ≠ 0
this :
∀ (i : ι) (t : ℝ),
a i * ↑(r i) * ↑(rexp (-π * r i ^ 2 * t)) = if r i = 0 then 0 else a i * ↑(r i) * ↑(rexp (-π * r i ^ 2 * t))
i : ι
h : r i = 0
⊢ (s + 1).Gammaℝ * a i * ↑(SignType.sign (r i)) / ↑|r i| ^ s = (s + 1).Gammaℝ * (a i * ↑(r i)) / ↑|r i| ^ (s + 1)
case h.e'_5.h.inr
ι : Type u_1
inst✝ : Countable ι
a : ι → ℂ
r : ι → ℝ
F : ℝ → ℂ
s : ℂ
hs : 0 < s.re
hF : ∀ t ∈ Ioi 0, HasSum (fun i => if r i = 0 then 0 else a i * ↑(r i) * ↑(rexp (-π * r i ^ 2 * t))) (F t)
h_sum : Summable fun i => ‖a i‖ / |r i| ^ s.re
hs₁ : s ≠ 0
hs₂ : 0 < (s + 1).re
hs₃ : s + 1 ≠ 0
this :
∀ (i : ι) (t : ℝ),
a i * ↑(r i) * ↑(rexp (-π * r i ^ 2 * t)) = if r i = 0 then 0 else a i * ↑(r i) * ↑(rexp (-π * r i ^ 2 * t))
i : ι
h : r i ≠ 0
⊢ (s + 1).Gammaℝ * a i * ↑(SignType.sign (r i)) / ↑|r i| ^ s = (s + 1).Gammaℝ * (a i * ↑(r i)) / ↑|r i| ^ (s + 1)
|
22936c8a231e7fbd
|
Subgroup.IsComplement.equiv_fst_eq_self_iff_mem
|
Mathlib/GroupTheory/Complement.lean
|
theorem equiv_fst_eq_self_iff_mem {g : G} (h1 : 1 ∈ T) :
((hST.equiv g).fst : G) = g ↔ g ∈ S
|
case mpr
G : Type u_1
inst✝ : Group G
S T : Set G
hST : IsComplement S T
g : G
h1 : 1 ∈ T
h : g ∈ S
⊢ ↑(hST.equiv g).1 = g
|
rw [hST.equiv_fst_eq_self_of_mem_of_one_mem h1 h]
|
no goals
|
becd34388e09e225
|
IsCyclotomicExtension.Rat.Three.lambda_dvd_or_dvd_sub_one_or_dvd_add_one
|
Mathlib/NumberTheory/Cyclotomic/Three.lean
|
/-- Let `(x : 𝓞 K)`. Then we have that `λ` divides one amongst `x`, `x - 1` and `x + 1`. -/
lemma lambda_dvd_or_dvd_sub_one_or_dvd_add_one [NumberField K] [IsCyclotomicExtension {3} ℚ K] :
λ ∣ x ∨ λ ∣ x - 1 ∨ λ ∣ x + 1
|
K : Type u_1
inst✝² : Field K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
x : 𝓞 K
inst✝¹ : NumberField K
inst✝ : IsCyclotomicExtension {3} ℚ K
this : Finite (𝓞 K ⧸ Ideal.span {λ})
⊢ λ ∣ x ∨ λ ∣ x - 1 ∨ λ ∣ x + 1
|
let _ := Fintype.ofFinite (𝓞 K ⧸ Ideal.span {λ})
|
K : Type u_1
inst✝² : Field K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
x : 𝓞 K
inst✝¹ : NumberField K
inst✝ : IsCyclotomicExtension {3} ℚ K
this : Finite (𝓞 K ⧸ Ideal.span {λ})
x✝ : Fintype (𝓞 K ⧸ Ideal.span {λ}) := Fintype.ofFinite (𝓞 K ⧸ Ideal.span {λ})
⊢ λ ∣ x ∨ λ ∣ x - 1 ∨ λ ∣ x + 1
|
40b2b58fa758600e
|
SimpleGraph.Walk.IsPath.snd_of_toSubgraph_adj
|
Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
|
lemma snd_of_toSubgraph_adj {u v v'} {p : G.Walk u v} (hp : p.IsPath)
(hadj : p.toSubgraph.Adj u v') : p.snd = v'
|
V : Type u
G : SimpleGraph V
u v : V
p : G.Walk u v
hp : p.IsPath
i : ℕ
hl1 : p.getVert i = u
hadj : p.toSubgraph.Adj u (p.getVert (i + 1))
hi :
(p.getVert i = u ∧ p.getVert (i + 1) = p.getVert (i + 1) ∨ p.getVert i = p.getVert (i + 1) ∧ p.getVert (i + 1) = u) ∧
i < p.length
⊢ 0 ∈ {i | i ≤ p.length}
|
rw [Set.mem_setOf]
|
V : Type u
G : SimpleGraph V
u v : V
p : G.Walk u v
hp : p.IsPath
i : ℕ
hl1 : p.getVert i = u
hadj : p.toSubgraph.Adj u (p.getVert (i + 1))
hi :
(p.getVert i = u ∧ p.getVert (i + 1) = p.getVert (i + 1) ∨ p.getVert i = p.getVert (i + 1) ∧ p.getVert (i + 1) = u) ∧
i < p.length
⊢ 0 ≤ p.length
|
6a4c9bd87e294aeb
|
Set.univ_div_univ
|
Mathlib/Algebra/Group/Pointwise/Set/Basic.lean
|
@[to_additive (attr := simp)]
lemma univ_div_univ : (univ / univ : Set α) = univ
|
α : Type u_2
inst✝ : DivisionMonoid α
⊢ univ / univ = univ
|
simp [div_eq_mul_inv]
|
no goals
|
ea0f1a3b1c0a164a
|
Affine.Simplex.sum_pointsWithCircumcenter
|
Mathlib/Geometry/Euclidean/Circumcenter.lean
|
theorem sum_pointsWithCircumcenter {α : Type*} [AddCommMonoid α] {n : ℕ}
(f : PointsWithCircumcenterIndex n → α) :
∑ i, f i = (∑ i : Fin (n + 1), f (pointIndex i)) + f circumcenterIndex
|
α : Type u_3
inst✝ : AddCommMonoid α
n : ℕ
f : PointsWithCircumcenterIndex n → α
h : univ = insert circumcenterIndex (Finset.map (pointIndexEmbedding n) univ)
⊢ circumcenterIndex ∉ Finset.map (pointIndexEmbedding n) univ
|
simp_rw [Finset.mem_map, not_exists]
|
α : Type u_3
inst✝ : AddCommMonoid α
n : ℕ
f : PointsWithCircumcenterIndex n → α
h : univ = insert circumcenterIndex (Finset.map (pointIndexEmbedding n) univ)
⊢ ∀ (x : Fin (n + 1)), ¬(x ∈ univ ∧ (pointIndexEmbedding n) x = circumcenterIndex)
|
248891fce28689d6
|
ZMod.castHom_bijective
|
Mathlib/Data/ZMod/Basic.lean
|
theorem castHom_bijective [Fintype R] (h : Fintype.card R = n) :
Function.Bijective (ZMod.castHom (dvd_refl n) R)
|
n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = n
hn : n = 0
⊢ False
|
rw [hn] at h
|
n : ℕ
R : Type u_1
inst✝² : Ring R
inst✝¹ : CharP R n
inst✝ : Fintype R
h : Fintype.card R = 0
hn : n = 0
⊢ False
|
f5948c31783484d7
|
IsIntegralCurve.periodic_xor_injective
|
Mathlib/Geometry/Manifold/IntegralCurve/ExistUnique.lean
|
/-- A global integral curve is injective xor periodic with positive period. -/
lemma IsIntegralCurve.periodic_xor_injective [BoundarylessManifold I M]
(hγ : IsIntegralCurve γ v)
(hv : ContMDiff I I.tangent 1 (fun x ↦ (⟨x, v x⟩ : TangentBundle I M))) :
Xor' (∃ T > 0, Periodic γ T) (Injective γ)
|
case neg
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
H : Type u_2
inst✝⁵ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝⁴ : TopologicalSpace M
inst✝³ : ChartedSpace H M
inst✝² : IsManifold I 1 M
γ : ℝ → M
v : (x : M) → TangentSpace I x
inst✝¹ : T2Space M
inst✝ : BoundarylessManifold I M
hγ : IsIntegralCurve γ v
hv : ContMDiff I I.tangent 1 fun x => { proj := x, snd := v x }
a b : ℝ
heq : γ a = γ b
hne : a ≠ b
hab : 0 ≤ a - b
⊢ Periodic γ (a - b)
|
exact hγ.periodic_of_eq hv heq
|
no goals
|
51957a500664b235
|
four_mul_le_sq_add
|
Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
|
/-- Binary, squared, and division-free **arithmetic mean-geometric mean inequality**
(aka AM-GM inequality) for linearly ordered commutative semirings. -/
lemma four_mul_le_sq_add [ExistsAddOfLE α] [MulPosStrictMono α]
[AddLeftReflectLE α] [AddLeftMono α]
(a b : α) : 4 * a * b ≤ (a + b) ^ 2
|
α : Type u
inst✝⁵ : CommSemiring α
inst✝⁴ : LinearOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosStrictMono α
inst✝¹ : AddLeftReflectLE α
inst✝ : AddLeftMono α
a b : α
⊢ a ^ 2 + b ^ 2 + 2 * a * b = a ^ 2 + 2 * a * b + b ^ 2
|
rw [add_right_comm]
|
no goals
|
38ca5601c78dc32a
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.