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
|
|---|---|---|---|---|---|---|
Submodule.topologicalClosure_eq_top_iff
|
Mathlib/Analysis/InnerProductSpace/Projection.lean
|
theorem Submodule.topologicalClosure_eq_top_iff [CompleteSpace E] :
K.topologicalClosure = ⊤ ↔ Kᗮ = ⊥
|
case mp
𝕜 : Type u_1
E : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
K : Submodule 𝕜 E
inst✝ : CompleteSpace E
h : Kᗮᗮ = ⊤
⊢ Kᗮ = ⊥
|
rw [← Submodule.triorthogonal_eq_orthogonal, h, Submodule.top_orthogonal_eq_bot]
|
no goals
|
2b2708d5ffbe295d
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go_decl_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.lean
|
theorem blastConst.go_decl_eq {aig : AIG α} (i : Nat) (s : AIG.RefVec aig i) (val : BitVec w)
(hi : i ≤ w) :
∀ (curr : Nat) (h1) (h2),
(go aig val i s hi).aig.decls[curr]'h2 = aig.decls[curr]'h1
|
case isFalse
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
i : Nat
s : aig.RefVec i
val : BitVec w
hi : i ≤ w
res : AIG.RefVecEntry α w
h✝ : ¬i < w
hgo : { aig := aig, vec := ⋯ ▸ s } = res
curr✝ : Nat
h1✝ : curr✝ < aig.decls.size
h2✝ : curr✝ < { aig := aig, vec := ⋯ ▸ s }.aig.decls.size
⊢ { aig := aig, vec := ⋯ ▸ s }.aig.decls[curr✝] = aig.decls[curr✝]
|
simp
|
no goals
|
a8695d661d5b3e87
|
Multiset.map_add_left_Icc
|
Mathlib/Algebra/Order/Interval/Multiset.lean
|
lemma map_add_left_Icc (a b c : α) : (Icc a b).map (c + ·) = Icc (c + a) (c + b)
|
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Icc a b) = Icc (c + a) (c + b)
|
rw [Icc, Icc, ← Finset.image_add_left_Icc, Finset.image_val,
((Finset.nodup _).map <| add_right_injective c).dedup]
|
no goals
|
68ad9583fea709f0
|
Submodule.torsionBySet_eq_torsionBySet_span
|
Mathlib/Algebra/Module/Torsion.lean
|
theorem torsionBySet_eq_torsionBySet_span :
torsionBySet R M s = torsionBySet R M (Ideal.span s)
|
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
x : M
hx : x ∈ torsionBySet R M s
⊢ x ∈ torsionBySet R M ↑(Ideal.span s)
|
rw [mem_torsionBySet_iff] at hx ⊢
|
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ ∀ (a : ↑↑(Ideal.span s)), ↑a • x = 0
|
c230c0cb287e0d48
|
UniqueProds.toTwoUniqueProds_of_group
|
Mathlib/Algebra/Group/UniqueProds/Basic.lean
|
theorem toTwoUniqueProds_of_group {G}
[Group G] [UniqueProds G] : TwoUniqueProds G where
uniqueMul_of_one_lt_card {A B} hc
|
case intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
inst✝ : UniqueProds G
A B : Finset G
hc : A.Nonempty ∧ B.Nonempty ∧ (1 < #A ∨ 1 < #B)
a : G
ha : a ∈ A
b : G
hb : b ∈ B
hu : UniqueMul A B a b
C : Finset G := map { toFun := fun x => a⁻¹ * x, inj' := ⋯ } A
D : Finset G := map { toFun := fun x => x * b⁻¹, inj' := ⋯ } B
hcard : 1 < #C ∨ 1 < #D
hC : 1 ∈ C
⊢ ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueMul A B p1.1 p1.2 ∧ UniqueMul A B p2.1 p2.2
|
have hD : 1 ∈ D := mem_map.mpr ⟨b, hb, mul_inv_cancel b⟩
|
case intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
inst✝ : UniqueProds G
A B : Finset G
hc : A.Nonempty ∧ B.Nonempty ∧ (1 < #A ∨ 1 < #B)
a : G
ha : a ∈ A
b : G
hb : b ∈ B
hu : UniqueMul A B a b
C : Finset G := map { toFun := fun x => a⁻¹ * x, inj' := ⋯ } A
D : Finset G := map { toFun := fun x => x * b⁻¹, inj' := ⋯ } B
hcard : 1 < #C ∨ 1 < #D
hC : 1 ∈ C
hD : 1 ∈ D
⊢ ∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueMul A B p1.1 p1.2 ∧ UniqueMul A B p2.1 p2.2
|
17753faf97209b5d
|
MeasureTheory.eLpNorm_one_le_of_le
|
Mathlib/MeasureTheory/Integral/Bochner.lean
|
theorem eLpNorm_one_le_of_le {r : ℝ≥0} (hfint : Integrable f μ) (hfint' : 0 ≤ ∫ x, f x ∂μ)
(hf : ∀ᵐ ω ∂μ, f ω ≤ r) : eLpNorm f 1 μ ≤ 2 * μ Set.univ * r
|
case pos
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ
r : ℝ≥0
hfint : Integrable f μ
hfint' : ∫ (a : α), ↑(-f a).toNNReal ∂μ ≤ ∫ (a : α), ↑(f a).toNNReal ∂μ
hf : ∀ᵐ (ω : α) ∂μ, f ω ≤ ↑r
hr : ¬r = 0
hμ this : IsFiniteMeasure μ
hposbdd : ∫ (ω : α), f ω ⊔ 0 ∂μ ≤ (μ univ).toReal • ↑r
⊢ (∫ (a : α), ‖f a‖ ^ ENNReal.toReal 1 ∂μ) ^ (ENNReal.toReal 1)⁻¹ ≤ (2 * μ univ * ↑r).toReal
|
simp_rw [ENNReal.one_toReal, _root_.inv_one, Real.rpow_one, Real.norm_eq_abs, ←
max_zero_add_max_neg_zero_eq_abs_self, ← Real.coe_toNNReal']
|
case pos
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ
r : ℝ≥0
hfint : Integrable f μ
hfint' : ∫ (a : α), ↑(-f a).toNNReal ∂μ ≤ ∫ (a : α), ↑(f a).toNNReal ∂μ
hf : ∀ᵐ (ω : α) ∂μ, f ω ≤ ↑r
hr : ¬r = 0
hμ this : IsFiniteMeasure μ
hposbdd : ∫ (ω : α), f ω ⊔ 0 ∂μ ≤ (μ univ).toReal • ↑r
⊢ ∫ (a : α), ↑(f a).toNNReal + ↑(-f a).toNNReal ∂μ ≤ (2 * μ univ * ↑r).toReal
|
f01ab8867e396603
|
Associates.factors_eq_top_iff_zero
|
Mathlib/RingTheory/UniqueFactorizationDomain/FactorSet.lean
|
theorem factors_eq_top_iff_zero {a : Associates α} : a.factors = ⊤ ↔ a = 0
|
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
a✝ : Nontrivial α
⊢ a.factors = ⊤ ↔ a = 0
|
exact ⟨fun h ↦ by rwa [← factors_prod a, FactorSet.prod_eq_zero_iff], fun h ↦ h ▸ factors_zero⟩
|
no goals
|
6a5578fd4a14b73f
|
MvPolynomial.eval₂Hom_eq_constantCoeff_of_vars
|
Mathlib/Algebra/MvPolynomial/Variables.lean
|
theorem eval₂Hom_eq_constantCoeff_of_vars (f : R →+* S) {g : σ → S} {p : MvPolynomial σ R}
(hp : ∀ i ∈ p.vars, g i = 0) : eval₂Hom f g p = f (constantCoeff p)
|
case neg.h₀.intro
R : Type u
S : Type v
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → S
p : MvPolynomial σ R
hp : ∀ i ∈ p.vars, g i = 0
h0 : ¬constantCoeff p = 0
d : σ →₀ ℕ
hd : d ∈ p.support
hd0 : d ≠ 0
i : σ
hi : i ∈ d.support
⊢ g i ^ d i = 0
|
rw [hp, zero_pow (Finsupp.mem_support_iff.1 hi)]
|
case neg.h₀.intro.a
R : Type u
S : Type v
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → S
p : MvPolynomial σ R
hp : ∀ i ∈ p.vars, g i = 0
h0 : ¬constantCoeff p = 0
d : σ →₀ ℕ
hd : d ∈ p.support
hd0 : d ≠ 0
i : σ
hi : i ∈ d.support
⊢ i ∈ p.vars
|
9913c8045ed6a111
|
List.isInfix_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Nat/Sublist.lean
|
theorem isInfix_iff : l₁ <:+: l₂ ↔
∃ k, l₁.length + k ≤ l₂.length ∧ ∀ i (h : i < l₁.length), l₂[i + k]? = some l₁[i]
|
case mp.intro.intro.intro
α✝ : Type u_1
l₁ l₂ : List α✝
h : l₁ <:+: l₂
t : List α✝
s : ∀ (i : Nat) (h : i < t.length), l₂[i]? = some t[i]
p' : l₁.length ≤ t.length
p : ∀ (i : Nat) (h : i < l₁.length), t[i + t.length - l₁.length]? = some l₁[i]
⊢ ∀ (i : Nat) (h : i < l₁.length), l₂[i + (t.length - l₁.length)]? = some l₁[i]
|
intro i h
|
case mp.intro.intro.intro
α✝ : Type u_1
l₁ l₂ : List α✝
h✝ : l₁ <:+: l₂
t : List α✝
s : ∀ (i : Nat) (h : i < t.length), l₂[i]? = some t[i]
p' : l₁.length ≤ t.length
p : ∀ (i : Nat) (h : i < l₁.length), t[i + t.length - l₁.length]? = some l₁[i]
i : Nat
h : i < l₁.length
⊢ l₂[i + (t.length - l₁.length)]? = some l₁[i]
|
8c836fc6d0b14b98
|
MulAction.IsBlock.inter
|
Mathlib/GroupTheory/GroupAction/Blocks.lean
|
/-- The intersection of two blocks is a block. -/
@[to_additive "The intersection of two blocks is a block."]
lemma IsBlock.inter {B₁ B₂ : Set X} (h₁ : IsBlock G B₁) (h₂ : IsBlock G B₂) :
IsBlock G (B₁ ∩ B₂)
|
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B₁ B₂ : Set X
h₁ : ∀ ⦃g₁ g₂ : G⦄, (g₁ • B₁ ∩ g₂ • B₁).Nonempty → g₁ • B₁ = g₂ • B₁
h₂ : ∀ ⦃g₁ g₂ : G⦄, (g₁ • B₂ ∩ g₂ • B₂).Nonempty → g₁ • B₂ = g₂ • B₂
⊢ ∀ ⦃g₁ g₂ : G⦄, (g₁ • B₁ ∩ g₁ • B₂ ∩ (g₂ • B₁ ∩ g₂ • B₂)).Nonempty → g₁ • B₁ ∩ g₁ • B₂ = g₂ • B₁ ∩ g₂ • B₂
|
rintro g₁ g₂ ⟨a, ha₁, ha₂⟩
|
case intro.intro
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
B₁ B₂ : Set X
h₁ : ∀ ⦃g₁ g₂ : G⦄, (g₁ • B₁ ∩ g₂ • B₁).Nonempty → g₁ • B₁ = g₂ • B₁
h₂ : ∀ ⦃g₁ g₂ : G⦄, (g₁ • B₂ ∩ g₂ • B₂).Nonempty → g₁ • B₂ = g₂ • B₂
g₁ g₂ : G
a : X
ha₁ : a ∈ g₁ • B₁ ∩ g₁ • B₂
ha₂ : a ∈ g₂ • B₁ ∩ g₂ • B₂
⊢ g₁ • B₁ ∩ g₁ • B₂ = g₂ • B₁ ∩ g₂ • B₂
|
2ca5b21c71032d0b
|
Nat.dvd_mod_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean
|
theorem dvd_mod_iff {k m n : Nat} (h: k ∣ n) : k ∣ m % n ↔ k ∣ m
|
k m n : Nat
h : k ∣ n
⊢ k ∣ m % n ↔ k ∣ m
|
have := Nat.dvd_add_iff_left (m := m % n) <| Nat.dvd_trans h <| Nat.dvd_mul_right n (m / n)
|
k m n : Nat
h : k ∣ n
this : k ∣ m % n ↔ k ∣ m % n + n * (m / n)
⊢ k ∣ m % n ↔ k ∣ m
|
b09e403fb2a88dde
|
Equiv.Perm.signAux_mul
|
Mathlib/GroupTheory/Perm/Sign.lean
|
theorem signAux_mul {n : ℕ} (f g : Perm (Fin n)) : signAux (f * g) = signAux f * signAux g
|
case mk
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
⊢ (if (f * g) a ≤ (f * g) b then -1 else 1) =
(if
f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
-1
else 1) *
if
g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
-1
else 1
|
rw [mul_apply, mul_apply]
|
case mk
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
(if
f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
-1
else 1) *
if
g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
-1
else 1
|
84ff998cb9c928fb
|
Turing.tr_reaches₁
|
Mathlib/Computability/PostTuringMachine.lean
|
theorem tr_reaches₁ {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ a₂}
(aa : tr a₁ a₂) {b₁} (ab : Reaches₁ f₁ a₁ b₁) : ∃ b₂, tr b₁ b₂ ∧ Reaches₁ f₂ a₂ b₂
|
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab : Reaches₁ f₁ a₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches₁ f₂ a₂ b₂
|
induction' ab with c₁ ac c₁ d₁ _ cd IH
|
case single
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ c₁ : σ₁
ac : c₁ ∈ f₁ a₁
⊢ ∃ b₂, tr c₁ b₂ ∧ Reaches₁ f₂ a₂ b₂
case tail
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ c₁ d₁ : σ₁
a✝ : TransGen (fun a b => b ∈ f₁ a) a₁ c₁
cd : d₁ ∈ f₁ c₁
IH : ∃ b₂, tr c₁ b₂ ∧ Reaches₁ f₂ a₂ b₂
⊢ ∃ b₂, tr d₁ b₂ ∧ Reaches₁ f₂ a₂ b₂
|
e28f0270b9420a4c
|
CategoryTheory.epi_iff_surjective_up_to_refinements
|
Mathlib/CategoryTheory/Abelian/Refinements.lean
|
lemma epi_iff_surjective_up_to_refinements (f : X ⟶ Y) :
Epi f ↔ ∀ ⦃A : C⦄ (y : A ⟶ Y),
∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (x : A' ⟶ X), π ≫ y = x ≫ f
|
case mpr
C : Type u_2
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
hf : ∀ ⦃A : C⦄ (y : A ⟶ Y), ∃ A' π, ∃ (_ : Epi π), ∃ x, π ≫ y = x ≫ f
⊢ Epi f
|
obtain ⟨A, π, hπ, a', fac⟩ := hf (𝟙 Y)
|
case mpr.intro.intro.intro.intro
C : Type u_2
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
hf : ∀ ⦃A : C⦄ (y : A ⟶ Y), ∃ A' π, ∃ (_ : Epi π), ∃ x, π ≫ y = x ≫ f
A : C
π : A ⟶ Y
hπ : Epi π
a' : A ⟶ X
fac : π ≫ 𝟙 Y = a' ≫ f
⊢ Epi f
|
8dab997ceac1b3da
|
Nat.mul_add_div
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
|
theorem mul_add_div {m : Nat} (m_pos : m > 0) (x y : Nat) : (m * x + y) / m = x + y / m
|
m : Nat
m_pos : m > 0
x✝ y x : Nat
⊢ (m + y - m) / m = y / m
|
rw [Nat.add_comm, Nat.add_sub_cancel]
|
no goals
|
1f0d931c34325414
|
SimpleGraph.Walk.IsCycle.ncard_neighborSet_toSubgraph_eq_two
|
Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
|
lemma ncard_neighborSet_toSubgraph_eq_two {u v} {p : G.Walk u u} (hpc : p.IsCycle)
(h : v ∈ p.support) : (p.toSubgraph.neighborSet v).ncard = 2
|
case neg
V : Type u
G : SimpleGraph V
u v : V
p : G.Walk u u
hpc : p.IsCycle
i : ℕ
hi : p.getVert i = v ∧ i ≤ p.length
he : i ≠ 0 ∧ i ≠ p.length
⊢ {p.getVert (i - 1), p.getVert (i + 1)}.ncard = 2
|
exact Set.ncard_pair (hpc.getVert_sub_one_neq_getVert_add_one (by omega))
|
no goals
|
ab28954a43d4f7d4
|
MeasureTheory.ae_eq_zero_of_forall_setIntegral_isClosed_eq_zero
|
Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
|
/-- If an integrable function has zero integral on all closed sets, then it is zero
almost everywhere. -/
lemma ae_eq_zero_of_forall_setIntegral_isClosed_eq_zero {μ : Measure β} {f : β → E}
(hf : Integrable f μ) (h'f : ∀ (s : Set β), IsClosed s → ∫ x in s, f x ∂μ = 0) :
f =ᵐ[μ] 0
|
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
β : Type u_3
inst✝² : TopologicalSpace β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
μ : Measure β
f : β → E
hf : Integrable f μ
h'f : ∀ (s : Set β), IsClosed s → ∫ (x : β) in s, f x ∂μ = 0
⊢ f =ᶠ[ae μ] 0
|
suffices ∀ s, MeasurableSet s → ∫ x in s, f x ∂μ = 0 from
hf.ae_eq_zero_of_forall_setIntegral_eq_zero (fun s hs _ ↦ this s hs)
|
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
β : Type u_3
inst✝² : TopologicalSpace β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
μ : Measure β
f : β → E
hf : Integrable f μ
h'f : ∀ (s : Set β), IsClosed s → ∫ (x : β) in s, f x ∂μ = 0
⊢ ∀ (s : Set β), MeasurableSet s → ∫ (x : β) in s, f x ∂μ = 0
|
365da9d95bd79d4b
|
ENNReal.count_const_le_le_of_tsum_le
|
Mathlib/MeasureTheory/Integral/Lebesgue.lean
|
theorem _root_.ENNReal.count_const_le_le_of_tsum_le [MeasurableSingletonClass α] {a : α → ℝ≥0∞}
(a_mble : Measurable a) {c : ℝ≥0∞} (tsum_le_c : ∑' i, a i ≤ c) {ε : ℝ≥0∞} (ε_ne_zero : ε ≠ 0)
(ε_ne_top : ε ≠ ∞) : Measure.count { i : α | ε ≤ a i } ≤ c / ε
|
α : Type u_1
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0∞
a_mble : Measurable a
c : ℝ≥0∞
tsum_le_c : ∫⁻ (a_1 : α), a a_1 ∂count ≤ c
ε : ℝ≥0∞
ε_ne_zero : ε ≠ 0
ε_ne_top : ε ≠ ⊤
⊢ (∫⁻ (a_1 : α), a a_1 ∂count) / ε ≤ c / ε
|
exact ENNReal.div_le_div tsum_le_c rfl.le
|
no goals
|
ce4e73ea7ab5815d
|
MeasureTheory.Submartingale.mul_integral_upcrossingsBefore_le_integral_pos_part
|
Mathlib/Probability/Martingale/Upcrossing.lean
|
theorem Submartingale.mul_integral_upcrossingsBefore_le_integral_pos_part [IsFiniteMeasure μ]
(a b : ℝ) (hf : Submartingale f ℱ μ) (N : ℕ) :
(b - a) * μ[upcrossingsBefore a b f N] ≤ μ[fun ω => (f N ω - a)⁺]
|
case neg
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
f : ℕ → Ω → ℝ
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
a b : ℝ
hf : Submartingale f ℱ μ
N : ℕ
hab : b - a ≤ 0
⊢ (b - a) * ∫ (x : Ω), ↑(upcrossingsBefore a b f N x) ∂μ ≤ ∫ (x : Ω), (fun ω => (f N ω - a)⁺) x ∂μ
|
exact le_trans (mul_nonpos_of_nonpos_of_nonneg hab (by positivity))
(integral_nonneg fun ω => posPart_nonneg _)
|
no goals
|
f5d86ca3fe8817f4
|
LieModule.maxGenEigenSpace_toEnd_eq_top
|
Mathlib/Algebra/Lie/Nilpotent.lean
|
@[simp] lemma maxGenEigenSpace_toEnd_eq_top [IsNilpotent L M] (x : L) :
((toEnd R L M x).maxGenEigenspace 0) = ⊤
|
case h
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNilpotent L M
x : L
m : M
⊢ m ∈ ((toEnd R L M) x).maxGenEigenspace 0 ↔ m ∈ ⊤
|
simp only [Module.End.mem_maxGenEigenspace, zero_smul, sub_zero, Submodule.mem_top,
iff_true]
|
case h
R : Type u
L : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNilpotent L M
x : L
m : M
⊢ ∃ k, ((toEnd R L M) x ^ k) m = 0
|
752679eb38a55f7e
|
MeasureTheory.Measure.lintegral_condKernel_mem
|
Mathlib/Probability/Kernel/Disintegration/Integral.lean
|
lemma lintegral_condKernel_mem {s : Set (β × Ω)} (hs : MeasurableSet s) :
∫⁻ x, ρ.condKernel x {y | (x, y) ∈ s} ∂ρ.fst = ρ s
|
β : Type u_1
Ω : Type u_2
mβ : MeasurableSpace β
inst✝³ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), (ρ.condKernel x) {y | (x, y) ∈ s} ∂ρ.fst = ∫⁻ (a : β), (ρ.condKernel a) (Prod.mk a ⁻¹' s) ∂ρ.fst
|
rfl
|
no goals
|
dd1b430e9eb07fd6
|
Equiv.Perm.card_isConj_eq
|
Mathlib/GroupTheory/Perm/Centralizer.lean
|
theorem card_isConj_eq :
Nat.card {h : Perm α | IsConj g h} =
(Fintype.card α)! /
((Fintype.card α - g.cycleType.sum)! *
g.cycleType.prod *
(∏ n ∈ g.cycleType.toFinset, (g.cycleType.count n)!))
|
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Perm α
⊢ Nat.card ↑{h | IsConj g h} *
((Fintype.card α - g.cycleType.sum)! * g.cycleType.prod *
∏ n ∈ g.cycleType.toFinset, (Multiset.count n g.cycleType)!) =
Nat.card ↑{h | IsConj g h} *
((Fintype.card α - g.cycleType.sum)! * g.cycleType.prod *
∏ n ∈ g.cycleType.toFinset, (Multiset.count n g.cycleType)!)
|
rfl
|
no goals
|
167cd0ded0acc7ee
|
Polynomial.isNoetherianRing
|
Mathlib/RingTheory/Polynomial/Basic.lean
|
theorem Polynomial.isNoetherianRing [inst : IsNoetherianRing R] : IsNoetherianRing R[X] :=
isNoetherianRing_iff.2
⟨fun I : Ideal R[X] =>
let M := inst.wf.min (Set.range I.leadingCoeffNth) ⟨_, ⟨0, rfl⟩⟩
have hm : M ∈ Set.range I.leadingCoeffNth := WellFounded.min_mem _ _ _
let ⟨N, HN⟩ := hm
let ⟨s, hs⟩ := I.is_fg_degreeLE N
have hm2 : ∀ k, I.leadingCoeffNth k ≤ M := fun k =>
Or.casesOn (le_or_lt k N) (fun h => HN ▸ I.leadingCoeffNth_mono h) fun h _ hx =>
Classical.by_contradiction fun hxm =>
haveI : IsNoetherian R R := inst
have : ¬M < I.leadingCoeffNth k
|
case h.inr
R : Type u
inst✝ : CommRing R
inst : IsNoetherianRing R
I : Ideal R[X]
M : Submodule R R := ⋯.min (Set.range I.leadingCoeffNth) ⋯
hm : M ∈ Set.range I.leadingCoeffNth
N : ℕ
HN : I.leadingCoeffNth N = M
s : Finset R[X]
hs : Submodule.span R ↑s = I.degreeLE ↑N
hm2 : ∀ (k : ℕ), I.leadingCoeffNth k ≤ M
hs2 : ∀ {x : R[X]}, x ∈ I.degreeLE ↑N → x ∈ Ideal.span ↑s
this✝ : Submodule.span R[X] ↑s = Ideal.span ↑s
k : ℕ
ih : ∀ m < k, ∀ ⦃p : R[X]⦄, p ∈ I → p.natDegree = m → p ∈ Ideal.span ↑s
p : R[X]
hp : p ∈ I
hn : p.natDegree = k
h : N < k
hp0 : p ≠ 0
this : 0 ≠ 1
⊢ p ∈ Ideal.span ↑s
|
haveI : Nontrivial R := ⟨⟨0, 1, this⟩⟩
|
case h.inr
R : Type u
inst✝ : CommRing R
inst : IsNoetherianRing R
I : Ideal R[X]
M : Submodule R R := ⋯.min (Set.range I.leadingCoeffNth) ⋯
hm : M ∈ Set.range I.leadingCoeffNth
N : ℕ
HN : I.leadingCoeffNth N = M
s : Finset R[X]
hs : Submodule.span R ↑s = I.degreeLE ↑N
hm2 : ∀ (k : ℕ), I.leadingCoeffNth k ≤ M
hs2 : ∀ {x : R[X]}, x ∈ I.degreeLE ↑N → x ∈ Ideal.span ↑s
this✝¹ : Submodule.span R[X] ↑s = Ideal.span ↑s
k : ℕ
ih : ∀ m < k, ∀ ⦃p : R[X]⦄, p ∈ I → p.natDegree = m → p ∈ Ideal.span ↑s
p : R[X]
hp : p ∈ I
hn : p.natDegree = k
h : N < k
hp0 : p ≠ 0
this✝ : 0 ≠ 1
this : Nontrivial R
⊢ p ∈ Ideal.span ↑s
|
2e2f75e5c85b5a04
|
HasStrictFDerivAt.of_local_left_inverse
|
Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
|
theorem HasStrictFDerivAt.of_local_left_inverse {f : E → F} {f' : E ≃L[𝕜] F} {g : F → E} {a : F}
(hg : ContinuousAt g a) (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) (g a))
(hfg : ∀ᶠ y in 𝓝 a, f (g y) = y) : HasStrictFDerivAt g (f'.symm : F →L[𝕜] E) a
|
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ (fun p => f' (g p.1 - g p.2) - (p.1 - p.2)) =o[𝓝 (a, a)] fun p => p.1 - p.2
|
refine ((hf.isLittleO.comp_tendsto hg).symm.congr'
(hfg.mono ?_) (Eventually.of_forall fun _ => rfl)).trans_isBigO ?_
|
case refine_1
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ ∀ (x : F × F),
f (g x.1) = x.1 ∧ f (g x.2) = x.2 →
(fun x => ↑f' ((Prod.map g g x).1 - (Prod.map g g x).2) - (f (Prod.map g g x).1 - f (Prod.map g g x).2)) x =
f' (g x.1 - g x.2) - (x.1 - x.2)
case refine_2
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ ((fun p => p.1 - p.2) ∘ Prod.map g g) =O[𝓝 (a, a)] fun p => p.1 - p.2
|
d8cfc8e27908f328
|
Set.Iio_diff_Iic
|
Mathlib/Order/Interval/Set/Basic.lean
|
theorem Iio_diff_Iic : Iio b \ Iic a = Ioo a b
|
α : Type u_1
inst✝ : LinearOrder α
a b : α
⊢ Iio b \ Iic a = Ioo a b
|
rw [diff_eq, compl_Iic, inter_comm, Ioi_inter_Iio]
|
no goals
|
5076b6ab365f9ef8
|
Finset.SupIndep.sigma
|
Mathlib/Order/SupIndep.lean
|
theorem SupIndep.sigma {β : ι → Type*} {s : Finset ι} {g : ∀ i, Finset (β i)}
{f : Sigma β → α} (hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩)
(hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩) : (s.sigma g).SupIndep f
|
case mk.mk
α : Type u_1
ι : Type u_3
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
β : ι → Type u_5
s : Finset ι
g : (i : ι) → Finset (β i)
f : Sigma β → α
hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩
hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩
t : Finset ((i : ι) × β i)
ht : t ⊆ s.sigma g
i : ι
b : β i
hi : ⟨i, b⟩.fst ∈ s ∧ ⟨i, b⟩.snd ∈ g ⟨i, b⟩.fst
hit : ⟨i, b⟩ ∉ t
j : ι
c : β j
hbc : ⟨i, b⟩ ≠ ⟨j, c⟩
hj : ⟨j, c⟩.fst ∈ s ∧ ⟨j, c⟩.snd ∈ g ⟨j, c⟩.fst
⊢ Disjoint (f ⟨i, b⟩) (f ⟨j, c⟩)
|
obtain rfl | hij := eq_or_ne i j
|
case mk.mk.inl
α : Type u_1
ι : Type u_3
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
β : ι → Type u_5
s : Finset ι
g : (i : ι) → Finset (β i)
f : Sigma β → α
hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩
hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩
t : Finset ((i : ι) × β i)
ht : t ⊆ s.sigma g
i : ι
b : β i
hi : ⟨i, b⟩.fst ∈ s ∧ ⟨i, b⟩.snd ∈ g ⟨i, b⟩.fst
hit : ⟨i, b⟩ ∉ t
c : β i
hbc : ⟨i, b⟩ ≠ ⟨i, c⟩
hj : ⟨i, c⟩.fst ∈ s ∧ ⟨i, c⟩.snd ∈ g ⟨i, c⟩.fst
⊢ Disjoint (f ⟨i, b⟩) (f ⟨i, c⟩)
case mk.mk.inr
α : Type u_1
ι : Type u_3
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
β : ι → Type u_5
s : Finset ι
g : (i : ι) → Finset (β i)
f : Sigma β → α
hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩
hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩
t : Finset ((i : ι) × β i)
ht : t ⊆ s.sigma g
i : ι
b : β i
hi : ⟨i, b⟩.fst ∈ s ∧ ⟨i, b⟩.snd ∈ g ⟨i, b⟩.fst
hit : ⟨i, b⟩ ∉ t
j : ι
c : β j
hbc : ⟨i, b⟩ ≠ ⟨j, c⟩
hj : ⟨j, c⟩.fst ∈ s ∧ ⟨j, c⟩.snd ∈ g ⟨j, c⟩.fst
hij : i ≠ j
⊢ Disjoint (f ⟨i, b⟩) (f ⟨j, c⟩)
|
7fa06dd50219bf7d
|
List.contains_eq_any_beq
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
|
theorem contains_eq_any_beq [BEq α] (l : List α) (a : α) : l.contains a = l.any (a == ·)
|
α : Type u_1
inst✝ : BEq α
l : List α
a : α
⊢ l.contains a = l.any fun x => a == x
|
induction l with simp | cons b l => cases b == a <;> simp [*]
|
no goals
|
fb26e2848314e439
|
CategoryTheory.InitiallySmall.exists_small_weakly_initial_set
|
Mathlib/CategoryTheory/Limits/FinallySmall.lean
|
theorem InitiallySmall.exists_small_weakly_initial_set [InitiallySmall.{w} J] :
∃ (s : Set J) (_ : Small.{w} s), ∀ i, ∃ j ∈ s, Nonempty (j ⟶ i)
|
case intro
J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : InitiallySmall J
i : J
f : CostructuredArrow (fromInitialModel J) i
⊢ ∃ j ∈ Set.range (fromInitialModel J).obj, Nonempty (j ⟶ i)
|
exact ⟨(fromInitialModel J).obj f.left, Set.mem_range_self _, ⟨f.hom⟩⟩
|
no goals
|
a939e0d8e64f8cce
|
MeasureTheory.crossing_pos_eq
|
Mathlib/Probability/Martingale/Upcrossing.lean
|
theorem crossing_pos_eq (hab : a < b) :
upperCrossingTime 0 (b - a) (fun n ω => (f n ω - a)⁺) N n = upperCrossingTime a b f N n ∧
lowerCrossingTime 0 (b - a) (fun n ω => (f n ω - a)⁺) N n = lowerCrossingTime a b f N n
|
case zero.h
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
N n : ℕ
hab : a < b
hab' : 0 < b - a
hf : ∀ (ω : Ω) (i : ℕ), b - a ≤ (f i ω - a)⁺ ↔ b ≤ f i ω
hf' : ∀ (ω : Ω) (i : ℕ), (f i ω - a)⁺ ≤ 0 ↔ f i ω ≤ a
ω : Ω
⊢ (if ∃ j ∈ Set.Icc ⊥ N, (f j ω - a)⁺ ∈ Set.Iic 0 then sInf (Set.Icc ⊥ N ∩ {i | (f i ω - a)⁺ ≤ 0}) else N) =
if ∃ j ∈ Set.Icc ⊥ N, f j ω ∈ Set.Iic a then sInf (Set.Icc ⊥ N ∩ {i | f i ω ≤ a}) else N
|
split_ifs with h₁ h₂ h₂
|
case pos
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
N n : ℕ
hab : a < b
hab' : 0 < b - a
hf : ∀ (ω : Ω) (i : ℕ), b - a ≤ (f i ω - a)⁺ ↔ b ≤ f i ω
hf' : ∀ (ω : Ω) (i : ℕ), (f i ω - a)⁺ ≤ 0 ↔ f i ω ≤ a
ω : Ω
h₁ : ∃ j ∈ Set.Icc ⊥ N, (f j ω - a)⁺ ∈ Set.Iic 0
h₂ : ∃ j ∈ Set.Icc ⊥ N, f j ω ∈ Set.Iic a
⊢ sInf (Set.Icc ⊥ N ∩ {i | (f i ω - a)⁺ ≤ 0}) = sInf (Set.Icc ⊥ N ∩ {i | f i ω ≤ a})
case neg
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
N n : ℕ
hab : a < b
hab' : 0 < b - a
hf : ∀ (ω : Ω) (i : ℕ), b - a ≤ (f i ω - a)⁺ ↔ b ≤ f i ω
hf' : ∀ (ω : Ω) (i : ℕ), (f i ω - a)⁺ ≤ 0 ↔ f i ω ≤ a
ω : Ω
h₁ : ∃ j ∈ Set.Icc ⊥ N, (f j ω - a)⁺ ∈ Set.Iic 0
h₂ : ¬∃ j ∈ Set.Icc ⊥ N, f j ω ∈ Set.Iic a
⊢ sInf (Set.Icc ⊥ N ∩ {i | (f i ω - a)⁺ ≤ 0}) = N
case pos
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
N n : ℕ
hab : a < b
hab' : 0 < b - a
hf : ∀ (ω : Ω) (i : ℕ), b - a ≤ (f i ω - a)⁺ ↔ b ≤ f i ω
hf' : ∀ (ω : Ω) (i : ℕ), (f i ω - a)⁺ ≤ 0 ↔ f i ω ≤ a
ω : Ω
h₁ : ¬∃ j ∈ Set.Icc ⊥ N, (f j ω - a)⁺ ∈ Set.Iic 0
h₂ : ∃ j ∈ Set.Icc ⊥ N, f j ω ∈ Set.Iic a
⊢ N = sInf (Set.Icc ⊥ N ∩ {i | f i ω ≤ a})
case neg
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
N n : ℕ
hab : a < b
hab' : 0 < b - a
hf : ∀ (ω : Ω) (i : ℕ), b - a ≤ (f i ω - a)⁺ ↔ b ≤ f i ω
hf' : ∀ (ω : Ω) (i : ℕ), (f i ω - a)⁺ ≤ 0 ↔ f i ω ≤ a
ω : Ω
h₁ : ¬∃ j ∈ Set.Icc ⊥ N, (f j ω - a)⁺ ∈ Set.Iic 0
h₂ : ¬∃ j ∈ Set.Icc ⊥ N, f j ω ∈ Set.Iic a
⊢ N = N
|
3016c9a152ee0783
|
Equiv.Perm.signAux3_mul_and_swap
|
Mathlib/GroupTheory/Perm/Sign.lean
|
theorem signAux3_mul_and_swap [Finite α] (f g : Perm α) (s : Multiset α) (hs : ∀ x, x ∈ s) :
signAux3 (f * g) hs = signAux3 f hs * signAux3 g hs ∧
Pairwise fun x y => signAux3 (swap x y) hs = -1
|
case intro.intro
α : Type u
inst✝¹ : DecidableEq α
inst✝ : Finite α
f g : Perm α
s : Multiset α
hs : ∀ (x : α), x ∈ s
n : ℕ
e : α ≃ Fin n
⊢ (f * g).signAux3 hs = f.signAux3 hs * g.signAux3 hs ∧ Pairwise fun x y => (swap x y).signAux3 hs = -1
|
induction s using Quotient.inductionOn with | _ l => ?_
|
case intro.intro.h
α : Type u
inst✝¹ : DecidableEq α
inst✝ : Finite α
f g : Perm α
n : ℕ
e : α ≃ Fin n
l : List α
hs : ∀ (x : α), x ∈ ⟦l⟧
⊢ (f * g).signAux3 hs = f.signAux3 hs * g.signAux3 hs ∧ Pairwise fun x y => (swap x y).signAux3 hs = -1
|
e47fa89a1e6e7e6b
|
Submodule.map₂_flip
|
Mathlib/Algebra/Module/Submodule/Bilinear.lean
|
theorem map₂_flip (f : M →ₗ[R] N →ₗ[R] P) (p : Submodule R M) (q : Submodule R N) :
map₂ f.flip q p = map₂ f p q
|
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
p : Submodule R M
q : Submodule R N
⊢ map₂ f.flip q p = map₂ f p q
|
rw [map₂_eq_span_image2, map₂_eq_span_image2, Set.image2_swap]
|
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
p : Submodule R M
q : Submodule R N
⊢ span R (image2 (fun a b => (f.flip b) a) ↑p ↑q) = span R (image2 (fun m n => (f m) n) ↑p ↑q)
|
c2948043df7d31d6
|
preNormEDS'_zero
|
Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
|
@[simp]
lemma preNormEDS'_zero : preNormEDS' b c d 0 = 0
|
R : Type u
inst✝ : CommRing R
b c d : R
⊢ preNormEDS' b c d 0 = 0
|
rw [preNormEDS']
|
no goals
|
8216425111a51661
|
Vector.zipWith_eq_append_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Zip.lean
|
theorem zipWith_eq_append_iff {f : α → β → γ} {l₁ : Vector α (n + m)} {l₂ : Vector β (n + m)} :
zipWith f l₁ l₂ = l₁' ++ l₂' ↔
∃ w x y z, l₁ = w ++ x ∧ l₂ = y ++ z ∧ l₁' = zipWith f w y ∧ l₂' = zipWith f x z
|
case mk.mk.mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → γ
l₁ : Array α
l₂ : Array β
l₁' l₂' : Array γ
h₁ : l₁.size = l₁'.size + l₂'.size
h₂ : l₂.size = l₁'.size + l₂'.size
⊢ (∃ w x y z, w.size = y.size ∧ l₁ = w ++ x ∧ l₂ = y ++ z ∧ l₁' = Array.zipWith f w y ∧ l₂' = Array.zipWith f x z) ↔
∃ w x y z,
l₁ = w.toArray ++ x.toArray ∧
l₂ = y.toArray ++ z.toArray ∧
l₁' = Array.zipWith f w.toArray y.toArray ∧ l₂' = Array.zipWith f x.toArray z.toArray
|
constructor
|
case mk.mk.mk.mk.mp
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → γ
l₁ : Array α
l₂ : Array β
l₁' l₂' : Array γ
h₁ : l₁.size = l₁'.size + l₂'.size
h₂ : l₂.size = l₁'.size + l₂'.size
⊢ (∃ w x y z, w.size = y.size ∧ l₁ = w ++ x ∧ l₂ = y ++ z ∧ l₁' = Array.zipWith f w y ∧ l₂' = Array.zipWith f x z) →
∃ w x y z,
l₁ = w.toArray ++ x.toArray ∧
l₂ = y.toArray ++ z.toArray ∧
l₁' = Array.zipWith f w.toArray y.toArray ∧ l₂' = Array.zipWith f x.toArray z.toArray
case mk.mk.mk.mk.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → γ
l₁ : Array α
l₂ : Array β
l₁' l₂' : Array γ
h₁ : l₁.size = l₁'.size + l₂'.size
h₂ : l₂.size = l₁'.size + l₂'.size
⊢ (∃ w x y z,
l₁ = w.toArray ++ x.toArray ∧
l₂ = y.toArray ++ z.toArray ∧
l₁' = Array.zipWith f w.toArray y.toArray ∧ l₂' = Array.zipWith f x.toArray z.toArray) →
∃ w x y z, w.size = y.size ∧ l₁ = w ++ x ∧ l₂ = y ++ z ∧ l₁' = Array.zipWith f w y ∧ l₂' = Array.zipWith f x z
|
5f549609bded35f4
|
LieSubmodule.coe_lieSpan_submodule_eq_iff
|
Mathlib/Algebra/Lie/Submodule.lean
|
theorem coe_lieSpan_submodule_eq_iff {p : Submodule R M} :
(lieSpan R L (p : Set M) : Submodule R M) = p ↔ ∃ N : LieSubmodule R L M, ↑N = p
|
case mp
R : Type u
L : Type v
M : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : LieRingModule L M
p : Submodule R M
h : ↑(lieSpan R L ↑p) = p
⊢ ∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p
|
intro x m hm
|
case mp
R : Type u
L : Type v
M : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : LieRingModule L M
p : Submodule R M
h : ↑(lieSpan R L ↑p) = p
x : L
m : M
hm : m ∈ p
⊢ ⁅x, m⁆ ∈ p
|
d79ccad0b81418ff
|
RingHom.isIntegralElem_leadingCoeff_mul
|
Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
|
theorem RingHom.isIntegralElem_leadingCoeff_mul (h : p.eval₂ f x = 0) :
f.IsIntegralElem (f p.leadingCoeff * x)
|
R : Type u_1
S : Type u_4
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
p : R[X]
x : S
h : eval₂ f x p = 0
⊢ f.IsIntegralElem (f p.leadingCoeff * x)
|
by_cases h' : 1 ≤ p.natDegree
|
case pos
R : Type u_1
S : Type u_4
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
p : R[X]
x : S
h : eval₂ f x p = 0
h' : 1 ≤ p.natDegree
⊢ f.IsIntegralElem (f p.leadingCoeff * x)
case neg
R : Type u_1
S : Type u_4
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
p : R[X]
x : S
h : eval₂ f x p = 0
h' : ¬1 ≤ p.natDegree
⊢ f.IsIntegralElem (f p.leadingCoeff * x)
|
4106733008ad0ff9
|
Matrix.inv_zero
|
Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
|
theorem inv_zero : (0 : Matrix n n α)⁻¹ = 0
|
case inr.inl.a
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
ht : Nontrivial α
hc this : IsEmpty n
i j✝ : n
⊢ 0⁻¹ i j✝ = 0 i j✝
|
exact (IsEmpty.false i).elim
|
no goals
|
c56610e4c48982cf
|
Nat.descFactorial_le
|
Mathlib/Data/Nat/Factorial/Basic.lean
|
theorem descFactorial_le (n : ℕ) {k m : ℕ} (h : k ≤ m) :
k.descFactorial n ≤ m.descFactorial n
|
n k m : ℕ
h : k ≤ m
⊢ k.descFactorial n ≤ m.descFactorial n
|
induction n with
| zero => rfl
| succ n ih =>
rw [descFactorial_succ, descFactorial_succ]
exact Nat.mul_le_mul (Nat.sub_le_sub_right h n) ih
|
no goals
|
d456a0d47d0a2baf
|
sum_div_nat_floor_pow_sq_le_div_sq
|
Mathlib/Analysis/SpecificLimits/FloorPow.lean
|
theorem sum_div_nat_floor_pow_sq_le_div_sq (N : ℕ) {j : ℝ} (hj : 0 < j) {c : ℝ} (hc : 1 < c) :
(∑ i ∈ range N with j < ⌊c ^ i⌋₊, (1 : ℝ) / (⌊c ^ i⌋₊ : ℝ) ^ 2) ≤
c ^ 5 * (c - 1)⁻¹ ^ 3 / j ^ 2
|
N : ℕ
j : ℝ
hj : 0 < j
c : ℝ
hc : 1 < c
⊢ ∑ i ∈ filter (fun i => j < ↑⌊c ^ i⌋₊) (range N), 1 / ↑⌊c ^ i⌋₊ ^ 2 ≤ c ^ 5 * (c - 1)⁻¹ ^ 3 / j ^ 2
|
have cpos : 0 < c := zero_lt_one.trans hc
|
N : ℕ
j : ℝ
hj : 0 < j
c : ℝ
hc : 1 < c
cpos : 0 < c
⊢ ∑ i ∈ filter (fun i => j < ↑⌊c ^ i⌋₊) (range N), 1 / ↑⌊c ^ i⌋₊ ^ 2 ≤ c ^ 5 * (c - 1)⁻¹ ^ 3 / j ^ 2
|
a23322a47b698b23
|
LieSubmodule.ucs_le_of_normalizer_eq_self
|
Mathlib/Algebra/Lie/Nilpotent.lean
|
theorem ucs_le_of_normalizer_eq_self (h : N₁.normalizer = N₁) (k : ℕ) :
(⊥ : LieSubmodule R L M).ucs k ≤ N₁
|
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
N₁ : LieSubmodule R L M
inst✝ : LieModule R L M
h : N₁.normalizer = N₁
k : ℕ
⊢ ucs k ⊥ ≤ N₁
|
rw [← ucs_eq_self_of_normalizer_eq_self h k]
|
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
N₁ : LieSubmodule R L M
inst✝ : LieModule R L M
h : N₁.normalizer = N₁
k : ℕ
⊢ ucs k ⊥ ≤ ucs k N₁
|
14ab1f8caa3b3baf
|
isLocalHom_of_le_jacobson_bot
|
Mathlib/RingTheory/Henselian.lean
|
theorem isLocalHom_of_le_jacobson_bot {R : Type*} [CommRing R] (I : Ideal R)
(h : I ≤ Ideal.jacobson ⊥) : IsLocalHom (Ideal.Quotient.mk I)
|
case h
R : Type u_1
inst✝ : CommRing R
I : Ideal R
h : I ≤ ⊥.jacobson
a b : R
hb : a * b - 1 ∈ I
⊢ a * b - 1 ∈ ⊥.jacobson
|
exact h hb
|
no goals
|
a961c7da2da42bc3
|
BitVec.msb_umod
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem msb_umod {x y : BitVec w} :
(x % y).msb = (x.msb && (x < y || y == 0#w))
|
w : Nat
x y : BitVec w
⊢ (x % y).msb = (x.msb && (decide (x < y) || y == 0#w))
|
rw [msb_eq_decide, toNat_umod]
|
w : Nat
x y : BitVec w
⊢ decide (2 ^ (w - 1) ≤ x.toNat % y.toNat) = (x.msb && (decide (x < y) || y == 0#w))
|
a4b9057a3dee0f33
|
Sylow.normal_of_all_max_subgroups_normal
|
Mathlib/GroupTheory/Sylow.lean
|
theorem normal_of_all_max_subgroups_normal [Finite G]
(hnc : ∀ H : Subgroup G, IsCoatom H → H.Normal) {p : ℕ} [Fact p.Prime] [Finite (Sylow p G)]
(P : Sylow p G) : P.Normal :=
normalizer_eq_top_iff.mp
(by
rcases eq_top_or_exists_le_coatom P.normalizer with (heq | ⟨K, hK, hNK⟩)
· exact heq
· haveI := hnc _ hK
have hPK : P ≤ K := le_trans le_normalizer hNK
refine (hK.1 ?_).elim
rw [← sup_of_le_right hNK, P.normalizer_sup_eq_top' hPK])
|
case inr.intro.intro
G : Type u
inst✝³ : Group G
inst✝² : Finite G
hnc : ∀ (H : Subgroup G), IsCoatom H → H.Normal
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
K : Subgroup G
hK : IsCoatom K
hNK : (↑P).normalizer ≤ K
this : K.Normal
hPK : ↑P ≤ K
⊢ K = ⊤
|
rw [← sup_of_le_right hNK, P.normalizer_sup_eq_top' hPK]
|
no goals
|
5ffcd9d1c9397554
|
RingHom.IsStableUnderBaseChange.mk
|
Mathlib/RingTheory/RingHomProperties.lean
|
theorem IsStableUnderBaseChange.mk (h₁ : RespectsIso @P)
(h₂ :
∀ ⦃R S T⦄ [CommRing R] [CommRing S] [CommRing T],
∀ [Algebra R S] [Algebra R T],
P (algebraMap R T) →
P (Algebra.TensorProduct.includeLeftRingHom : S →+* TensorProduct R S T)) :
IsStableUnderBaseChange @P
|
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
h₁ : RespectsIso P
h₂ :
∀ ⦃R S T : Type u⦄ [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T] [inst_3 : Algebra R S]
[inst_4 : Algebra R T], P (algebraMap R T) → P Algebra.TensorProduct.includeLeftRingHom
R S R' S' : Type u
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : CommRing R'
inst✝⁷ : CommRing S'
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R R'
inst✝⁴ : Algebra R S'
inst✝³ : Algebra S S'
inst✝² : Algebra R' S'
inst✝¹ : IsScalarTower R S S'
inst✝ : IsScalarTower R R' S'
h : Algebra.IsPushout R S R' S'
H : P (algebraMap R S)
e : TensorProduct R R' S ≃ₛₗ[id R'] S' := ⋯.equiv
f' : TensorProduct R R' S →ₐ[R] S' :=
Algebra.TensorProduct.productMap (IsScalarTower.toAlgHom R R' S') (IsScalarTower.toAlgHom R S S')
this : ∀ (x : TensorProduct R R' S), e x = f' x
x y : TensorProduct R R' S
⊢ f' (x * y) = f' x * f' y
|
exact map_mul f' _ _
|
no goals
|
b9f11fd814b95109
|
MeasureTheory.StronglyMeasurable.integral_prod_right
|
Mathlib/MeasureTheory/Integral/Prod.lean
|
theorem MeasureTheory.StronglyMeasurable.integral_prod_right [SFinite ν] ⦃f : α → β → E⦄
(hf : StronglyMeasurable (uncurry f)) : StronglyMeasurable fun x => ∫ y, f x y ∂ν
|
case pos
α : Type u_1
β : Type u_2
E : Type u_3
inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
ν : Measure β
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : SFinite ν
f : α → β → E
hf : StronglyMeasurable (uncurry f)
hE : CompleteSpace E
this✝¹ : MeasurableSpace E := borel E
this✝ : BorelSpace E
this : SeparableSpace ↑(range (uncurry f) ∪ {0})
s : ℕ → SimpleFunc (α × β) E := SimpleFunc.approxOn (uncurry f) ⋯ (range (uncurry f) ∪ {0}) 0 ⋯
s' : ℕ → α → SimpleFunc β E := fun n x => (s n).comp (Prod.mk x) ⋯
f' : ℕ → α → E := fun n => {x | Integrable (f x) ν}.indicator fun x => SimpleFunc.integral ν (s' n x)
hf' : ∀ (n : ℕ), StronglyMeasurable (f' n)
h2f' : Tendsto f' atTop (𝓝 fun x => ∫ (y : β), f x y ∂ν)
⊢ StronglyMeasurable fun x => ∫ (y : β), f x y ∂ν
|
exact stronglyMeasurable_of_tendsto _ hf' h2f'
|
no goals
|
8f3d348cb36760b7
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.assignmentsInvariant_insertRupUnits_of_assignmentsInvariant
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.lean
|
theorem assignmentsInvariant_insertRupUnits_of_assignmentsInvariant {n : Nat} (f : DefaultFormula n) (f_readyForRupAdd : ReadyForRupAdd f)
(units : CNF.Clause (PosFin n)) :
AssignmentsInvariant (insertRupUnits f units).1
|
n : Nat
f : DefaultFormula n
f_readyForRupAdd : f.ReadyForRupAdd
units : CNF.Clause (PosFin n)
h :
let assignments := (f.insertRupUnits units).fst.assignments;
let_fun hsize := ⋯;
let rupUnits := (f.insertRupUnits units).fst.rupUnits;
InsertUnitInvariant f.assignments ⋯ rupUnits assignments hsize
⊢ (f.insertRupUnits units).fst.assignments.size = n
|
rw [size_assignments_insertRupUnits, f_readyForRupAdd.2.1]
|
no goals
|
7537b9cac0fe9952
|
ProbabilityTheory.paretoCDFReal_eq_integral
|
Mathlib/Probability/Distributions/Pareto.lean
|
/-- CDF of the Pareto distribution equals the integral of the PDF. -/
lemma paretoCDFReal_eq_integral (ht : 0 < t) (hr : 0 < r) (x : ℝ) :
cdf (paretoMeasure t r) x = ∫ x in Iic x, paretoPDFReal t r x
|
t r : ℝ
ht : 0 < t
hr : 0 < r
x : ℝ
⊢ ↑(cdf (paretoMeasure t r)) x = ∫ (x : ℝ) in Iic x, paretoPDFReal t r x
|
have : IsProbabilityMeasure (paretoMeasure t r) := isProbabilityMeasure_paretoMeasure ht hr
|
t r : ℝ
ht : 0 < t
hr : 0 < r
x : ℝ
this : IsProbabilityMeasure (paretoMeasure t r)
⊢ ↑(cdf (paretoMeasure t r)) x = ∫ (x : ℝ) in Iic x, paretoPDFReal t r x
|
186b65518841aa4b
|
IsSelfAdjoint.map_spectrum_real
|
Mathlib/Analysis/CStarAlgebra/Hom.lean
|
lemma IsSelfAdjoint.map_spectrum_real {F A B : Type*} [CStarAlgebra A] [CStarAlgebra B]
[FunLike F A B] [AlgHomClass F ℂ A B] [StarHomClass F A B]
{a : A} (ha : IsSelfAdjoint a) (φ : F) (hφ : Function.Injective φ) :
spectrum ℝ (φ a) = spectrum ℝ a
|
F : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CStarAlgebra A
inst✝³ : CStarAlgebra B
inst✝² : FunLike F A B
inst✝¹ : AlgHomClass F ℂ A B
inst✝ : StarHomClass F A B
a : A
ha : IsSelfAdjoint a
φ : F
hφ : Function.Injective ⇑φ
h_spec : spectrum ℝ ((StarAlgHom.restrictScalars ℝ ↑φ) a) ⊆ spectrum ℝ a
⊢ spectrum ℝ (φ a) = spectrum ℝ a
|
refine Set.eq_of_subset_of_subset h_spec fun x hx ↦ ?_
|
F : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CStarAlgebra A
inst✝³ : CStarAlgebra B
inst✝² : FunLike F A B
inst✝¹ : AlgHomClass F ℂ A B
inst✝ : StarHomClass F A B
a : A
ha : IsSelfAdjoint a
φ : F
hφ : Function.Injective ⇑φ
h_spec : spectrum ℝ ((StarAlgHom.restrictScalars ℝ ↑φ) a) ⊆ spectrum ℝ a
x : ℝ
hx : x ∈ spectrum ℝ a
⊢ x ∈ spectrum ℝ (φ a)
|
50868c8d7abd5f84
|
LocalSubring.map_maximalIdeal_eq_top_of_isMax
|
Mathlib/RingTheory/Valuation/LocalSubring.lean
|
lemma LocalSubring.map_maximalIdeal_eq_top_of_isMax {R : LocalSubring K}
(hR : IsMax R) {S : Subring K} (hS : R.toSubring < S) :
(maximalIdeal R.toSubring).map (Subring.inclusion hS.le) = ⊤
|
case mk
K : Type u_3
inst✝ : Field K
R : LocalSubring K
hR : IsMax R
S : Subring K
hS : R.toSubring < S
mR : Ideal ↥S := Ideal.map (Subring.inclusion ⋯) (maximalIdeal ↥R.toSubring)
h_is_not_top : ¬Ideal.map (Subring.inclusion ⋯) (maximalIdeal ↥R.toSubring) = ⊤
M : Ideal ↥S
h_is_max : M.IsMaximal
h_incl : Ideal.map (Subring.inclusion ⋯) (maximalIdeal ↥R.toSubring) ≤ M
fSₘ : LocalSubring K := ofPrime S M
a : K
h_a_inR : a ∈ R.toSubring
h_fa_isUnit : ⟨a, ⋯⟩ ∈ M.primeCompl
h : ¬IsUnit ⟨a, h_a_inR⟩
⊢ False
|
rw [← mem_nonunits_iff, ← mem_maximalIdeal] at h
|
case mk
K : Type u_3
inst✝ : Field K
R : LocalSubring K
hR : IsMax R
S : Subring K
hS : R.toSubring < S
mR : Ideal ↥S := Ideal.map (Subring.inclusion ⋯) (maximalIdeal ↥R.toSubring)
h_is_not_top : ¬Ideal.map (Subring.inclusion ⋯) (maximalIdeal ↥R.toSubring) = ⊤
M : Ideal ↥S
h_is_max : M.IsMaximal
h_incl : Ideal.map (Subring.inclusion ⋯) (maximalIdeal ↥R.toSubring) ≤ M
fSₘ : LocalSubring K := ofPrime S M
a : K
h_a_inR : a ∈ R.toSubring
h_fa_isUnit : ⟨a, ⋯⟩ ∈ M.primeCompl
h : ⟨a, h_a_inR⟩ ∈ maximalIdeal ↥R.toSubring
⊢ False
|
5f96bfa4acaf9956
|
Std.Tactic.BVDecide.BVExpr.bitblast.mkOverflowBit.go_decl_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.lean
|
theorem go_decl_eq {aig : AIG α} {cin} {lhs rhs : AIG.RefVec aig w} :
∀ (idx : Nat) (h1) (h2),
(go aig lhs rhs curr cin).aig.decls[idx]'h2 = aig.decls[idx]'h1
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w curr : Nat
aig : AIG α
cin : aig.Ref
lhs rhs : aig.RefVec w
res : AIG.Entrypoint α
hgo :
(if hidx : curr < w then
go (mkFullAdderCarry aig { lhs := lhs.get curr hidx, rhs := rhs.get curr hidx, cin := cin }).aig (lhs.cast ⋯)
(rhs.cast ⋯) (curr + 1)
(mkFullAdderCarry aig { lhs := lhs.get curr hidx, rhs := rhs.get curr hidx, cin := cin }).ref
else { aig := aig, ref := cin }) =
res
⊢ ∀ (idx : Nat) (h1 : idx < aig.decls.size) (h2 : idx < res.aig.decls.size), res.aig.decls[idx] = aig.decls[idx]
|
split at hgo
|
case isTrue
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w curr : Nat
aig : AIG α
cin : aig.Ref
lhs rhs : aig.RefVec w
res : AIG.Entrypoint α
h✝ : curr < w
hgo :
go (mkFullAdderCarry aig { lhs := lhs.get curr h✝, rhs := rhs.get curr h✝, cin := cin }).aig (lhs.cast ⋯) (rhs.cast ⋯)
(curr + 1) (mkFullAdderCarry aig { lhs := lhs.get curr h✝, rhs := rhs.get curr h✝, cin := cin }).ref =
res
⊢ ∀ (idx : Nat) (h1 : idx < aig.decls.size) (h2 : idx < res.aig.decls.size), res.aig.decls[idx] = aig.decls[idx]
case isFalse
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w curr : Nat
aig : AIG α
cin : aig.Ref
lhs rhs : aig.RefVec w
res : AIG.Entrypoint α
h✝ : ¬curr < w
hgo : { aig := aig, ref := cin } = res
⊢ ∀ (idx : Nat) (h1 : idx < aig.decls.size) (h2 : idx < res.aig.decls.size), res.aig.decls[idx] = aig.decls[idx]
|
0e1562c4999c3b0c
|
SzemerediRegularity.eps_le_card_star_div
|
Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean
|
theorem eps_le_card_star_div [Nonempty α] (hPα : #P.parts * 16 ^ #P.parts ≤ card α)
(hPε : ↑100 ≤ ↑4 ^ #P.parts * ε ^ 5) (hε₁ : ε ≤ 1) (hU : U ∈ P.parts) (hV : V ∈ P.parts)
(hUV : U ≠ V) (hunif : ¬G.IsUniform ε U V) :
↑4 / ↑5 * ε ≤ #(star hP G ε hU V) / ↑4 ^ #P.parts
|
case h₁.h₂.h.hba
α : Type u_1
inst✝³ : Fintype α
inst✝² : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
U V : Finset α
inst✝ : Nonempty α
hPα : #P.parts * 16 ^ #P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ #P.parts * ε ^ 5
hε₁ : ε ≤ 1
hU : U ∈ P.parts
hV : V ∈ P.parts
hUV : U ≠ V
hunif : ¬G.IsUniform ε U V
hm : 0 ≤ 1 - (↑m)⁻¹
hε : 0 ≤ 1 - ε / 10
hε₀ : 0 < ε
⊢ 9 ≤ ↑m
case h₂
α : Type u_1
inst✝³ : Fintype α
inst✝² : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
U V : Finset α
inst✝ : Nonempty α
hPα : #P.parts * 16 ^ #P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ #P.parts * ε ^ 5
hε₁ : ε ≤ 1
hU : U ∈ P.parts
hV : V ∈ P.parts
hUV : U ≠ V
hunif : ¬G.IsUniform ε U V
hm : 0 ≤ 1 - (↑m)⁻¹
hε : 0 ≤ 1 - ε / 10
hε₀ : 0 < ε
⊢ ε ≤ ↑(#(G.nonuniformWitness ε U V)) / ↑(#U)
|
exacts [mod_cast (show 9 ≤ 100 by norm_num).trans (hundred_le_m hPα hPε hε₁),
(le_div_iff₀' <| cast_pos.2 (P.nonempty_of_mem_parts hU).card_pos).2 <|
G.le_card_nonuniformWitness hunif]
|
no goals
|
1f26219e271e2883
|
Polynomial.eraseLead_add_of_degree_lt_right
|
Mathlib/Algebra/Polynomial/EraseLead.lean
|
theorem eraseLead_add_of_degree_lt_right {p q : R[X]} (pq : p.degree < q.degree) :
(p + q).eraseLead = p + q.eraseLead
|
case a
R : Type u_1
inst✝ : Semiring R
p q : R[X]
pq : p.degree < q.degree
n : ℕ
⊢ (p + q).eraseLead.coeff n = (p + q.eraseLead).coeff n
|
by_cases nd : n = q.natDegree
|
case pos
R : Type u_1
inst✝ : Semiring R
p q : R[X]
pq : p.degree < q.degree
n : ℕ
nd : n = q.natDegree
⊢ (p + q).eraseLead.coeff n = (p + q.eraseLead).coeff n
case neg
R : Type u_1
inst✝ : Semiring R
p q : R[X]
pq : p.degree < q.degree
n : ℕ
nd : ¬n = q.natDegree
⊢ (p + q).eraseLead.coeff n = (p + q.eraseLead).coeff n
|
557f2f23d484ef7d
|
List.map_eq_append_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
|
theorem map_eq_append_iff {f : α → β} :
map f l = L₁ ++ L₂ ↔ ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = L₁ ∧ map f l₂ = L₂
|
α : Type u_1
β : Type u_2
l : List α
L₁ L₂ : List β
f : α → β
⊢ map f l = L₁ ++ L₂ ↔ ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = L₁ ∧ map f l₂ = L₂
|
rw [← filterMap_eq_map, filterMap_eq_append_iff]
|
no goals
|
53ce71e1143d847a
|
Array.zipIdx_eq_append_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Range.lean
|
theorem zipIdx_eq_append_iff {l : Array α} {k : Nat} :
zipIdx l k = l₁ ++ l₂ ↔
∃ l₁' l₂', l = l₁' ++ l₂' ∧ l₁ = zipIdx l₁' k ∧ l₂ = zipIdx l₂' (k + l₁'.size)
|
case mk
α : Type u_1
l₁ l₂ : Array (α × Nat)
k : Nat
l : List α
⊢ { toList := l }.zipIdx k = l₁ ++ l₂ ↔
∃ l₁' l₂', { toList := l } = l₁' ++ l₂' ∧ l₁ = l₁'.zipIdx k ∧ l₂ = l₂'.zipIdx (k + l₁'.size)
|
rcases l₁ with ⟨l₁⟩
|
case mk.mk
α : Type u_1
l₂ : Array (α × Nat)
k : Nat
l : List α
l₁ : List (α × Nat)
⊢ { toList := l }.zipIdx k = { toList := l₁ } ++ l₂ ↔
∃ l₁' l₂', { toList := l } = l₁' ++ l₂' ∧ { toList := l₁ } = l₁'.zipIdx k ∧ l₂ = l₂'.zipIdx (k + l₁'.size)
|
f19008c60afcfe32
|
Int.two_pow_two_pow_add_two_pow_two_pow
|
Mathlib/NumberTheory/Multiplicity.lean
|
theorem Int.two_pow_two_pow_add_two_pow_two_pow {x y : ℤ} (hx : ¬2 ∣ x) (hxy : 4 ∣ x - y) (i : ℕ) :
emultiplicity 2 (x ^ 2 ^ i + y ^ 2 ^ i) = ↑(1 : ℕ)
|
case refine_1
x y : ℤ
hx : ¬2 ∣ x
hxy : 4 ∣ x - y
i : ℕ
hx_odd : Odd x
hxy_even : Even (x - y)
hy_odd : Odd y
⊢ Even (x ^ 2 ^ i + y ^ 2 ^ i)
|
exact hx_odd.pow.add_odd hy_odd.pow
|
no goals
|
c2c4f247c9f39fe5
|
List.comp_traverse
|
Mathlib/Control/Traversable/Instances.lean
|
theorem comp_traverse {α β γ} (f : β → F γ) (g : α → G β) (x : List α) :
List.traverse (Comp.mk ∘ (f <$> ·) ∘ g) x =
Comp.mk (List.traverse f <$> List.traverse g x)
|
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
x : List α
⊢ List.traverse (Comp.mk ∘ (fun x => f <$> x) ∘ g) x = Comp.mk (List.traverse f <$> List.traverse g x)
|
induction x <;> simp! [*, functor_norm] <;> rfl
|
no goals
|
bb693fd619cb6dd2
|
GromovHausdorff.HD_lipschitz_aux2
|
Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
|
theorem HD_lipschitz_aux2 (f g : Cb X Y) :
(⨆ y, ⨅ x, f (inl x, inr y)) ≤ (⨆ y, ⨅ x, g (inl x, inr y)) + dist f g
|
X : Type u
Y : Type v
inst✝³ : MetricSpace X
inst✝² : MetricSpace Y
inst✝¹ : Nonempty X
inst✝ : Nonempty Y
f g : GromovHausdorff.Cb X Y
⊢ ⨆ y, ⨅ x, f (inl x, inr y) ≤ (⨆ y, ⨅ x, g (inl x, inr y)) + dist f g
|
obtain ⟨cg, hcg⟩ := g.isBounded_range.bddBelow
|
case intro
X : Type u
Y : Type v
inst✝³ : MetricSpace X
inst✝² : MetricSpace Y
inst✝¹ : Nonempty X
inst✝ : Nonempty Y
f g : GromovHausdorff.Cb X Y
cg : ℝ
hcg : cg ∈ lowerBounds (range ⇑g)
⊢ ⨆ y, ⨅ x, f (inl x, inr y) ≤ (⨆ y, ⨅ x, g (inl x, inr y)) + dist f g
|
640179802facac4b
|
Valuation.Integers.isPrincipalIdealRing_iff_not_denselyOrdered
|
Mathlib/RingTheory/Valuation/Archimedean.lean
|
lemma isPrincipalIdealRing_iff_not_denselyOrdered [MulArchimedean Γ₀] (hv : Integers v O) :
IsPrincipalIdealRing O ↔ ¬ DenselyOrdered (Set.range v)
|
case inr
F : Type u_1
Γ₀ : Type u_2
O : Type u_3
inst✝⁴ : Field F
inst✝³ : LinearOrderedCommGroupWithZero Γ₀
inst✝² : CommRing O
inst✝¹ : Algebra O F
v : Valuation F Γ₀
inst✝ : MulArchimedean Γ₀
hv : v.Integers O
H : ¬DenselyOrdered ↑(Set.range ⇑v)
h✝ : Nontrivial (↥(MonoidHom.mrange v))ˣ
this✝ : IsDomain O
this : ValuationRing O
⊢ IsPrincipalIdealRing O
|
have : IsBezout O := ValuationRing.instIsBezout
|
case inr
F : Type u_1
Γ₀ : Type u_2
O : Type u_3
inst✝⁴ : Field F
inst✝³ : LinearOrderedCommGroupWithZero Γ₀
inst✝² : CommRing O
inst✝¹ : Algebra O F
v : Valuation F Γ₀
inst✝ : MulArchimedean Γ₀
hv : v.Integers O
H : ¬DenselyOrdered ↑(Set.range ⇑v)
h✝ : Nontrivial (↥(MonoidHom.mrange v))ˣ
this✝¹ : IsDomain O
this✝ : ValuationRing O
this : IsBezout O
⊢ IsPrincipalIdealRing O
|
ebfcccdd17f449e6
|
CategoryTheory.Injective.injective_iff_preservesEpimorphisms_yoneda_obj
|
Mathlib/CategoryTheory/Preadditive/Injective/Basic.lean
|
theorem injective_iff_preservesEpimorphisms_yoneda_obj (J : C) :
Injective J ↔ (yoneda.obj J).PreservesEpimorphisms
|
C : Type u₁
inst✝ : Category.{v₁, u₁} C
J : C
⊢ Injective J ↔ (yoneda.obj J).PreservesEpimorphisms
|
rw [injective_iff_projective_op, Projective.projective_iff_preservesEpimorphisms_coyoneda_obj]
|
C : Type u₁
inst✝ : Category.{v₁, u₁} C
J : C
⊢ (coyoneda.obj (op (op J))).PreservesEpimorphisms ↔ (yoneda.obj J).PreservesEpimorphisms
|
7e092be94d48cd63
|
ZMod.pow_card
|
Mathlib/FieldTheory/Finite/Basic.lean
|
theorem pow_card {p : ℕ} [Fact p.Prime] (x : ZMod p) : x ^ p = x
|
p : ℕ
inst✝ : Fact (Nat.Prime p)
x : ZMod p
h : x ^ Fintype.card (ZMod p) = x
⊢ x ^ p = x
|
rwa [ZMod.card p] at h
|
no goals
|
c86d93b485cf12ae
|
MeasureTheory.ae_nonneg_of_forall_setIntegral_nonneg_of_sigmaFinite
|
Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
|
theorem ae_nonneg_of_forall_setIntegral_nonneg_of_sigmaFinite [SigmaFinite μ] {f : α → ℝ}
(hf_int_finite : ∀ s, MeasurableSet s → μ s < ∞ → IntegrableOn f s μ)
(hf_zero : ∀ s, MeasurableSet s → μ s < ∞ → 0 ≤ ∫ x in s, f x ∂μ) : 0 ≤ᵐ[μ] f
|
case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
f : α → ℝ
hf_int_finite : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → IntegrableOn f s μ
hf_zero : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
t : Set α
t_meas : MeasurableSet t
t_lt_top : μ t < ⊤
⊢ ∀ (s : Set α), MeasurableSet s → μ (s ∩ t) < ⊤ → 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ
|
intro s s_meas _
|
case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
f : α → ℝ
hf_int_finite : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → IntegrableOn f s μ
hf_zero : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
t : Set α
t_meas : MeasurableSet t
t_lt_top : μ t < ⊤
s : Set α
s_meas : MeasurableSet s
a✝ : μ (s ∩ t) < ⊤
⊢ 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ
|
c952d9bd03e52640
|
Real.arsinh_nonpos_iff
|
Mathlib/Analysis/SpecialFunctions/Arsinh.lean
|
theorem arsinh_nonpos_iff : arsinh x ≤ 0 ↔ x ≤ 0
|
x : ℝ
⊢ arsinh x ≤ 0 ↔ x ≤ 0
|
rw [← sinh_le_sinh, sinh_zero, sinh_arsinh]
|
no goals
|
103cd864840149b0
|
Algebra.algebraMap_intTrace
|
Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean
|
lemma Algebra.algebraMap_intTrace (x : B) :
algebraMap A K (Algebra.intTrace A B x) = Algebra.trace K L (algebraMap B L x)
|
A : Type u_1
K : Type u_2
L : Type u_3
B : Type u_4
inst✝¹⁹ : CommRing A
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Algebra A B
inst✝¹⁶ : Field K
inst✝¹⁵ : Field L
inst✝¹⁴ : Algebra A K
inst✝¹³ : IsFractionRing A K
inst✝¹² : Algebra B L
inst✝¹¹ : Algebra K L
inst✝¹⁰ : Algebra A L
inst✝⁹ : IsScalarTower A B L
inst✝⁸ : IsScalarTower A K L
inst✝⁷ : IsIntegralClosure B A L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : IsDomain A
inst✝⁴ : IsIntegrallyClosed A
inst✝³ : IsDomain B
inst✝² : IsIntegrallyClosed B
inst✝¹ : Module.Finite A B
inst✝ : NoZeroSMulDivisors A B
x : B
this✝¹ : IsIntegralClosure B A (FractionRing B)
this✝ : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B)
this : FiniteDimensional (FractionRing A) (FractionRing B)
⊢ (algebraMap A K) ((intTrace A B) x) = (trace K L) ((algebraMap B L) x)
|
haveI := IsIntegralClosure.isFractionRing_of_finite_extension A K L B
|
A : Type u_1
K : Type u_2
L : Type u_3
B : Type u_4
inst✝¹⁹ : CommRing A
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Algebra A B
inst✝¹⁶ : Field K
inst✝¹⁵ : Field L
inst✝¹⁴ : Algebra A K
inst✝¹³ : IsFractionRing A K
inst✝¹² : Algebra B L
inst✝¹¹ : Algebra K L
inst✝¹⁰ : Algebra A L
inst✝⁹ : IsScalarTower A B L
inst✝⁸ : IsScalarTower A K L
inst✝⁷ : IsIntegralClosure B A L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : IsDomain A
inst✝⁴ : IsIntegrallyClosed A
inst✝³ : IsDomain B
inst✝² : IsIntegrallyClosed B
inst✝¹ : Module.Finite A B
inst✝ : NoZeroSMulDivisors A B
x : B
this✝² : IsIntegralClosure B A (FractionRing B)
this✝¹ : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B)
this✝ : FiniteDimensional (FractionRing A) (FractionRing B)
this : IsFractionRing B L
⊢ (algebraMap A K) ((intTrace A B) x) = (trace K L) ((algebraMap B L) x)
|
d6085620fefd6e71
|
Complex.ofReal_sub
|
Mathlib/Data/Complex/Basic.lean
|
theorem ofReal_sub (r s : ℝ) : ((r - s : ℝ) : ℂ) = r - s :=
Complex.ext_iff.2 <| by simp [ofReal]
|
r s : ℝ
⊢ (↑(r - s)).re = (↑r - ↑s).re ∧ (↑(r - s)).im = (↑r - ↑s).im
|
simp [ofReal]
|
no goals
|
1c727796bad13de7
|
Int.induction_on
|
Mathlib/Data/Int/Init.lean
|
/--
Induction on integers: prove a proposition `p i` by proving the base case `p 0`,
the upwards induction step `p i → p (i + 1)` and the downwards induction step `p (-i) → p (-i - 1)`.
It is used as the default induction principle for the `induction` tactic.
-/
@[elab_as_elim, induction_eliminator] protected lemma induction_on {p : ℤ → Prop} (i : ℤ)
(hz : p 0) (hp : ∀ i : ℕ, p i → p (i + 1)) (hn : ∀ i : ℕ, p (-i) → p (-i - 1)) : p i
|
p : ℤ → Prop
i : ℤ
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
⊢ p i
|
cases i with
| ofNat i =>
induction i with
| zero => exact hz
| succ i ih => exact hp _ ih
| negSucc i =>
suffices ∀ n : ℕ, p (-n) from this (i + 1)
intro n; induction n with
| zero => simp [hz]
| succ n ih => simpa [ofNat_succ, Int.neg_add, Int.sub_eq_add_neg] using hn _ ih
|
no goals
|
b52be7c1ec7d3694
|
Surreal.double_powHalf_succ_eq_powHalf
|
Mathlib/SetTheory/Surreal/Dyadic.lean
|
theorem double_powHalf_succ_eq_powHalf (n : ℕ) : 2 * powHalf (n + 1) = powHalf n
|
n : ℕ
⊢ powHalf (n + 1) + powHalf (n + 1) = powHalf n
|
exact Quotient.sound (PGame.add_powHalf_succ_self_eq_powHalf n)
|
no goals
|
fb76cc4ba70ef026
|
Lean.Omega.Constraint.scale_sat
|
Mathlib/.lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
|
theorem scale_sat {c : Constraint} (k) (w : c.sat t) : (scale k c).sat (k * t)
|
case isTrue
t : Int
c : Constraint
k : Int
w : c.sat t = true
h✝ : k = 0
⊢ (if c.isImpossible = true then c else { lowerBound := some 0, upperBound := some 0 }).sat (k * t) = true
|
split
|
case isTrue.isTrue
t : Int
c : Constraint
k : Int
w : c.sat t = true
h✝¹ : k = 0
h✝ : c.isImpossible = true
⊢ c.sat (k * t) = true
case isTrue.isFalse
t : Int
c : Constraint
k : Int
w : c.sat t = true
h✝¹ : k = 0
h✝ : ¬c.isImpossible = true
⊢ { lowerBound := some 0, upperBound := some 0 }.sat (k * t) = true
|
498e5968042038b0
|
Monotone.isBoundedUnder_le_comp_iff
|
Mathlib/Order/LiminfLimsup.lean
|
theorem Monotone.isBoundedUnder_le_comp_iff [Nonempty β] [LinearOrder β] [Preorder γ] [NoMaxOrder γ]
{g : β → γ} {f : α → β} {l : Filter α} (hg : Monotone g) (hg' : Tendsto g atTop atTop) :
IsBoundedUnder (· ≤ ·) l (g ∘ f) ↔ IsBoundedUnder (· ≤ ·) l f
|
case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Nonempty β
inst✝² : LinearOrder β
inst✝¹ : Preorder γ
inst✝ : NoMaxOrder γ
g : β → γ
f : α → β
l : Filter α
hg : Monotone g
hg' : Tendsto g atTop atTop
c : γ
hc : ∀ᶠ (a : α) in l, (fun x1 x2 => x1 ≤ x2) ((g ∘ f) a) c
⊢ IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l f
|
obtain ⟨b, hb⟩ : ∃ b, ∀ a ≥ b, c < g a := eventually_atTop.1 (hg'.eventually_gt_atTop c)
|
case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Nonempty β
inst✝² : LinearOrder β
inst✝¹ : Preorder γ
inst✝ : NoMaxOrder γ
g : β → γ
f : α → β
l : Filter α
hg : Monotone g
hg' : Tendsto g atTop atTop
c : γ
hc : ∀ᶠ (a : α) in l, (fun x1 x2 => x1 ≤ x2) ((g ∘ f) a) c
b : β
hb : ∀ a ≥ b, c < g a
⊢ IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l f
|
27bb41283202a063
|
ProbabilityTheory.IsRatCondKernelCDFAux.iInf_rat_gt_eq
|
Mathlib/Probability/Kernel/Disintegration/CDFToKernel.lean
|
lemma IsRatCondKernelCDFAux.iInf_rat_gt_eq (hf : IsRatCondKernelCDFAux f κ ν) [IsFiniteKernel κ]
[IsFiniteKernel ν] (a : α) :
∀ᵐ t ∂(ν a), ∀ q : ℚ, ⨅ r : Ioi q, f (a, t) r = f (a, t) q
|
case refine_2
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel ν
a : α
q : ℚ
⊢ ∀ (s : Set β), MeasurableSet s → (ν a) s < ⊤ → IntegrableOn (fun a_3 => f (a, a_3) q) s (ν a)
|
exact fun _ _ _ ↦ (hf.integrable a _).integrableOn
|
no goals
|
1a4c60aca8d6f13b
|
Sym2.mem_pmap_iff
|
Mathlib/Data/Sym/Sym2.lean
|
@[simp]
lemma mem_pmap_iff {P : α → Prop} (f : ∀ a, P a → β) (z : Sym2 α) (h : ∀ a ∈ z, P a) (b : β) :
b ∈ z.pmap f h ↔ ∃ (a : α) (ha : a ∈ z), b = f a (h a ha)
|
case h
α : Type u_1
β : Type u_2
P : α → Prop
f : (a : α) → P a → β
b : β
x y : α
h : ∀ a ∈ s(x, y), P a
⊢ b ∈ pmap f s(x, y) h ↔ ∃ a, ∃ (ha : a ∈ s(x, y)), b = f a ⋯
|
rw [pmap_pair f x y h]
|
case h
α : Type u_1
β : Type u_2
P : α → Prop
f : (a : α) → P a → β
b : β
x y : α
h : ∀ a ∈ s(x, y), P a
⊢ b ∈ s(f x ⋯, f y ⋯) ↔ ∃ a, ∃ (ha : a ∈ s(x, y)), b = f a ⋯
|
81eb87bfc55a6028
|
locallyConnectedSpace_iff_connectedComponentIn_open
|
Mathlib/Topology/Connected/LocallyConnected.lean
|
theorem locallyConnectedSpace_iff_connectedComponentIn_open :
LocallyConnectedSpace α ↔
∀ F : Set α, IsOpen F → ∀ x ∈ F, IsOpen (connectedComponentIn F x)
|
α : Type u
inst✝ : TopologicalSpace α
⊢ LocallyConnectedSpace α ↔ ∀ (F : Set α), IsOpen F → ∀ x ∈ F, IsOpen (connectedComponentIn F x)
|
constructor
|
case mp
α : Type u
inst✝ : TopologicalSpace α
⊢ LocallyConnectedSpace α → ∀ (F : Set α), IsOpen F → ∀ x ∈ F, IsOpen (connectedComponentIn F x)
case mpr
α : Type u
inst✝ : TopologicalSpace α
⊢ (∀ (F : Set α), IsOpen F → ∀ x ∈ F, IsOpen (connectedComponentIn F x)) → LocallyConnectedSpace α
|
2f496f7313e9e2c7
|
Std.DHashMap.Internal.List.getKey?_insertListConst_of_mem
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean
|
theorem getKey?_insertListConst_of_mem [BEq α] [EquivBEq α]
{l : List ((_ : α) × β)} {toInsert : List (α × β)}
{k k' : α} (k_beq : k == k')
(distinct_l : DistinctKeys l)
(distinct_toInsert : toInsert.Pairwise (fun a b => (a.1 == b.1) = false))
(mem : k ∈ toInsert.map Prod.fst) :
getKey? k' (insertListConst l toInsert) = some k
|
case distinct_toInsert
α : Type u
β : Type v
inst✝¹ : BEq α
inst✝ : EquivBEq α
l : List ((_ : α) × β)
toInsert : List (α × β)
k k' : α
k_beq : (k == k') = true
distinct_l : DistinctKeys l
distinct_toInsert : List.Pairwise (fun a b => (a.fst == b.fst) = false) toInsert
mem : k ∈ List.map Prod.fst toInsert
⊢ List.Pairwise (fun a b => (a.fst == b.fst) = false) (List.map Prod.toSigma toInsert)
|
simpa [List.pairwise_map]
|
no goals
|
28a901ceec5fb004
|
Matroid.IsBase.mem_fundCocircuit_iff_mem_fundCircuit
|
Mathlib/Data/Matroid/Circuit.lean
|
/-- Fundamental circuits and cocircuits of a base `B` play dual roles;
`e` belongs to the fundamental cocircuit for `B` and `f` if and only if
`f` belongs to the fundamental circuit for `e` and `B`.
This statement isn't so reasonable unless `f ∈ B` and `e ∉ B`,
but holds due to junk values even without these assumptions. -/
lemma IsBase.mem_fundCocircuit_iff_mem_fundCircuit {e f : α} (hB : M.IsBase B) :
e ∈ M.fundCocircuit f B ↔ f ∈ M.fundCircuit e B
|
case inr.inr.inr.intro
α : Type u_1
M : Matroid α
B : Set α
hB : M.IsBase B
e f : α
he : M✶.Indep (insert f (M✶.E \ B) \ {e})
hne : e ≠ f
hB'✝ : M✶.IsBase (M✶.E \ B)
hfE : f ∈ M.E
hfB : f ∈ B
heE : e ∈ M.E
heB : e ∉ B
hB' : M.IsBase (M.E \ (insert f (M✶.E \ B) \ {e}))
⊢ insert e B ⊆ insert e (insert f (B \ {f}))
|
simp [hfB]
|
no goals
|
ba4cbc4ce0daa07a
|
AkraBazziRecurrence.GrowsPolynomially.rpow
|
Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
|
protected lemma GrowsPolynomially.rpow (p : ℝ) (hf : GrowsPolynomially f)
(hf_nonneg : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially fun x => (f x) ^ p
|
f : ℝ → ℝ
p : ℝ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
b : ℝ
hb : b ∈ Set.Ioo 0 1
c₁ : ℝ
hc₁_mem : 0 < c₁
c₂ : ℝ
hc₂_mem : c₂ > 0
hfnew : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)
hc₁p : 0 < c₁ ^ p
hc₂p : 0 < c₂ ^ p
hp : p < 0
hpos : ∀ᶠ (x : ℝ) in atTop, 0 < f x
⊢ ∀ᶠ (x : ℝ) in atTop,
∀ u ∈ Set.Icc (b * x) x,
(fun x => f x ^ p) u ∈ Set.Icc (c₂ ^ p * (fun x => f x ^ p) x) (c₁ ^ p * (fun x => f x ^ p) x)
|
filter_upwards [eventually_gt_atTop 0, hfnew, hpos,
(tendsto_id.const_mul_atTop hb.1).eventually_forall_ge_atTop hpos]
with x _ hf₁ hf_pos hf_pos₂
|
case h
f : ℝ → ℝ
p : ℝ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
b : ℝ
hb : b ∈ Set.Ioo 0 1
c₁ : ℝ
hc₁_mem : 0 < c₁
c₂ : ℝ
hc₂_mem : c₂ > 0
hfnew : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)
hc₁p : 0 < c₁ ^ p
hc₂p : 0 < c₂ ^ p
hp : p < 0
hpos : ∀ᶠ (x : ℝ) in atTop, 0 < f x
x : ℝ
a✝ : 0 < x
hf₁ : ∀ u ∈ Set.Icc (b * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)
hf_pos : 0 < f x
hf_pos₂ : ∀ (y : ℝ), b * id x ≤ y → 0 < f y
⊢ ∀ u ∈ Set.Icc (b * x) x, f u ^ p ∈ Set.Icc (c₂ ^ p * f x ^ p) (c₁ ^ p * f x ^ p)
|
cc486cdea8b0b615
|
Commute.pow_eq_pow_iff_of_coprime
|
Mathlib/Data/Int/GCD.lean
|
protected lemma Commute.pow_eq_pow_iff_of_coprime (hab : Commute a b) (hmn : m.Coprime n) :
a ^ m = b ^ n ↔ ∃ c, a = c ^ n ∧ b = c ^ m
|
case pos
α : Type u_1
inst✝ : GroupWithZero α
a b : α
m n : ℕ
hab : Commute a b
hmn : m.Coprime n
h : a ^ m = b ^ n
h✝ : m = 0
⊢ ∃ c, a = c ^ n ∧ b = c ^ m
|
aesop
|
no goals
|
a6f86fafcc8e993a
|
MeasureTheory.integral_comp_rpow_Ioi
|
Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
|
theorem integral_comp_rpow_Ioi (g : ℝ → E) {p : ℝ} (hp : p ≠ 0) :
(∫ x in Ioi 0, (|p| * x ^ (p - 1)) • g (x ^ p)) = ∫ y in Ioi 0, g y
|
case inl
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
g : ℝ → E
p : ℝ
hp : p ≠ 0
S : Set ℝ := Ioi 0
a1 : ∀ x ∈ S, HasDerivWithinAt (fun t => t ^ p) (p * x ^ (p - 1)) S x
h : p < 0
⊢ InjOn (fun x => x ^ p) S
|
apply StrictAntiOn.injOn
|
case inl.H
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
g : ℝ → E
p : ℝ
hp : p ≠ 0
S : Set ℝ := Ioi 0
a1 : ∀ x ∈ S, HasDerivWithinAt (fun t => t ^ p) (p * x ^ (p - 1)) S x
h : p < 0
⊢ StrictAntiOn (fun x => x ^ p) S
|
2e1724a0aef0efd0
|
RegularExpression.char_rmatch_iff
|
Mathlib/Computability/RegularExpressions.lean
|
theorem char_rmatch_iff (a : α) (x : List α) : rmatch (char a) x ↔ x = [a]
|
case cons.nil
α : Type u_1
inst✝ : DecidableEq α
a head✝ : α
⊢ (char a).rmatch [head✝] = true ↔ [head✝] = [a]
|
rw [rmatch, deriv, List.singleton_inj]
|
case cons.nil
α : Type u_1
inst✝ : DecidableEq α
a head✝ : α
⊢ (if a = head✝ then 1 else 0).rmatch [] = true ↔ head✝ = a
|
23bc4fc84fb55aa6
|
CategoryTheory.Functor.commShiftIso_add'
|
Mathlib/CategoryTheory/Shift/CommShift.lean
|
lemma commShiftIso_add' {a b c : A} (h : a + b = c) :
F.commShiftIso c = CommShift.isoAdd' h (F.commShiftIso a) (F.commShiftIso b)
|
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_7, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
F : C ⥤ D
A : Type u_4
inst✝³ : AddMonoid A
inst✝² : HasShift C A
inst✝¹ : HasShift D A
inst✝ : F.CommShift A
a b c : A
h : a + b = c
⊢ F.commShiftIso c = CommShift.isoAdd' h (F.commShiftIso a) (F.commShiftIso b)
|
subst h
|
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_7, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
F : C ⥤ D
A : Type u_4
inst✝³ : AddMonoid A
inst✝² : HasShift C A
inst✝¹ : HasShift D A
inst✝ : F.CommShift A
a b : A
⊢ F.commShiftIso (a + b) = CommShift.isoAdd' ⋯ (F.commShiftIso a) (F.commShiftIso b)
|
0c360e580cd4cf04
|
CategoryTheory.GrothendieckTopology.W_eq_W_range_sheafToPresheaf_obj
|
Mathlib/CategoryTheory/Sites/Localization.lean
|
lemma W_eq_W_range_sheafToPresheaf_obj :
J.W = LeftBousfield.W (· ∈ Set.range (sheafToPresheaf J A).obj)
|
case h.h.a.mpr
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
J : GrothendieckTopology C
A : Type u_2
inst✝ : Category.{u_4, u_2} A
P : Cᵒᵖ ⥤ A
⊢ P ∈ Set.range (sheafToPresheaf J A).obj → Presheaf.IsSheaf J P
|
rintro ⟨F, rfl⟩
|
case h.h.a.mpr.intro
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
J : GrothendieckTopology C
A : Type u_2
inst✝ : Category.{u_4, u_2} A
F : Sheaf J A
⊢ Presheaf.IsSheaf J ((sheafToPresheaf J A).obj F)
|
9ae0a5f641cf1151
|
ascPochhammer_eval_neg_coe_nat_of_lt
|
Mathlib/RingTheory/Polynomial/Pochhammer.lean
|
theorem ascPochhammer_eval_neg_coe_nat_of_lt {n k : ℕ} (h : k < n) :
(ascPochhammer R n).eval (-(k : R)) = 0
|
case succ.inr.inr
R : Type u
inst✝ : Ring R
k n : ℕ
ih : k < n → eval (-↑k) (ascPochhammer R n) = 0
h : k < n + 1
hkn : n < k
⊢ eval (-↑k) (ascPochhammer R n) * (-↑k + ↑n) = 0
|
omega
|
no goals
|
a05c0c4c7884ccf5
|
Computation.exists_of_mem_parallel
|
Mathlib/Data/Seq/Parallel.lean
|
theorem exists_of_mem_parallel {S : WSeq (Computation α)} {a} (h : a ∈ parallel S) :
∃ c ∈ S, a ∈ c
|
case cons.inr.inr.intro.intro.inl
α : Type u
S : WSeq (Computation α)
a : α
h✝ : a ∈ parallel S
F : List (Computation α) → α ⊕ List (Computation α) → Prop :=
fun l a =>
Sum.casesOn a (fun a => ∃ c, c ∈ l ∧ a ∈ c) fun l' => ∀ (a' : α), (∃ c, c ∈ l' ∧ a' ∈ c) → ∃ c, c ∈ l ∧ a' ∈ c
c : Computation α
l val✝ : List (Computation α)
IH : F l (Sum.inr val✝)
c' : Computation α
h : c.destruct = Sum.inr c'
a' : α
d : Computation α
ad : a' ∈ c'
e : d = c'
⊢ a' ∈ c'.think
|
exact think_mem ad
|
no goals
|
b380dbfafe118cb2
|
Order.pred_iterate
|
Mathlib/Algebra/Order/SuccPred.lean
|
theorem pred_iterate [AddCommGroupWithOne α] [PredSubOrder α] (x : α) (n : ℕ) :
pred^[n] x = x - n
|
case zero
α : Type u_1
inst✝² : Preorder α
inst✝¹ : AddCommGroupWithOne α
inst✝ : PredSubOrder α
x : α
⊢ pred^[0] x = x - ↑0
|
rw [Function.iterate_zero_apply, Nat.cast_zero, sub_zero]
|
no goals
|
a9be6dc84df758d0
|
uniformCauchySeqOn_ball_of_fderiv
|
Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean
|
theorem uniformCauchySeqOn_ball_of_fderiv {r : ℝ} (hf' : UniformCauchySeqOn f' l (Metric.ball x r))
(hf : ∀ n : ι, ∀ y : E, y ∈ Metric.ball x r → HasFDerivAt (f n) (f' n y) y)
(hfg : Cauchy (map (fun n => f n x) l)) : UniformCauchySeqOn f l (Metric.ball x r)
|
case inr.left
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : IsRCLikeNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : ι → E → G
f' : ι → E → E →L[𝕜] G
x : E
r : ℝ
hf : ∀ (n : ι), ∀ y ∈ Metric.ball x r, HasFDerivAt (f n) (f' n y) y
hfg : Cauchy (map (fun n => f n x) l)
this✝¹ : RCLike 𝕜 := IsRCLikeNormedField.rclike 𝕜
hf' : ∀ ε > 0, ∀ᶠ (n : ι × ι) in l ×ˢ l, ∀ x_1 ∈ Metric.ball x r, dist (0 x_1) (f' n.1 x_1 - f' n.2 x_1) < ε
this✝ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 E
this : l.NeBot
hr : 0 < r
ε : ℝ
hε : ε > 0
⊢ ∀ᶠ (n : ι × ι) in l ×ˢ l, ∀ x_1 ∈ Metric.ball x r, dist (0 x_1) (f n.1 x_1 - f n.2 x_1 - (f n.1 x - f n.2 x)) < ε
|
obtain ⟨q, hqpos, hq⟩ : ∃ q : ℝ, 0 < q ∧ q * r < ε := by
simp_rw [mul_comm]
exact exists_pos_mul_lt hε.lt r
|
case inr.left.intro.intro
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : IsRCLikeNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : ι → E → G
f' : ι → E → E →L[𝕜] G
x : E
r : ℝ
hf : ∀ (n : ι), ∀ y ∈ Metric.ball x r, HasFDerivAt (f n) (f' n y) y
hfg : Cauchy (map (fun n => f n x) l)
this✝¹ : RCLike 𝕜 := IsRCLikeNormedField.rclike 𝕜
hf' : ∀ ε > 0, ∀ᶠ (n : ι × ι) in l ×ˢ l, ∀ x_1 ∈ Metric.ball x r, dist (0 x_1) (f' n.1 x_1 - f' n.2 x_1) < ε
this✝ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 E
this : l.NeBot
hr : 0 < r
ε : ℝ
hε : ε > 0
q : ℝ
hqpos : 0 < q
hq : q * r < ε
⊢ ∀ᶠ (n : ι × ι) in l ×ˢ l, ∀ x_1 ∈ Metric.ball x r, dist (0 x_1) (f n.1 x_1 - f n.2 x_1 - (f n.1 x - f n.2 x)) < ε
|
982ef3c3832b9fcd
|
Nat.choose_le_middle_of_le_half_left
|
Mathlib/Data/Nat/Choose/Basic.lean
|
theorem choose_le_middle_of_le_half_left {n r : ℕ} (hr : r ≤ n / 2) :
choose n r ≤ choose n (n / 2)
|
case of_succ
n r k : ℕ
hk : k < n / 2
ih : n.choose (k + 1) ≤ n.choose (n / 2)
⊢ n.choose k ≤ n.choose (n / 2)
|
exact (choose_le_succ_of_lt_half_left hk).trans ih
|
no goals
|
26f4fa89c0e23b03
|
StrictConvexOn.ae_eq_const_or_map_average_lt
|
Mathlib/Analysis/Convex/Integral.lean
|
theorem StrictConvexOn.ae_eq_const_or_map_average_lt [IsFiniteMeasure μ] (hg : StrictConvexOn ℝ s g)
(hgc : ContinuousOn g s) (hsc : IsClosed s) (hfs : ∀ᵐ x ∂μ, f x ∈ s) (hfi : Integrable f μ)
(hgi : Integrable (g ∘ f) μ) :
f =ᵐ[μ] const α (⨍ x, f x ∂μ) ∨ g (⨍ x, f x ∂μ) < ⨍ x, g (f x) ∂μ
|
case intro.intro.intro.intro
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
μ : Measure α
s : Set E
f : α → E
g : E → ℝ
inst✝ : IsFiniteMeasure μ
hg : StrictConvexOn ℝ s g
hgc : ContinuousOn g s
hsc : IsClosed s
hfs : ∀ᵐ (x : α) ∂μ, f x ∈ s
hfi : Integrable f μ
hgi : Integrable (g ∘ f) μ
this : ∀ {t : Set α}, μ t ≠ 0 → ⨍ (x : α) in t, f x ∂μ ∈ s ∧ g (⨍ (x : α) in t, f x ∂μ) ≤ ⨍ (x : α) in t, g (f x) ∂μ
t : Set α
hm : MeasurableSet t
h₀ : μ t ≠ 0
h₀' : μ tᶜ ≠ 0
hne : ⨍ (x : α) in t, f x ∂μ ≠ ⨍ (x : α) in tᶜ, f x ∂μ
⊢ g (⨍ (x : α), f x ∂μ) < ⨍ (x : α), g (f x) ∂μ
|
rcases average_mem_openSegment_compl_self hm.nullMeasurableSet h₀ h₀' (hfi.prod_mk hgi) with
⟨a, b, ha, hb, hab, h_avg⟩
|
case intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
μ : Measure α
s : Set E
f : α → E
g : E → ℝ
inst✝ : IsFiniteMeasure μ
hg : StrictConvexOn ℝ s g
hgc : ContinuousOn g s
hsc : IsClosed s
hfs : ∀ᵐ (x : α) ∂μ, f x ∈ s
hfi : Integrable f μ
hgi : Integrable (g ∘ f) μ
this : ∀ {t : Set α}, μ t ≠ 0 → ⨍ (x : α) in t, f x ∂μ ∈ s ∧ g (⨍ (x : α) in t, f x ∂μ) ≤ ⨍ (x : α) in t, g (f x) ∂μ
t : Set α
hm : MeasurableSet t
h₀ : μ t ≠ 0
h₀' : μ tᶜ ≠ 0
hne : ⨍ (x : α) in t, f x ∂μ ≠ ⨍ (x : α) in tᶜ, f x ∂μ
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
h_avg :
a • ⨍ (x : α) in t, (f x, (g ∘ f) x) ∂μ + b • ⨍ (x : α) in tᶜ, (f x, (g ∘ f) x) ∂μ = ⨍ (x : α), (f x, (g ∘ f) x) ∂μ
⊢ g (⨍ (x : α), f x ∂μ) < ⨍ (x : α), g (f x) ∂μ
|
444c949c6a58f0aa
|
LieSubmodule.lieIdeal_oper_eq_linear_span'
|
Mathlib/Algebra/Lie/IdealOperations.lean
|
theorem lieIdeal_oper_eq_linear_span' [LieModule R L M] :
(↑⁅I, N⁆ : Submodule R M) = Submodule.span R { ⁅x, n⁆ | (x ∈ I) (n ∈ N) }
|
case e_s.h.mp
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
N : LieSubmodule R L M
inst✝¹ : LieAlgebra R L
I : LieIdeal R L
inst✝ : LieModule R L M
m : M
⊢ m ∈ {x | ∃ x_1 n, ⁅↑x_1, ↑n⁆ = x} → m ∈ {x | ∃ x_1 ∈ I, ∃ n ∈ N, ⁅x_1, n⁆ = x}
|
rintro ⟨⟨x, hx⟩, ⟨n, hn⟩, rfl⟩
|
case e_s.h.mp.intro.mk.intro.mk
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
N : LieSubmodule R L M
inst✝¹ : LieAlgebra R L
I : LieIdeal R L
inst✝ : LieModule R L M
x : L
hx : x ∈ I
n : M
hn : n ∈ N
⊢ ⁅↑⟨x, hx⟩, ↑⟨n, hn⟩⁆ ∈ {x | ∃ x_1 ∈ I, ∃ n ∈ N, ⁅x_1, n⁆ = x}
|
36507cbeea573138
|
Matrix.trace_conj'
|
Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
|
theorem trace_conj' {M : Matrix m m α} (h : IsUnit M) (N : Matrix m m α) :
trace (M⁻¹ * N * M) = trace N
|
m : Type u
α : Type v
inst✝² : CommRing α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m m α
h : IsUnit M
N : Matrix m m α
⊢ (M⁻¹ * N * M).trace = N.trace
|
rw [← h.unit_spec, ← coe_units_inv, trace_units_conj']
|
no goals
|
11436d193d30d3c3
|
Equiv.sigmaCongrRight_sigmaEquivProd
|
Mathlib/Logic/Equiv/Basic.lean
|
theorem sigmaCongrRight_sigmaEquivProd :
(sigmaCongrRight e).trans (sigmaEquivProd α₁ β₂)
= (sigmaEquivProd α₁ β₁).trans (prodCongrRight e)
|
case H.mk
α₁ : Type u_9
β₁ : Type u_11
β₂ : Type u_12
e : α₁ → β₁ ≃ β₂
a : α₁
b : β₁
⊢ ((sigmaCongrRight e).trans (sigmaEquivProd α₁ β₂)) ⟨a, b⟩ = ((sigmaEquivProd α₁ β₁).trans (prodCongrRight e)) ⟨a, b⟩
|
simp
|
no goals
|
97976782b908e05a
|
isPrimePow_pow_iff
|
Mathlib/Data/Nat/Factorization/PrimePow.lean
|
theorem isPrimePow_pow_iff {n k : ℕ} (hk : k ≠ 0) : IsPrimePow (n ^ k) ↔ IsPrimePow n
|
case h
n k : ℕ
hk : k ≠ 0
p : ℕ
hp : Nat.Prime p
⊢ p ∣ n ^ k ↔ p ∣ n
|
exact ⟨hp.dvd_of_dvd_pow, fun t => t.trans (dvd_pow_self _ hk)⟩
|
no goals
|
da98ff94f5a183d6
|
MeasureTheory.Measure.singularPart_smul_right
|
Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
|
theorem singularPart_smul_right (μ ν : Measure α) (r : ℝ≥0) (hr : r ≠ 0) :
μ.singularPart (r • ν) = μ.singularPart ν
|
case h.e'_3.h.e'_6.h.e'_4.h
α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0
hr : r ≠ 0
hl : μ.HaveLebesgueDecomposition ν
x : α
⊢ (↑r • r⁻¹ • μ.rnDeriv ν) x = μ.rnDeriv ν x
|
simp only [Pi.smul_apply]
|
case h.e'_3.h.e'_6.h.e'_4.h
α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0
hr : r ≠ 0
hl : μ.HaveLebesgueDecomposition ν
x : α
⊢ ↑r • r⁻¹ • μ.rnDeriv ν x = μ.rnDeriv ν x
|
ba33040902f46823
|
Polynomial.ringHom_ext
|
Mathlib/Algebra/Polynomial/Monomial.lean
|
theorem ringHom_ext {S} [Semiring S] {f g : R[X] →+* S} (h₁ : ∀ a, f (C a) = g (C a))
(h₂ : f X = g X) : f = g
|
R : Type u
inst✝¹ : Semiring R
S : Type u_1
inst✝ : Semiring S
f g : R[X] →+* S
h₁ : ∀ (a : R), f (C a) = g (C a)
h₂ : f X = g X
f' : AddMonoidAlgebra R ℕ →+* S := f.comp (toFinsuppIso R).symm.toRingHom
hf' : f' = f.comp (toFinsuppIso R).symm.toRingHom
g' : AddMonoidAlgebra R ℕ →+* S := g.comp (toFinsuppIso R).symm.toRingHom
hg' : g' = g.comp (toFinsuppIso R).symm.toRingHom
A : f' = g'
B : f = f'.comp ↑(toFinsuppIso R)
⊢ f = g
|
have C' : g = g'.comp (toFinsuppIso R) := by
rw [hg', RingHom.comp_assoc]
ext x
simp only [RingEquiv.toRingHom_eq_coe, RingEquiv.symm_apply_apply, Function.comp_apply,
RingHom.coe_comp, RingEquiv.coe_toRingHom]
|
R : Type u
inst✝¹ : Semiring R
S : Type u_1
inst✝ : Semiring S
f g : R[X] →+* S
h₁ : ∀ (a : R), f (C a) = g (C a)
h₂ : f X = g X
f' : AddMonoidAlgebra R ℕ →+* S := f.comp (toFinsuppIso R).symm.toRingHom
hf' : f' = f.comp (toFinsuppIso R).symm.toRingHom
g' : AddMonoidAlgebra R ℕ →+* S := g.comp (toFinsuppIso R).symm.toRingHom
hg' : g' = g.comp (toFinsuppIso R).symm.toRingHom
A : f' = g'
B : f = f'.comp ↑(toFinsuppIso R)
C' : g = g'.comp ↑(toFinsuppIso R)
⊢ f = g
|
0a7f72cbc18ffb89
|
Real.cos_lt_one_div_sqrt_sq_add_one
|
Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean
|
theorem cos_lt_one_div_sqrt_sq_add_one {x : ℝ} (hx1 : -(3 * π / 2) ≤ x) (hx2 : x ≤ 3 * π / 2)
(hx3 : x ≠ 0) : cos x < (1 / √(x ^ 2 + 1) : ℝ)
|
x : ℝ
hx1 : -(3 * π / 2) ≤ x
hx2 : x ≤ 3 * π / 2
hx3 : x ≠ 0
this : ∀ {y : ℝ}, 0 < y → y ≤ 3 * π / 2 → cos y < 1 / √(y ^ 2 + 1)
h✝ : x < 0
⊢ 0 < -x
|
linarith
|
no goals
|
f405817ae92adc5b
|
sdiff_sup
|
Mathlib/Order/BooleanAlgebra.lean
|
theorem sdiff_sup : y \ (x ⊔ z) = y \ x ⊓ y \ z :=
sdiff_unique
(calc
y ⊓ (x ⊔ z) ⊔ y \ x ⊓ y \ z = (y ⊓ (x ⊔ z) ⊔ y \ x) ⊓ (y ⊓ (x ⊔ z) ⊔ y \ z)
|
α : Type u
x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ y ⊓ x ⊓ y \ x ⊓ y \ z ⊔ y \ x ⊓ (y \ z ⊓ (y ⊓ z)) = ⊥
|
rw [inf_inf_sdiff, bot_inf_eq, bot_sup_eq, inf_comm (y \ z),
inf_inf_sdiff, inf_bot_eq]
|
no goals
|
d036844b47839f50
|
Besicovitch.exists_closedBall_covering_tsum_measure_le
|
Mathlib/MeasureTheory/Covering/Besicovitch.lean
|
theorem exists_closedBall_covering_tsum_measure_le (μ : Measure α) [SFinite μ]
[Measure.OuterRegular μ] {ε : ℝ≥0∞} (hε : ε ≠ 0) (f : α → Set ℝ) (s : Set α)
(hf : ∀ x ∈ s, ∀ δ > 0, (f x ∩ Ioo 0 δ).Nonempty) :
∃ (t : Set α) (r : α → ℝ), t.Countable ∧ t ⊆ s ∧ (∀ x ∈ t, r x ∈ f x) ∧
(s ⊆ ⋃ x ∈ t, closedBall x (r x)) ∧ (∑' x : t, μ (closedBall x (r x))) ≤ μ s + ε
|
case intro.intro.intro
α : Type u_1
inst✝⁶ : MetricSpace α
inst✝⁵ : SecondCountableTopology α
inst✝⁴ : MeasurableSpace α
inst✝³ : OpensMeasurableSpace α
inst✝² : HasBesicovitchCovering α
μ : Measure α
inst✝¹ : SFinite μ
inst✝ : μ.OuterRegular
ε : ℝ≥0∞
hε : ε ≠ 0
f : α → Set ℝ
s : Set α
hf : ∀ x ∈ s, ∀ δ > 0, (f x ∩ Ioo 0 δ).Nonempty
u : Set α
su : u ⊇ s
u_open : IsOpen u
μu : μ u ≤ μ s + ε / 2
R : α → ℝ
hR : ∀ x ∈ s, R x > 0 ∧ ball x (R x) ⊆ u
⊢ ∃ t r,
t.Countable ∧
t ⊆ s ∧ (∀ x ∈ t, r x ∈ f x) ∧ s ⊆ ⋃ x ∈ t, closedBall x (r x) ∧ ∑' (x : ↑t), μ (closedBall (↑x) (r ↑x)) ≤ μ s + ε
|
obtain ⟨t0, r0, t0_count, t0s, hr0, μt0, t0_disj⟩ :
∃ (t0 : Set α) (r0 : α → ℝ), t0.Countable ∧ t0 ⊆ s ∧
(∀ x ∈ t0, r0 x ∈ f x ∩ Ioo 0 (R x)) ∧ μ (s \ ⋃ x ∈ t0, closedBall x (r0 x)) = 0 ∧
t0.PairwiseDisjoint fun x => closedBall x (r0 x) :=
exists_disjoint_closedBall_covering_ae μ f s hf R fun x hx => (hR x hx).1
|
case intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝⁶ : MetricSpace α
inst✝⁵ : SecondCountableTopology α
inst✝⁴ : MeasurableSpace α
inst✝³ : OpensMeasurableSpace α
inst✝² : HasBesicovitchCovering α
μ : Measure α
inst✝¹ : SFinite μ
inst✝ : μ.OuterRegular
ε : ℝ≥0∞
hε : ε ≠ 0
f : α → Set ℝ
s : Set α
hf : ∀ x ∈ s, ∀ δ > 0, (f x ∩ Ioo 0 δ).Nonempty
u : Set α
su : u ⊇ s
u_open : IsOpen u
μu : μ u ≤ μ s + ε / 2
R : α → ℝ
hR : ∀ x ∈ s, R x > 0 ∧ ball x (R x) ⊆ u
t0 : Set α
r0 : α → ℝ
t0_count : t0.Countable
t0s : t0 ⊆ s
hr0 : ∀ x ∈ t0, r0 x ∈ f x ∩ Ioo 0 (R x)
μt0 : μ (s \ ⋃ x ∈ t0, closedBall x (r0 x)) = 0
t0_disj : t0.PairwiseDisjoint fun x => closedBall x (r0 x)
⊢ ∃ t r,
t.Countable ∧
t ⊆ s ∧ (∀ x ∈ t, r x ∈ f x) ∧ s ⊆ ⋃ x ∈ t, closedBall x (r x) ∧ ∑' (x : ↑t), μ (closedBall (↑x) (r ↑x)) ≤ μ s + ε
|
181682c2ed74f98b
|
WeierstrassCurve.exists_variableChange_of_char_two
|
Mathlib/AlgebraicGeometry/EllipticCurve/IsomOfJ.lean
|
private lemma exists_variableChange_of_char_two (heq : E.j = E'.j) :
∃ C : VariableChange F, E.variableChange C = E'
|
case intro.of_j_ne_zero.intro.of_j_eq_zero
F : Type u_1
inst✝⁶ : Field F
inst✝⁵ : IsSepClosed F
E E' : WeierstrassCurve F
inst✝⁴ : E.IsElliptic
inst✝³ : E'.IsElliptic
inst✝² : CharP F 2
heq : E.j = E'.j
C : VariableChange F
inst✝¹ : (E.variableChange C).IsCharTwoJNeZeroNF
C' : VariableChange F
inst✝ : (E'.variableChange C').IsCharTwoJEqZeroNF
⊢ ∃ C, E.variableChange C = E'
|
have h := (E.variableChange C).j_ne_zero_of_isCharTwoJNeZeroNF_of_char_two
|
case intro.of_j_ne_zero.intro.of_j_eq_zero
F : Type u_1
inst✝⁶ : Field F
inst✝⁵ : IsSepClosed F
E E' : WeierstrassCurve F
inst✝⁴ : E.IsElliptic
inst✝³ : E'.IsElliptic
inst✝² : CharP F 2
heq : E.j = E'.j
C : VariableChange F
inst✝¹ : (E.variableChange C).IsCharTwoJNeZeroNF
C' : VariableChange F
inst✝ : (E'.variableChange C').IsCharTwoJEqZeroNF
h : (E.variableChange C).j ≠ 0
⊢ ∃ C, E.variableChange C = E'
|
777fc2b6b6b2f928
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastZeroExtend.go_denote_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.lean
|
theorem go_denote_eq (aig : AIG α) (w : Nat) (input : AIG.RefVec aig w) (newWidth curr : Nat)
(hcurr : curr ≤ newWidth) (s : AIG.RefVec aig curr) (assign : α → Bool) :
∀ (idx : Nat) (hidx1 : idx < newWidth),
curr ≤ idx
→
⟦
(go aig w input newWidth curr hcurr s).aig,
(go aig w input newWidth curr hcurr s).vec.get idx hidx1,
assign
⟧
=
if hidx : idx < w then
⟦aig, input.get idx hidx, assign⟧
else
false
|
case isTrue.inr.isFalse.isFalse
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefVec w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefVec curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefVecEntry α newWidth
h✝³ : curr < newWidth
h✝² : curr < idx
h✝¹ : ¬curr < w
hgo :
go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
((s.cast ⋯).push (aig.mkConstCached false).ref) =
res
h✝ : ¬idx < w
⊢ false = false
|
rfl
|
no goals
|
4f5d95c54c74e073
|
IsLocalization.surj''
|
Mathlib/RingTheory/Localization/InvSubmonoid.lean
|
theorem surj'' (z : S) : ∃ (r : R) (m : M), z = r • (toInvSubmonoid M S m : S)
|
case intro.mk
R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
z : S
r : R
m : ↥M
e : z * (algebraMap R S) ↑(r, m).2 = (algebraMap R S) r
⊢ z = r • ↑((toInvSubmonoid M S) m)
|
rw [Algebra.smul_def, ← e, mul_assoc]
|
case intro.mk
R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
z : S
r : R
m : ↥M
e : z * (algebraMap R S) ↑(r, m).2 = (algebraMap R S) r
⊢ z = z * ((algebraMap R S) ↑(r, m).2 * ↑((toInvSubmonoid M S) m))
|
de1a619505f23744
|
Complex.norm_exp_ofReal
|
Mathlib/Data/Complex/Exponential.lean
|
theorem norm_exp_ofReal (x : ℝ) : ‖exp x‖ = Real.exp x
|
x : ℝ
⊢ ‖↑(Real.exp x)‖ = Real.exp x
|
exact Complex.norm_of_nonneg (le_of_lt (Real.exp_pos _))
|
no goals
|
aa9d89e7b46b7208
|
MeasureTheory.integral_trim_simpleFunc
|
Mathlib/MeasureTheory/Integral/Bochner.lean
|
theorem integral_trim_simpleFunc (hm : m ≤ m0) (f : @SimpleFunc β m F) (hf_int : Integrable f μ) :
∫ x, f x ∂μ = ∫ x, f x ∂μ.trim hm
|
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
β : Type u_6
m m0 : MeasurableSpace β
μ : Measure β
hm : m ≤ m0
f : β →ₛ F
hf_int : Integrable (⇑f) μ
hf : StronglyMeasurable ⇑f
hf_int_m : Integrable (⇑f) (μ.trim hm)
⊢ ∫ (x : β), f x ∂μ = ∫ (x : β), f x ∂μ.trim hm
|
rw [integral_simpleFunc_larger_space (le_refl m) f hf_int_m,
integral_simpleFunc_larger_space hm f hf_int]
|
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
β : Type u_6
m m0 : MeasurableSpace β
μ : Measure β
hm : m ≤ m0
f : β →ₛ F
hf_int : Integrable (⇑f) μ
hf : StronglyMeasurable ⇑f
hf_int_m : Integrable (⇑f) (μ.trim hm)
⊢ ∑ x ∈ f.range, (μ (⇑f ⁻¹' {x})).toReal • x = ∑ x ∈ f.range, ((μ.trim hm) (⇑f ⁻¹' {x})).toReal • x
|
adb2d33a8f6ec844
|
RingHom.FormallyUnramified.ofLocalizationPrime
|
Mathlib/RingTheory/RingHom/Unramified.lean
|
lemma ofLocalizationPrime :
OfLocalizationPrime FormallyUnramified
|
⊢ OfLocalizationPrime fun {R S} [CommRing R] [CommRing S] => FormallyUnramified
|
intros R S _ _ f H
|
R S : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
H :
∀ (J : Ideal S) (x : J.IsPrime),
(fun {R S} [CommRing R] [CommRing S] => FormallyUnramified) (Localization.localRingHom (Ideal.comap f J) J f ⋯)
⊢ f.FormallyUnramified
|
4a1b7e80bb139389
|
maximal_orthonormal_iff_orthogonalComplement_eq_bot
|
Mathlib/Analysis/InnerProductSpace/Projection.lean
|
theorem maximal_orthonormal_iff_orthogonalComplement_eq_bot (hv : Orthonormal 𝕜 ((↑) : v → E)) :
(∀ u ⊇ v, Orthonormal 𝕜 ((↑) : u → E) → u = v) ↔ (span 𝕜 v)ᗮ = ⊥
|
case mp.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
v : Set E
hv : Orthonormal 𝕜 Subtype.val
x : E
hx' : x ∈ (span 𝕜 v)ᗮ
hx : x ≠ 0
e : E := (↑‖x‖)⁻¹ • x
he : ‖e‖ = 1
he' : e ∈ (span 𝕜 v)ᗮ
he'' : e ∉ v
⊢ ∃ u ⊇ v, Orthonormal 𝕜 Subtype.val ∧ u ≠ v
|
refine ⟨insert e v, v.subset_insert e, ⟨?_, ?_⟩, (ne_insert_of_not_mem v he'').symm⟩
|
case mp.intro.intro.refine_1
𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
v : Set E
hv : Orthonormal 𝕜 Subtype.val
x : E
hx' : x ∈ (span 𝕜 v)ᗮ
hx : x ≠ 0
e : E := (↑‖x‖)⁻¹ • x
he : ‖e‖ = 1
he' : e ∈ (span 𝕜 v)ᗮ
he'' : e ∉ v
⊢ ∀ (i : { x // x ∈ insert e v }), ‖↑i‖ = 1
case mp.intro.intro.refine_2
𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
v : Set E
hv : Orthonormal 𝕜 Subtype.val
x : E
hx' : x ∈ (span 𝕜 v)ᗮ
hx : x ≠ 0
e : E := (↑‖x‖)⁻¹ • x
he : ‖e‖ = 1
he' : e ∈ (span 𝕜 v)ᗮ
he'' : e ∉ v
⊢ Pairwise fun i j => ⟪↑i, ↑j⟫_𝕜 = 0
|
ce0a185108c33220
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.