name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Array.append_inj_left' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs₁ xs₂ ys₁ ys₂ : Array α}, xs₁ ++ ys₁ = xs₂ ++ ys₂ → ys₁.size = ys₂.size → xs₁ = xs₂ |
RingHomInvPair.mk._flat_ctor | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ : R₁ →+* R₂}
{σ' : outParam (R₂ →+* R₁)}, σ'.comp σ = RingHom.id R₁ → σ.comp σ' = RingHom.id R₂ → RingHomInvPair σ σ' |
MeasureTheory.AddQuotientMeasureEqMeasurePreimage.addHaarMeasure_quotient | Mathlib.MeasureTheory.Measure.Haar.Quotient | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] [inst_2 : TopologicalSpace G]
[IsTopologicalAddGroup G] [BorelSpace G] [PolishSpace G] {Γ : AddSubgroup G} [inst_6 : Γ.Normal] [T2Space (G ⧸ Γ)]
[SecondCountableTopology (G ⧸ Γ)] {μ : MeasureTheory.Measure (G ⧸ Γ)} [Countable ↥Γ] (ν : MeasureTheory.Measure G)
[ν.IsAddHaarMeasure] [ν.IsAddRightInvariant] [LocallyCompactSpace G]
[MeasureTheory.AddQuotientMeasureEqMeasurePreimage ν μ] [i : MeasureTheory.HasAddFundamentalDomain (↥Γ.op) G ν]
[MeasureTheory.IsFiniteMeasure μ], μ.IsAddHaarMeasure |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isDefEqArgs._sparseCasesOn_1 | Lean.Meta.ExprDefEq | {motive : Lean.Meta.DefEqArgsFirstPassResult → Sort u} →
(t : Lean.Meta.DefEqArgsFirstPassResult) →
((postponedImplicit postponedHO : Array ℕ) →
motive (Lean.Meta.DefEqArgsFirstPassResult.ok postponedImplicit postponedHO)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
LightDiagram.diagram | Mathlib.Topology.Category.LightProfinite.Basic | LightDiagram → CategoryTheory.Functor ℕᵒᵖ FintypeCat |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.doubling_lt_golden_ratio._simp_1_21 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) |
DifferentiableAt.smul_const | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
{𝕜' : Type u_5} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module 𝕜' F] [IsBoundedSMul 𝕜' F]
[IsScalarTower 𝕜 𝕜' F] {c : E → 𝕜'}, DifferentiableAt 𝕜 c x → ∀ (f : F), DifferentiableAt 𝕜 (fun y => c y • f) x |
InitialSeg.mem_range_of_rel' | Mathlib.Order.InitialSeg | ∀ {α : Type u_4} {β : Type u_5} {r : α → α → Prop} {s : β → β → Prop} (self : InitialSeg r s) (a : α) (b : β),
s b (self.toRelEmbedding a) → b ∈ Set.range ⇑self.toRelEmbedding |
Std.DHashMap.Internal.List.HashesTo.mk | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {l : List ((a : α) × β a)} {i size : ℕ},
(∀ (h : 0 < size), ∀ p ∈ l, (↑(Std.DHashMap.Internal.mkIdx size h (hash p.fst))).toNat = i) →
Std.DHashMap.Internal.List.HashesTo l i size |
MonCat.instConcreteCategoryMonoidHomCarrier._proof_1 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : MonCat} (f : ↑X →* ↑Y), { hom' := f }.hom' = f |
CategoryTheory.PullbackShift.adjunction_counit | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] (φ : A →+ B) [inst_3 : CategoryTheory.HasShift C B] {D : Type u_4}
[inst_4 : CategoryTheory.Category.{v_2, u_4} D] [inst_5 : CategoryTheory.HasShift D B]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G),
(CategoryTheory.PullbackShift.adjunction φ adj).counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.PullbackShift.natIsoComp φ G F).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.PullbackShift.natTrans φ adj.counit)
(CategoryTheory.NatTrans.PullbackShift.natIsoId D φ).inv) |
CategoryTheory.SmallObject.FunctorObjIndex.comm_assoc | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X : C}
(πX : X ⟶ S)
[inst_1 :
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX))
C]
[inst_2 :
CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πX)
(CategoryTheory.SmallObject.functorObjLeft f πX)]
(x : CategoryTheory.SmallObject.FunctorObjIndex f πX) {Z : C} (h : CategoryTheory.SmallObject.functorObj f πX ⟶ Z),
CategoryTheory.CategoryStruct.comp (f x.i)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Sigma.ι (CategoryTheory.SmallObject.functorObjTgtFamily f πX) x)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.ρFunctorObj f πX) h)) =
CategoryTheory.CategoryStruct.comp x.t
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.ιFunctorObj f πX) h) |
ContinuousLinearMap.IsIdempotentElem.ext | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p q : M →L[R] M},
IsIdempotentElem p → IsIdempotentElem q → (↑p).range = (↑q).range ∧ (↑p).ker = (↑q).ker → p = q |
_private.Mathlib.RingTheory.MvPowerSeries.Order.0.MvPowerSeries.le_weightedOrder._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ}, (↑m < ↑n) = (m < n) |
Pi.cancelMonoid._proof_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → CancelMonoid (f i)], IsRightCancelMul ((i : I) → f i) |
ULift.forall | Mathlib.Data.ULift | ∀ {α : Type u} {p : ULift.{u_1, u} α → Prop}, (∀ (x : ULift.{u_1, u} α), p x) ↔ ∀ (x : α), p { down := x } |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.Action.hugeNumber | Lean.Meta.Tactic.Grind.Intro | ℕ |
MonoidHom.smulOneHom | Mathlib.Algebra.Group.Action.Hom | {M : Type u_4} →
{N : Type u_5} →
[inst : Monoid M] → [inst_1 : MulOneClass N] → [inst_2 : MulAction M N] → [IsScalarTower M N N] → M →* N |
Lean.Macro.State | Init.Prelude | Type |
List.perm_reverse | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Perm l₂.reverse ↔ l₁.Perm l₂ |
CategoryTheory.EnrichedCat.bicategory._proof_3 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c : CategoryTheory.EnrichedCat V} {f g : CategoryTheory.EnrichedFunctor V ↑a ↑b}
{h i : CategoryTheory.EnrichedFunctor V ↑b ↑c} (α : f ⟶ g) (β : h ⟶ i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.EnrichedCat.whiskerLeft f β)
(CategoryTheory.EnrichedCat.whiskerRight α i) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.EnrichedCat.whiskerRight α h)
(CategoryTheory.EnrichedCat.whiskerLeft g β) |
UInt16.toUInt32_and | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a &&& b).toUInt32 = a.toUInt32 &&& b.toUInt32 |
Lean.Grind.instToIntIntIi._proof_2 | Init.GrindInstances.ToInt | ∀ (x : ℤ), id x ∈ Lean.Grind.IntInterval.ii |
SimpleGraph.Walk.isHamiltonianCycle_iff_isCycle_and_support_count_tail_eq_one | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a},
p.IsHamiltonianCycle ↔ p.IsCycle ∧ ∀ (a_1 : α), List.count a_1 p.support.tail = 1 |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.brecOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive : Lean.Meta.Grind.Arith.CommRing.PolyDerivation → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
((t : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.below t → motive t) →
motive t |
_private.Mathlib.Analysis.Convex.Segment.0.insert_endpoints_openSegment._simp_1_1 | Mathlib.Analysis.Convex.Segment | ∀ {α : Type u} [inst : HasSubset α] {a b : α} [Std.Refl fun x1 x2 => x1 ⊆ x2] [Std.Antisymm fun x1 x2 => x1 ⊆ x2],
(a = b) = (a ⊆ b ∧ b ⊆ a) |
MeasureTheory.AEStronglyMeasurable.add_const | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : Add β] [ContinuousAdd β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (c : β), MeasureTheory.AEStronglyMeasurable (fun x => f x + c) μ |
Monoid.PushoutI.hom_ext_iff | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} {K : Type u_4} [inst : Monoid K] [inst_1 : (i : ι) → Monoid (G i)]
[inst_2 : Monoid H] {φ : (i : ι) → H →* G i} {f g : Monoid.PushoutI φ →* K},
f = g ↔
(∀ (i : ι), f.comp (Monoid.PushoutI.of i) = g.comp (Monoid.PushoutI.of i)) ∧
f.comp (Monoid.PushoutI.base φ) = g.comp (Monoid.PushoutI.base φ) |
_private.Aesop.Nanos.0.Aesop.instBEqNanos.beq.match_1 | Aesop.Nanos | (motive : Aesop.Nanos → Aesop.Nanos → Sort u_1) →
(x x_1 : Aesop.Nanos) →
((a b : ℕ) → motive { nanos := a } { nanos := b }) → ((x x_2 : Aesop.Nanos) → motive x x_2) → motive x x_1 |
HXor.mk.noConfusion | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : outParam (Type w)} →
{P : Sort u_1} → {hXor hXor' : α → β → γ} → { hXor := hXor } = { hXor := hXor' } → (hXor ≍ hXor' → P) → P |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_of_two_pow_le_and_two_pow_add_one_gt._proof_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ {n : ℕ} {i : ℕ}, ∀ i' ≥ i, ¬i = i' → ¬i + 1 ≤ i' → False |
CategoryTheory.MonObj.pow_comp | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N X : C} [inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] (f : X ⟶ M) (n : ℕ) (g : M ⟶ N)
[CategoryTheory.IsMonHom g], CategoryTheory.CategoryStruct.comp (f ^ n) g = CategoryTheory.CategoryStruct.comp f g ^ n |
_private.Init.Data.List.Sort.Basic.0.List.merge.match_1 | Init.Data.List.Sort.Basic | {α : Type u_1} →
(motive : List α → List α → Sort u_2) →
(xs ys : List α) →
((ys : List α) → motive [] ys) →
((xs : List α) → motive xs []) →
((x : α) → (xs : List α) → (y : α) → (ys : List α) → motive (x :: xs) (y :: ys)) → motive xs ys |
Polynomial.contentIdeal_le_span_content | Mathlib.RingTheory.Polynomial.ContentIdeal | ∀ {R : Type u_3} [inst : CommRing R] [inst_1 : NormalizedGCDMonoid R] {p : Polynomial R},
p.contentIdeal ≤ Ideal.span {p.content} |
Mathlib.Tactic.LibraryRewrite.Kind.hypothesis.sizeOf_spec | Mathlib.Tactic.Widget.LibraryRewrite | sizeOf Mathlib.Tactic.LibraryRewrite.Kind.hypothesis = 1 |
exists_ne_mem_inter_of_not_pairwise_disjoint | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {ι : Type u_4} {f : ι → Set α},
¬Pairwise (Function.onFun Disjoint f) → ∃ i j, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.isAdmissible_iff_isChain_and_le._proof_1_20 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ {m : ℕ} (k : ℕ), m + (k + 1) ≤ m + 1 + k |
Std.DTreeMap.Equiv.getEntryGT_eq.match_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₁ : Std.DTreeMap α β cmp} {k : α} (x : α)
(motive : x ∈ t₁ ∧ cmp x k = Ordering.gt → Prop) (x_1 : x ∈ t₁ ∧ cmp x k = Ordering.gt),
(∀ (h₁ : x ∈ t₁) (h₂ : cmp x k = Ordering.gt), motive ⋯) → motive x_1 |
CommGroupWithZero.toGroupWithZero | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} → [self : CommGroupWithZero G₀] → GroupWithZero G₀ |
Lean.Grind.CommRing.Mon.sharesVar._unary | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | (_ : Lean.Grind.CommRing.Mon) ×' Lean.Grind.CommRing.Mon → Bool |
Aesop.NormalizationState.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.NormalizationState} → t = t' → Aesop.NormalizationState.noConfusionType P t t' |
CategoryTheory.CopyDiscardCategory.copy_tensor | Mathlib.CategoryTheory.CopyDiscardCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.CopyDiscardCategory C] (X Y : C),
CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.ComonObj.comul CategoryTheory.ComonObj.comul)
(CategoryTheory.MonoidalCategory.tensorμ X X Y Y) |
Lean.Meta.Try.collect | Lean.Meta.Tactic.Try.Collect | Lean.MVarId → Lean.Try.Config → Lean.MetaM Lean.Meta.Try.Info |
MeasureTheory.SimpleFunc.noConfusionType | Mathlib.MeasureTheory.Function.SimpleFunc | Sort u_1 →
{α : Type u} →
[inst : MeasurableSpace α] →
{β : Type v} →
MeasureTheory.SimpleFunc α β →
{α' : Type u} → [inst' : MeasurableSpace α'] → {β' : Type v} → MeasureTheory.SimpleFunc α' β' → Sort u_1 |
Std.ExtDTreeMap.eq_empty_iff_size_eq_zero | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
t = ∅ ↔ t.size = 0 |
Multiset.ssubset_singleton_iff | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α} {a : α}, s ⊂ {a} ↔ s = 0 |
UpperSet.completeLattice | Mathlib.Order.UpperLower.CompleteLattice | {α : Type u_1} → [inst : LE α] → CompleteLattice (UpperSet α) |
QuotientGroup.dense_preimage_mk._simp_2 | Mathlib.Topology.Algebra.Group.Quotient | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [SeparatelyContinuousMul G] {N : Subgroup G}
{s : Set (G ⧸ N)}, Dense (QuotientGroup.mk ⁻¹' s) = Dense s |
NonarchAddGroupSeminorm.instZero._proof_3 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (x : E), 0 (-x) = 0 (-x) |
Std.Iter.toList_zip_of_finite_right | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ α₂ β₁ β₂ : Type u_1} [inst : Std.Iterator α₁ Id β₁] [inst_1 : Std.Iterator α₂ Id β₂] {it₁ : Std.Iter β₁}
{it₂ : Std.Iter β₂} [Std.Iterators.Productive α₁ Id] [Std.Iterators.Finite α₂ Id],
(it₁.zip it₂).toList = (Std.Iter.take it₂.toList.length it₁).toList.zip it₂.toList |
Set.BijOn.surjOn | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.BijOn f s t → Set.SurjOn f s t |
MeasureTheory.Measure.FiniteAtFilter | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} → {_m0 : MeasurableSpace α} → MeasureTheory.Measure α → Filter α → Prop |
_private.Mathlib.GroupTheory.OrderOfElement.0.mem_zpowers_zpow_iff._simp_1_4 | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (∃ c, b = a * c) = (a ∣ b) |
Lean.Parser.nameLitFn | Lean.Parser.Basic | Lean.Parser.ParserFn |
QuaternionAlgebra.instRing._proof_3 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : CommRing R] (x : QuaternionAlgebra R c₁ c₂ c₃), 0 * x = 0 |
ConditionallyCompletePartialOrderInf.isGLB_csInf_of_directed | Mathlib.Order.ConditionallyCompletePartialOrder.Defs | ∀ {α : Type u_3} [self : ConditionallyCompletePartialOrderInf α] (s : Set α),
DirectedOn (fun x1 x2 => x1 ≥ x2) s → s.Nonempty → BddBelow s → IsGLB s (sInf s) |
CategoryTheory.Endofunctor.Algebra.Hom.mk.inj | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {F : CategoryTheory.Functor C C}
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} {f : A₀.a ⟶ A₁.a}
{h :
autoParam (CategoryTheory.CategoryStruct.comp (F.map f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str f)
CategoryTheory.Endofunctor.Algebra.Hom.h._autoParam}
{f_1 : A₀.a ⟶ A₁.a}
{h_1 :
autoParam (CategoryTheory.CategoryStruct.comp (F.map f_1) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str f_1)
CategoryTheory.Endofunctor.Algebra.Hom.h._autoParam},
{ f := f, h := h } = { f := f_1, h := h_1 } → f = f_1 |
CategoryTheory.Limits.PushoutCocone.ofCocone | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor CategoryTheory.Limits.WalkingSpan C} →
CategoryTheory.Limits.Cocone F →
CategoryTheory.Limits.PushoutCocone (F.map CategoryTheory.Limits.WalkingSpan.Hom.fst)
(F.map CategoryTheory.Limits.WalkingSpan.Hom.snd) |
LaurentSeries.coe_range_dense | Mathlib.RingTheory.LaurentSeries | ∀ {K : Type u_2} [inst : Field K], DenseRange ⇑(algebraMap (RatFunc K) (LaurentSeries K)) |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.isCyclotomicExtension_iff_eq_adjoin._simp_1_9 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
WeierstrassCurve.Projective.addY_of_X_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P Q : Fin 3 → F},
W.Equation P →
W.Equation Q → P 2 ≠ 0 → Q 2 ≠ 0 → P 0 * Q 2 = Q 0 * P 2 → W.addY P Q = WeierstrassCurve.Projective.addU P Q |
MeasureTheory.hittingBtwn.eq_1 | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Preorder ι] [inst_1 : InfSet ι] (u : ι → Ω → β) (s : Set β)
(n m : ι) (x : Ω),
MeasureTheory.hittingBtwn u s n m x = if ∃ j ∈ Set.Icc n m, u j x ∈ s then sInf (Set.Icc n m ∩ {i | u i x ∈ s}) else m |
CategoryTheory.Functor.Faithful.mapMon | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] [F.Faithful], F.mapMon.Faithful |
Finset.inv_subset_inv | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Inv α] {s t : Finset α}, s ⊆ t → s⁻¹ ⊆ t⁻¹ |
Algebra.Extension.tensorCotangentInvFun._proof_5 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] {P : Algebra.Extension R S} {Q : Algebra.Extension R T}
[alg : Algebra P.Ring Q.Ring], IsScalarTower P.Ring Q.Ring ↥Q.ker |
groupHomology.coinfNatTrans._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ (k : Type u_1) {G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal] (n : ℕ)
{X Y : Rep k G} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((groupHomology.functor k G n).map φ)
(groupHomology.map (QuotientGroup.mk' S)
(Y.mkQ (Representation.Coinvariants.ker (MonoidHom.comp Y.ρ S.subtype)) ⋯) n) =
CategoryTheory.CategoryStruct.comp
(groupHomology.map (QuotientGroup.mk' S)
(X.mkQ (Representation.Coinvariants.ker (MonoidHom.comp X.ρ S.subtype)) ⋯) n)
(((Rep.quotientToCoinvariantsFunctor k S).comp (groupHomology.functor k (G ⧸ S) n)).map φ) |
Nat.odd_mul_odd_div_two | Mathlib.Data.Nat.ModEq | ∀ {m n : ℕ}, m % 2 = 1 → n % 2 = 1 → m * n / 2 = m * (n / 2) + m / 2 |
initFn._@.Lean.Elab.Tactic.TreeTacAttr.1721268732._hygCtx._hyg.2 | Lean.Elab.Tactic.TreeTacAttr | IO Lean.Meta.SimpExtension |
Computability.encodingNatBool | Mathlib.Computability.Encoding | Computability.Encoding ℕ |
Std.Do.Spec.modifyGet_StateT | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {σ α : Type u} {f : σ → α × σ}
{Q : Std.Do.PostCond α (Std.Do.PostShape.arg σ ps)} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps],
⦃fun s =>
have t := f s;
Q.1 t.1 t.2⦄
MonadStateOf.modifyGet f ⦃Q⦄ |
PartOrdEmb.instConcreteCategoryOrderEmbeddingCarrier._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ {X Y : PartOrdEmb} (f : ↑X ↪o ↑Y), { hom' := f }.hom' = f |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_56 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x head : α) (tail : List α),
¬([(head :: tail).getLast ⋯] ++ [x]).dropLast.isEmpty = true → ([(head :: tail).getLast ⋯] ++ [x]).dropLast ≠ [] |
Lean.VersoModuleDocs.snippets | Lean.DocString.Extension | Lean.VersoModuleDocs → Lean.PersistentArray Lean.VersoModuleDocs.Snippet |
Std.Time.instHSubOffsetOffset_22 | Std.Time.Date.Basic | HSub Std.Time.Minute.Offset Std.Time.Day.Offset Std.Time.Minute.Offset |
instMulPosMonoWithZeroOfMulRightMono | Mathlib.Algebra.Order.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α] [MulRightMono α], MulPosMono (WithZero α) |
CFC.nnrpow_two | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : NonUnitalRing A] [inst_2 : TopologicalSpace A] [inst_3 : StarRing A]
[inst_4 : Module ℝ A] [inst_5 : SMulCommClass ℝ A A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : StarOrderedRing A]
[inst_8 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_9 : NonnegSpectrumClass ℝ A] (a : A),
autoParam (0 ≤ a) CFC.nnrpow_two._auto_1 → a ^ 2 = a * a |
Std.ExtDHashMap.instInsertSigmaOfEquivBEqOfLawfulHashable.match_1 | Std.Data.ExtDHashMap.Basic | {α : Type u_1} →
{β : α → Type u_2} →
{x : BEq α} →
{x_1 : Hashable α} →
(motive : (a : α) × β a → Std.ExtDHashMap α β → Sort u_3) →
(x_2 : (a : α) × β a) →
(x_3 : Std.ExtDHashMap α β) →
((a : α) → (b : β a) → (s : Std.ExtDHashMap α β) → motive ⟨a, b⟩ s) → motive x_2 x_3 |
CategoryTheory.Oplax.OplaxTrans.vcomp._proof_5 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.OplaxFunctor B C} (η : CategoryTheory.Oplax.OplaxTrans F G)
(θ : CategoryTheory.Oplax.OplaxTrans G H) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map (CategoryTheory.CategoryStruct.comp f g)) (η.app c) (θ.app c)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (η.naturality (CategoryTheory.CategoryStruct.comp f g)) (θ.app c))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (η.app a) (G.map (CategoryTheory.CategoryStruct.comp f g))
(θ.app c)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (η.app a) (θ.naturality (CategoryTheory.CategoryStruct.comp f g)))
(CategoryTheory.Bicategory.associator (η.app a) (θ.app a)
(H.map (CategoryTheory.CategoryStruct.comp f g))).inv))))
(CategoryTheory.Bicategory.whiskerLeft (CategoryTheory.CategoryStruct.comp (η.app a) (θ.app a)) (H.mapComp f g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map (CategoryTheory.CategoryStruct.comp f g)) (η.app c) (θ.app c)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerRight (F.mapComp f g) (η.app c))
(θ.app c))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight
(CategoryTheory.Bicategory.associator (F.map f) (F.map g) (η.app c)).hom (θ.app c))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) (η.app c))
(θ.app c)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (F.map f)
(CategoryTheory.Bicategory.whiskerRight (η.naturality g) (θ.app c)))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (F.map f)
(CategoryTheory.Bicategory.associator (η.app b) (G.map g) (θ.app c)).hom)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (η.app b)
(CategoryTheory.CategoryStruct.comp (G.map g) (θ.app c))).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (CategoryTheory.CategoryStruct.comp (F.map f) (η.app b))
(θ.naturality g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (η.naturality f)
(CategoryTheory.CategoryStruct.comp (θ.app b) (H.map g)))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (η.app a) (G.map f)
(CategoryTheory.CategoryStruct.comp (θ.app b) (H.map g))).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (η.app a)
(CategoryTheory.Bicategory.associator (G.map f) (θ.app b) (H.map g)).inv)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (η.app a)
(CategoryTheory.Bicategory.whiskerRight (θ.naturality f) (H.map g)))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (η.app a)
(CategoryTheory.Bicategory.associator (θ.app a) (H.map f) (H.map g)).hom)
(CategoryTheory.Bicategory.associator (η.app a) (θ.app a)
(CategoryTheory.CategoryStruct.comp (H.map f) (H.map g))).inv)))))))))))) |
Antitone.iSup_comp_tendsto_atBot | Mathlib.Order.Filter.AtTopBot.CompleteLattice | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : ConditionallyCompleteLattice γ]
[OrderTop γ] {l : Filter α} [l.NeBot] {f : β → γ},
Antitone f → ∀ {g : α → β}, Filter.Tendsto g l Filter.atBot → ⨆ a, f (g a) = ⨆ b, f b |
CategoryTheory.Mat.instAddCommGroupHom | Mathlib.CategoryTheory.Preadditive.Mat | (R : Type) → [inst : Ring R] → (X Y : CategoryTheory.Mat R) → AddCommGroup (X ⟶ Y) |
RingQuot.ringQuot_ext | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Semiring R] {T : Type uT} [inst_1 : NonAssocSemiring T] {r : R → R → Prop}
(f g : RingQuot r →+* T), f.comp (RingQuot.mkRingHom r) = g.comp (RingQuot.mkRingHom r) → f = g |
CategoryTheory.Adjunction.compUliftCoyonedaIso_inv_app_app_down | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (X : Cᵒᵖ) (X_1 : D)
(a :
((CategoryTheory.uliftCoyoneda.{max w v₂, v₁, u₁}.comp
((CategoryTheory.Functor.whiskeringLeft D C (Type (max (max w v₂) v₁))).obj G)).obj
X).obj
X_1),
((adj.compUliftCoyonedaIso.inv.app X).app X_1 a).down =
CategoryTheory.CategoryStruct.comp (F.map a.down) (adj.counit.app X_1) |
AlgebraicGeometry.isIso_ΓSpec_adjunction_unit_app_basicOpen | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X : AlgebraicGeometry.Scheme} [CompactSpace ↥X] [QuasiSeparatedSpace ↥X] (f : ↑(X.presheaf.obj (Opposite.op ⊤))),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.app X.toSpecΓ (PrimeSpectrum.basicOpen f)) |
RingEquiv.toNonUnitalRingHom_trans | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} {S' : Type u_6} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring S'] (e₁ : R ≃+* S) (e₂ : S ≃+* S'),
(e₁.trans e₂).toNonUnitalRingHom = e₂.toNonUnitalRingHom.comp e₁.toNonUnitalRingHom |
AddSubgroup.single_mem_pi._simp_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → AddGroup (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → AddSubgroup (f i)} (i : η) (x : f i), (Pi.single i x ∈ AddSubgroup.pi I H) = (i ∈ I → x ∈ H i) |
Lean.Parser.«_aux_Init_Simproc___macroRules_Lean_Parser_command__Simproc__[_]_(_):=__1» | Init.Simproc | Lean.Macro |
Nat.exists_subseq_of_forall_mem_union | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {s t : Set α} (e : ℕ → α),
(∀ (n : ℕ), e n ∈ s ∪ t) → ∃ g, (∀ (n : ℕ), e (g n) ∈ s) ∨ ∀ (n : ℕ), e (g n) ∈ t |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.SavedState.mk.injEq | Lean.Elab.StructInst | ∀ (termState : Lean.Elab.Term.SavedState) (state : Lean.Elab.Term.StructInst.StructInstState✝)
(termState_1 : Lean.Elab.Term.SavedState) (state_1 : Lean.Elab.Term.StructInst.StructInstState✝¹),
({ termState := termState, state := state } = { termState := termState_1, state := state_1 }) =
(termState = termState_1 ∧ state = state_1) |
CategoryTheory.FreeMonoidalCategory.Hom.l_inv | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} → (X : CategoryTheory.FreeMonoidalCategory C) → X.Hom (CategoryTheory.FreeMonoidalCategory.unit.tensor X) |
HomotopyGroup.commGroup._proof_3 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] [inst_2 : Nontrivial N],
EckmannHilton.IsUnital Mul.mul ⟦GenLoop.const⟧ |
hasStrictDerivAt_exp_smul_const_of_mem_ball | Mathlib.Analysis.SpecialFunctions.Exponential | ∀ {𝕂 : Type u_1} {𝔸 : Type u_3} [inst : NontriviallyNormedField 𝕂] [CharZero 𝕂] [inst_2 : NormedRing 𝔸]
[inst_3 : NormedAlgebra 𝕂 𝔸] [CompleteSpace 𝔸] (x : 𝔸) (t : 𝕂),
t • x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius →
HasStrictDerivAt (fun u => NormedSpace.exp (u • x)) (NormedSpace.exp (t • x) * x) t |
CategoryTheory.Functor.ι_biproductComparison'_assoc | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {J : Type w₁}
(F : CategoryTheory.Functor C D) (f : J → C) [inst_4 : CategoryTheory.Limits.HasBiproduct f]
[inst_5 : CategoryTheory.Limits.HasBiproduct (F.obj ∘ f)] (j : J) {Z : D} (h : F.obj (⨁ f) ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.ι (F.obj ∘ f) j)
(CategoryTheory.CategoryStruct.comp (F.biproductComparison' f) h) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.biproduct.ι f j)) h |
_private.Lean.Parser.Tactic.Doc.0.Lean.Parser.Tactic.Doc.initFn._@.Lean.Parser.Tactic.Doc.1176478476._hygCtx._hyg.2 | Lean.Parser.Tactic.Doc | IO Unit |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_le_length_insertEntry._proof_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} {l : List ((a : α) × β a)}, ¬l.length ≤ l.length + 1 → False |
IntermediateField.restrict_algEquiv._proof_20 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_2} {L : Type u_1} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {F : IntermediateField K L}
(q : ℚ≥0) (x : ↥F.toSubfield), ↑(q • x) = q • ↑x |
String.rawStartPos_eq | Init.Data.String.Defs | ∀ {s : String}, s.rawStartPos = 0 |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.le_weightedOrder_subst_of_forall_ne_zero._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i |
CategoryTheory.congrArg_cast_hom_left | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (p : X = Y) (q : Y ⟶ Z),
cast ⋯ q = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p) q |
Topology.IsInducing.mk | Mathlib.Topology.Defs.Induced | ∀ {X : Type u_1} {Y : Type u_2} [tX : TopologicalSpace X] [tY : TopologicalSpace Y] {f : X → Y},
tX = TopologicalSpace.induced f tY → Topology.IsInducing f |
WType.mk.injEq | Mathlib.Data.W.Basic | ∀ {α : Type u_1} {β : α → Type u_2} (a : α) (f : β a → WType β) (a_1 : α) (f_1 : β a_1 → WType β),
(WType.mk a f = WType.mk a_1 f_1) = (a = a_1 ∧ f ≍ f_1) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.