name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
List.infix_append' | Init.Data.List.Sublist | ∀ {α : Type u_1} (l₁ l₂ l₃ : List α), l₂ <:+: l₁ ++ (l₂ ++ l₃) |
LinearMap.re_inner_adjoint_mul_self_nonneg | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] (T : E →ₗ[𝕜] E) (x : E), 0 ≤ RCLike.re (inner 𝕜 x ((LinearMap.adjoint T * T) x)) |
Algebra.norm_eq_of_ringEquiv | Mathlib.RingTheory.Norm.Basic | ∀ {A : Type u_8} {B : Type u_9} {C : Type u_10} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Ring C]
[inst_3 : Algebra A C] [inst_4 : Algebra B C] (e : A ≃+* B),
(algebraMap B C).comp ↑e = algebraMap A C → ∀ (x : C), e ((Algebra.norm A) x) = (Algebra.norm B) x |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processId.match_1 | Lean.Elab.PatternVar | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (some (Lean.ConstantInfo.ctorInfo val))) →
((val : Lean.ConstantInfo) → motive (some val)) → (Unit → motive none) → motive x |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.rewriteOneFile.match_7 | Mathlib.Tactic.Linter.FindDeprecations | (motive : List String.Pos.Raw → Sort u_1) →
(x : List String.Pos.Raw) →
((a b _c : String.Pos.Raw) → motive [a, b, _c]) → ((x : List String.Pos.Raw) → motive x) → motive x |
_private.Lean.Meta.Transform.0.Lean.Meta.unfoldIfArgIsAppOf._sparseCasesOn_1 | Lean.Meta.Transform | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
CategoryTheory.Limits.HasWideCoequalizer | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} → {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (J → (X ⟶ Y)) → Prop |
IsCompact.of_subset_of_specializes | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X},
IsCompact s → t ⊆ s → (∀ x ∈ s, ∃ y ∈ t, x ⤳ y) → IsCompact t |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.TFAE_exists_lt_isLittleO_pow.match_1_7 | Mathlib.Analysis.SpecificLimits.Normed | ∀ (f : ℕ → ℝ) (R : ℝ) (motive : (∃ a ∈ Set.Ioo 0 R, f =O[Filter.atTop] fun x => a ^ x) → Prop)
(x : ∃ a ∈ Set.Ioo 0 R, f =O[Filter.atTop] fun x => a ^ x),
(∀ (a : ℝ) (ha : a ∈ Set.Ioo 0 R) (H : f =O[Filter.atTop] fun x => a ^ x), motive ⋯) → motive x |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor? | Lean.Meta.Tactic.Grind.PropagateInj | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Option (Lean.Expr × Lean.Expr)) |
Quaternion.imI_sub | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a b : Quaternion R), (a - b).imI = a.imI - b.imI |
LE.le.lt_or_eq_dec | Mathlib.Order.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} [DecidableLE α], a ≤ b → a < b ∨ a = b |
Int.dvd_add_self_mul | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a ∣ b + a * c ↔ a ∣ b |
Lean.Meta.Grind.instInhabitedEntry | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.Entry |
List.findIdx_singleton | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {p : α → Bool}, List.findIdx p [a] = if p a = true then 0 else 1 |
Pi.Lex.wellFounded | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} (r : ι → ι → Prop) {s : (i : ι) → α i → α i → Prop} [IsStrictTotalOrder ι r]
[Finite ι], (∀ (i : ι), WellFounded (s i)) → WellFounded (Pi.Lex r fun {i} => s i) |
LinearEquiv.conjRingEquiv._proof_1 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_4} {M₁ : Type u_2} {M₂ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M₁] [inst_5 : Module R₂ M₂]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_6 : RingHomInvPair σ₁₂ σ₂₁] [inst_7 : RingHomInvPair σ₂₁ σ₁₂]
(e : M₁ ≃ₛₗ[σ₁₂] M₂) (x y : M₁ →ₗ[R₁] M₁),
(e.arrowCongrAddEquiv e).toFun (x + y) = (e.arrowCongrAddEquiv e).toFun x + (e.arrowCongrAddEquiv e).toFun y |
_private.Mathlib.Topology.Instances.Irrational.0.dense_irrational._simp_1_2 | Mathlib.Topology.Instances.Irrational | ∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b) |
InfiniteGalois.GaloisCoinsertionIntermediateFieldSubgroup._proof_2 | Mathlib.FieldTheory.Galois.Infinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] [IsGalois k K]
(K_1 : IntermediateField k K),
((fun H => IntermediateField.fixedField H) ∘ ⇑OrderDual.toDual)
((⇑OrderDual.toDual ∘ fun E => E.fixingSubgroup) K_1) ≤
K_1 |
Aesop.RuleStatsTotals.compareByTotalElapsed | Aesop.Stats.Basic | Aesop.RuleStatsTotals → Aesop.RuleStatsTotals → Ordering |
CategoryTheory.toPresheafToSheafCompComposeAndSheafify | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
(F : CategoryTheory.Functor A B) →
[inst_3 : CategoryTheory.HasWeakSheafify J B] →
[inst_4 : CategoryTheory.HasWeakSheafify J A] →
((CategoryTheory.Functor.whiskeringRight Cᵒᵖ A B).obj F).comp (CategoryTheory.presheafToSheaf J B) ⟶
(CategoryTheory.presheafToSheaf J A).comp (CategoryTheory.Sheaf.composeAndSheafify J F) |
Isometry.isometryEquivOnRange | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} →
{β : Type v} →
[inst : EMetricSpace α] → [inst_1 : PseudoEMetricSpace β] → {f : α → β} → Isometry f → α ≃ᵢ ↑(Set.range f) |
_private.Lean.Meta.LevelDefEq.0.Lean.Meta.solve.match_3 | Lean.Meta.LevelDefEq | (motive : Lean.Level → Lean.Level → Sort u_1) →
(u v : Lean.Level) →
((mvarId : Lean.LMVarId) → (x : Lean.Level) → motive (Lean.Level.mvar mvarId) x) →
((x : Lean.Level) → (a : Lean.LMVarId) → motive x (Lean.Level.mvar a)) →
((v₁ v₂ : Lean.Level) → motive Lean.Level.zero (v₁.max v₂)) →
((a v₂ : Lean.Level) → motive Lean.Level.zero (a.imax v₂)) →
((a : Lean.Level) → motive Lean.Level.zero a.succ) →
((u v : Lean.Level) → motive u.succ v) → ((x x_1 : Lean.Level) → motive x x_1) → motive u v |
Std.Do.SPred.entails.trans' | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R : Std.Do.SPred σs}, (P ⊢ₛ Q) → (P ∧ Q ⊢ₛ R) → P ⊢ₛ R |
Iff.not | Mathlib.Logic.Basic | ∀ {a b : Prop}, (a ↔ b) → (¬a ↔ ¬b) |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.largeSchroderSeries_eq_one_add_X_mul_largeSchroderSeries_add_X_mul_largeSchroderSeries_sq._proof_1_3 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ (n : ℕ), 0 < n → ¬n = n - 1 + 1 → False |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._simp_1_28 | Mathlib.Algebra.Lie.CartanExists | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) |
Subarray.mkSlice_roc_eq_mkSlice_rcc | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo hi : ℕ},
(Std.Roc.Sliceable.mkSlice xs lo<...=hi) = Std.Rcc.Sliceable.mkSlice xs (lo + 1)...=hi |
AddSubmonoid.toNatSubmodule._proof_2 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {M : Type u_1} [inst : AddCommMonoid M],
Function.RightInverse Submodule.toAddSubmonoid fun S => { toAddSubmonoid := S, smul_mem' := ⋯ } |
List.findIdxNth.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (p : α → Bool) (xs : List α) (n : ℕ), List.findIdxNth p xs n = List.findIdxNth.go p xs n 0 |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mpullback_mlieBracket._simp_1_2 | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {x : M},
MDifferentiableAt I I' f x = MDifferentiableWithinAt I I' f Set.univ x |
Lean.IR.FnBody.set | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ → Lean.IR.Arg → Lean.IR.FnBody → Lean.IR.FnBody |
Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (n n_1 : ℕ),
(Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n = Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst n_1) = (n = n_1) |
Std.IterM.TerminationMeasures.Finite.mk._flat_ctor | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} → [inst : Std.Iterator α m β] → Std.IterM m β → Std.IterM.TerminationMeasures.Finite α m |
Lean.JsonNumber.recOn | Lean.Data.Json.Basic | {motive : Lean.JsonNumber → Sort u} →
(t : Lean.JsonNumber) →
((mantissa : ℤ) → (exponent : ℕ) → motive { mantissa := mantissa, exponent := exponent }) → motive t |
IsZGroup.instQuotientSubgroupOfFinite | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] [Finite G] [IsZGroup G] (H : Subgroup G) [inst_3 : H.Normal], IsZGroup (G ⧸ H) |
CartanMatrix.C | Mathlib.Data.Matrix.Cartan | (n : ℕ) → Matrix (Fin n) (Fin n) ℤ |
_private.Mathlib.Logic.Nonempty.0.exists_const_iff.match_1_1 | Mathlib.Logic.Nonempty | ∀ {α : Sort u_1} {P : Prop} (motive : (∃ x, P) → Prop) (x : ∃ x, P), (∀ (a : α) (h : P), motive ⋯) → motive x |
Set.disjoint_image_inl_image_inr | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {u : Set α} {v : Set β}, Disjoint (Sum.inl '' u) (Sum.inr '' v) |
Int8.not_xor | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, ~~~a ^^^ b = ~~~(a ^^^ b) |
StrictConvexOn.strictMonoOn_derivWithin | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ}, StrictConvexOn ℝ S f → DifferentiableOn ℝ f S → StrictMonoOn (derivWithin f S) S |
Lean.LeanOptionValue._sizeOf_inst | Lean.Util.LeanOptions | SizeOf Lean.LeanOptionValue |
CategoryTheory.Bicategory.InducedBicategory.Hom₂.casesOn | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {B : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Bicategory C] →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g → Sort u} →
(t : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g) →
((hom : f.hom ⟶ g.hom) → motive { hom := hom }) → motive t |
Std.HashMap.Raw.valuesIter | Std.Data.HashMap.Iterator | {α β : Type u} → Std.HashMap.Raw α β → Std.Iter β |
Dioph.«term_D*_» | Mathlib.NumberTheory.Dioph | Lean.TrailingParserDescr |
Turing.ToPartrec.Code.brecOn.eq | Mathlib.Computability.TMConfig | ∀ {motive : Turing.ToPartrec.Code → Sort u} (t : Turing.ToPartrec.Code)
(F_1 : (t : Turing.ToPartrec.Code) → Turing.ToPartrec.Code.below t → motive t),
Turing.ToPartrec.Code.brecOn t F_1 = F_1 t (Turing.ToPartrec.Code.brecOn.go t F_1).2 |
RootPairing.reflectionPerm_root | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (self : RootPairing ι R M N) (i j : ι),
self.root j - (self.toLinearMap (self.root j)) (self.coroot i) • self.root i = self.root ((self.reflectionPerm i) j) |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.noConfusion | Lean.DocString.Extension | {P : Sort u} →
{content : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock)} →
{priorParts : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)} →
{titleString : String} →
{title : Array (Lean.Doc.Inline Lean.ElabInline)} →
{content' : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock)} →
{priorParts' : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)} →
{titleString' : String} →
{title' : Array (Lean.Doc.Inline Lean.ElabInline)} →
{ content := content, priorParts := priorParts, titleString := titleString, title := title } =
{ content := content', priorParts := priorParts', titleString := titleString', title := title' } →
(content = content' → priorParts = priorParts' → titleString = titleString' → title = title' → P) →
P |
Std.DTreeMap.Internal.Impl.link.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hr_2 : Std.DTreeMap.Internal.Impl.leaf.Balanced),
Std.DTreeMap.Internal.Impl.link k v Std.DTreeMap.Internal.Impl.leaf r hr_2 hr =
{ impl := (Std.DTreeMap.Internal.Impl.insertMin k v r ⋯).impl, balanced_impl := ⋯, size_impl := ⋯ } |
CategoryTheory.cechNerveTerminalFrom._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasFiniteProducts C] (X : C)
(n : SimplexCategoryᵒᵖ), CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun x => X) |
Module.Relations.instQuotient | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u} → [inst : Ring A] → (relations : Module.Relations A) → Module A relations.Quotient |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._proof_17 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_4} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} {S' : C} {p : S' ⟶ S} {ι' : Type u_3} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'} {α : ι' → ι}
{p' : (j : ι') → X' j ⟶ X (α j)},
(∀ (j : ι'), CategoryTheory.CategoryStruct.comp (p' j) (f (α j)) = CategoryTheory.CategoryStruct.comp (f' j) p) →
∀ ⦃Y : C⦄ (q : Y ⟶ S') ⦃j₁ : ι'⦄ (f₁ : Y ⟶ X' j₁) (q' : Y ⟶ S) (f₁' : Y ⟶ X (α j₁)),
autoParam (CategoryTheory.CategoryStruct.comp f₁ (f' j₁) = q)
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._auto_1 →
autoParam (CategoryTheory.CategoryStruct.comp q p = q')
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._auto_5 →
autoParam (CategoryTheory.CategoryStruct.comp f₁ (p' j₁) = f₁')
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._auto_7 →
CategoryTheory.CategoryStruct.comp f₁' (f (α j₁)) = q' |
NegPart.mk._flat_ctor | Mathlib.Algebra.Notation | {α : Type u_1} → (α → α) → NegPart α |
Orientation.oangle_sign_neg_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), (o.oangle x (-y)).sign = -(o.oangle x y).sign |
derangements.Equiv.RemoveNone.fiber | Mathlib.Combinatorics.Derangements.Basic | {α : Type u_1} → [DecidableEq α] → Option α → Set (Equiv.Perm α) |
dist_neg | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] (x y : E), dist (-x) y = dist x (-y) |
CategoryTheory.SimplicialObject | Mathlib.AlgebraicTopology.SimplicialObject.Basic | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Type (max v u) |
LinearIsometryEquiv.toContinuousLinearEquiv | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{E : Type u_5} →
{E₂ : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
{σ₂₁ : R₂ →+* R} →
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] →
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] →
[inst_4 : SeminormedAddCommGroup E] →
[inst_5 : SeminormedAddCommGroup E₂] →
[inst_6 : Module R E] → [inst_7 : Module R₂ E₂] → (E ≃ₛₗᵢ[σ₁₂] E₂) → E ≃SL[σ₁₂] E₂ |
sum_chartAt_inr_apply | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u} {M : Type u_2} {M' : Type u_3} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
[inst_2 : TopologicalSpace M'] [cm : ChartedSpace H M] [cm' : ChartedSpace H M'] {x y : M'},
↑(chartAt H (Sum.inr x)) (Sum.inr y) = ↑(chartAt H x) y |
IsRadical.dvd_radical | Mathlib.RingTheory.Radical | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M}, IsRadical a → a ≠ 0 → a ∣ UniqueFactorizationMonoid.radical a |
_private.Batteries.Data.Fin.Lemmas.0.Fin.findSomeRev?_eq_some_iff.match_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α} {f : Fin n → Option α}
(motive : (∃ i, f i.rev = some a ∧ ∀ j < i, f j.rev = none) → Prop)
(x : ∃ i, f i.rev = some a ∧ ∀ j < i, f j.rev = none),
(∀ (i : Fin n) (h : f i.rev = some a ∧ ∀ j < i, f j.rev = none), motive ⋯) → motive x |
Pi.nonAssocSemiring._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonAssocSemiring (f i)] (a : (i : I) → f i), 1 * a = a |
CategoryTheory.ObjectProperty.IsClosedUnderQuotients.prop_of_epi | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P : CategoryTheory.ObjectProperty C}
[self : P.IsClosedUnderQuotients] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f], P X → P Y |
CategoryTheory.Regular.regularEpiIsStableUnderBaseChange | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Regular C],
(CategoryTheory.MorphismProperty.regularEpi C).IsStableUnderBaseChange |
Lean.Elab.Command.instMonadMacroAdapterCommandElabM | Lean.Elab.Command | Lean.Elab.MonadMacroAdapter Lean.Elab.Command.CommandElabM |
_private.Mathlib.Algebra.Order.Group.Indicator.0.Function.mulSupport_iSup._simp_1_3 | Mathlib.Algebra.Order.Group.Indicator | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x |
Std.Sat.AIG.RelabelNat.State.Inv2.below.gate | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {decls : Array (Std.Sat.AIG.Decl α)}
{motive : (a : ℕ) → (a_1 : Std.HashMap α ℕ) → Std.Sat.AIG.RelabelNat.State.Inv2 decls a a_1 → Prop} {idx : ℕ}
{map : Std.HashMap α ℕ} {l r : Std.Sat.AIG.Fanin} (hinv : Std.Sat.AIG.RelabelNat.State.Inv2 decls idx map)
(hlt : idx < decls.size) (hatom : decls[idx] = Std.Sat.AIG.Decl.gate l r),
Std.Sat.AIG.RelabelNat.State.Inv2.below hinv → motive idx map hinv → Std.Sat.AIG.RelabelNat.State.Inv2.below ⋯ |
Fin.insertNth_mul | Mathlib.Algebra.Group.Fin.Tuple | ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} [inst : (j : Fin (n + 1)) → Mul (α j)] (i : Fin (n + 1)) (x y : α i)
(p q : (j : Fin n) → α (i.succAbove j)), i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q |
SemiNormedGrp.explicitCokernelIso_hom_desc | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | ∀ {X Y Z : SemiNormedGrp} {f : X ⟶ Y} {g : Y ⟶ Z} (w : CategoryTheory.CategoryStruct.comp f g = 0),
CategoryTheory.CategoryStruct.comp (SemiNormedGrp.explicitCokernelIso f).hom
(CategoryTheory.Limits.cokernel.desc f g w) =
SemiNormedGrp.explicitCokernelDesc w |
Std.DHashMap.values | Std.Data.DHashMap.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (Std.DHashMap α fun x => β) → List β |
Set.Nonempty.image2 | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β},
s.Nonempty → t.Nonempty → (Set.image2 f s t).Nonempty |
StdSimplex.weights | Mathlib.LinearAlgebra.ConvexSpace | {R : Type u} → [inst : LE R] → [inst_1 : AddCommMonoid R] → [inst_2 : One R] → {M : Type v} → StdSimplex R M → M →₀ R |
_private.Init.Data.List.Basic.0.List.dropLast.match_1.splitter | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) →
(Unit → motive []) →
((head : α) → motive [head]) → ((a : α) → (as : List α) → (as = [] → False) → motive (a :: as)) → motive x |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Deriv.0.Real.iter_deriv_rpow_const._proof_1_4 | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ (r : ℝ) (k : ℕ) (y : ℝ),
y ^ (r - ↑k - 1) = y ^ (r - (↑k + 1)) ∨ Polynomial.eval r (descPochhammer ℝ k) = 0 ∨ r - ↑k = 0 |
CategoryTheory.Pseudofunctor.Grothendieck.Hom.fiber | Mathlib.CategoryTheory.Bicategory.Grothendieck | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} →
{X Y : F.Grothendieck} → (self : X.Hom Y) → (F.map self.base.toLoc).toFunctor.obj X.fiber ⟶ Y.fiber |
Set.ordConnected_pi' | Mathlib.Order.Interval.Set.OrdConnected | ∀ {ι : Type u_3} {α : ι → Type u_4} [inst : (i : ι) → Preorder (α i)] {s : Set ι} {t : (i : ι) → Set (α i)}
[h : ∀ (i : ι), (t i).OrdConnected], (s.pi t).OrdConnected |
CategoryTheory.MorphismProperty.LeftFraction.noConfusionType | Mathlib.CategoryTheory.Localization.CalculusOfFractions | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
W.LeftFraction X Y →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
{W' : CategoryTheory.MorphismProperty C'} → {X' Y' : C'} → W'.LeftFraction X' Y' → Sort u |
CategoryTheory.ChosenPullbacksAlong.binaryFanIsBinaryProduct._proof_4 | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong Z.hom] {T : CategoryTheory.Over X} (f : T ⟶ Y) (g : T ⟶ Z),
CategoryTheory.CategoryStruct.comp
((fun {T} u v => CategoryTheory.Over.homMk (CategoryTheory.ChosenPullbacksAlong.lift u.left v.left ⋯) ⋯) f g)
(CategoryTheory.ChosenPullbacksAlong.binaryFan Y Z).fst =
f |
LeftOrdContinuous.rightOrdContinuous_dual | Mathlib.Order.OrdContinuous | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
LeftOrdContinuous f → RightOrdContinuous (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) |
Lean.Grind.CommRing.Poly.denote_combineC | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.CommRing.Context α)
(p₁ p₂ : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (p₁.combineC p₂ c) =
Lean.Grind.CommRing.Poly.denote ctx p₁ + Lean.Grind.CommRing.Poly.denote ctx p₂ |
HahnEmbedding.Seed.rec | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
[inst_7 : Module K M] →
[inst_8 : IsOrderedModule K M] →
{R : Type u_3} →
[inst_9 : AddCommGroup R] →
[inst_10 : LinearOrder R] →
[inst_11 : Module K R] →
{motive : HahnEmbedding.Seed K M R → Sort u} →
((toArchimedeanStrata : HahnEmbedding.ArchimedeanStrata K M) →
(coeff :
(c : FiniteArchimedeanClass M) → ↥(toArchimedeanStrata.stratum c) →ₗ[K] R) →
(strictMono_coeff : ∀ (c : FiniteArchimedeanClass M), StrictMono ⇑(coeff c)) →
motive
{ toArchimedeanStrata := toArchimedeanStrata, coeff := coeff,
strictMono_coeff := strictMono_coeff }) →
(t : HahnEmbedding.Seed K M R) → motive t |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.rewriteOneFile.match_1 | Mathlib.Tactic.Linter.FindDeprecations | (motive : Lean.Name × Lean.Syntax.Range → Sort u_1) →
(x : Lean.Name × Lean.Syntax.Range) →
((decl : Lean.Name) → (s e : String.Pos.Raw) → motive (decl, { start := s, stop := e })) → motive x |
Lean.Parser.Command.versoCommentBody.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter |
_private.Mathlib.Algebra.MvPolynomial.Variables.0.MvPolynomial.vars_rename._simp_1_1 | Mathlib.Algebra.MvPolynomial.Variables | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ s.toFinset) = (a ∈ s) |
Std.TreeMap.Raw.getElem?_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ \ t₂)[k]? = none |
Std.HashMap.insertMany_ind | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {ρ : Type w} [inst : ForIn Id ρ (α × β)]
{motive : Std.HashMap α β → Prop} (m : Std.HashMap α β) {l : ρ},
motive m → (∀ (m : Std.HashMap α β) (a : α) (b : β), motive m → motive (m.insert a b)) → motive (m.insertMany l) |
Std.ExtTreeMap.minEntry.match_1 | Std.Data.ExtTreeMap.Basic | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering}
(motive : (t : Std.ExtTreeMap α β cmp) → t ≠ ∅ → t.inner = ∅ → Prop) (t : Std.ExtTreeMap α β cmp) (h : t ≠ ∅)
(x : t.inner = ∅), motive t h x |
Finsupp.domCongr_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (e : α ≃ β) (l : α →₀ M),
(Finsupp.domCongr e) l = Finsupp.equivMapDomain e l |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_neBot_iff._simp_1_2 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
RootPairing.EmbeddedG2.shortAddLong.eq_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N)
[inst_5 : P.EmbeddedG2],
RootPairing.EmbeddedG2.shortAddLong P =
(P.reflectionPerm (RootPairing.EmbeddedG2.long P)) (RootPairing.EmbeddedG2.short P) |
instMinNat | Init.Prelude | Min ℕ |
UniformSpaceCat.completionFunctor._proof_2 | Mathlib.Topology.Category.UniformSpace | ∀ {X Y Z : UniformSpaceCat} (f : X ⟶ Y) (g : Y ⟶ Z),
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.ConcreteCategory.ofHom
⟨UniformSpace.Completion.map ⇑(CategoryTheory.CategoryStruct.comp f g).hom', ⋯⟩).hom) =
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.ConcreteCategory.ofHom ⟨UniformSpace.Completion.map ⇑f.hom', ⋯⟩)
(CategoryTheory.ConcreteCategory.ofHom ⟨UniformSpace.Completion.map ⇑g.hom', ⋯⟩)).hom) |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.noConfusionType | Init.Data.Format.Basic | Sort u → Std.Format.WorkGroup✝ → Std.Format.WorkGroup✝ → Sort u |
integral_bilinear_hasLineDerivAt_right_eq_neg_left_of_integrable | Mathlib.Analysis.Calculus.LineDeriv.IntegrationByParts | ∀ {E : Type u_1} {F : Type u_2} {G : Type u_3} {W : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G]
[inst_6 : NormedAddCommGroup W] [inst_7 : NormedSpace ℝ W] [inst_8 : MeasurableSpace E] {μ : MeasureTheory.Measure E}
[BorelSpace E] [FiniteDimensional ℝ E] [μ.IsAddHaarMeasure] {f f' : E → F} {g g' : E → G} {v : E}
{B : F →L[ℝ] G →L[ℝ] W},
MeasureTheory.Integrable (fun x => (B (f' x)) (g x)) μ →
MeasureTheory.Integrable (fun x => (B (f x)) (g' x)) μ →
MeasureTheory.Integrable (fun x => (B (f x)) (g x)) μ →
(∀ (x : E), HasLineDerivAt ℝ f (f' x) x v) →
(∀ (x : E), HasLineDerivAt ℝ g (g' x) x v) → ∫ (x : E), (B (f x)) (g' x) ∂μ = -∫ (x : E), (B (f' x)) (g x) ∂μ |
BitVec.instHashable | Init.Data.BitVec.Basic | {n : ℕ} → Hashable (BitVec n) |
OrderRingHom.comp_id | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} {β : Type u_3} [inst : NonAssocSemiring α] [inst_1 : Preorder α] [inst_2 : NonAssocSemiring β]
[inst_3 : Preorder β] (f : α →+*o β), f.comp (OrderRingHom.id α) = f |
isLinearSet_iff_exists_fin_addMonoidHom | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M}, IsLinearSet s ↔ ∃ a n f, s = a +ᵥ Set.range ⇑f |
Std.DTreeMap.Internal.Impl.Const.minEntry._unary | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → (t : Std.DTreeMap.Internal.Impl α fun x => β) ×' t.isEmpty = false → α × β |
CochainComplex.HomComplex | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → CochainComplex C ℤ → CochainComplex C ℤ → CochainComplex AddCommGrpCat ℤ |
Char.reduceEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | Lean.Meta.Simp.Simproc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.