name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.Set.Finite.Lattice.0.Set.Finite.bddAbove_biUnion._simp_1_1 | Mathlib.Data.Set.Finite.Lattice | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], BddAbove ∅ = True | null | false |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(X : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ),
((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₁ =
CategoryTheory.CategoryStruct.id X.obj₁ | null | true |
CategoryTheory.Functor.instEffectiveEpiEffectiveEpiOver | Mathlib.CategoryTheory.EffectiveEpi.Enough | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) [inst_2 : F.EffectivelyEnough]
(X : D), CategoryTheory.EffectiveEpi (F.effectiveEpiOver X) | null | true |
derivWithin_fun_const | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (c : F), derivWithin (fun x => c) s = 0 | null | true |
CoeOut.mk | Init.Coe | {α : Sort u} → {β : semiOutParam (Sort v)} → (α → β) → CoeOut α β | null | true |
Preorder.frestrictLe₂.congr_simp | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {α : Type u_1} [inst : Preorder α] {π : α → Type u_2} [inst_1 : LocallyFiniteOrderBot α] {a b : α} (hab : a ≤ b)
(f f_1 : (i : ↥(Finset.Iic b)) → π ↑i),
f = f_1 → ∀ (i : ↥(Finset.Iic a)), Preorder.frestrictLe₂ hab f i = Preorder.frestrictLe₂ hab f_1 i | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory.0.CategoryTheory.Functor.cartesianMonoidalCategory._simp_5 | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f f' : X ⟶ Y) (g : Y ≅ Z),
(CategoryTheory.CategoryStruct.comp f g.hom = CategoryTheory.CategoryStruct.comp f' g.hom) = (f = f') | null | false |
CategoryTheory.Functor.IsCoverDense.sheafYonedaHom | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{K : CategoryTheory.GrothendieckTopology D} →
{A : Type u_4} →
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] →
{G : CategoryTheory... | (Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
| true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.IsCompact.nhds_hausdorff_eq_nhds_vietoris._simp_1_2 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | null | false |
Matroid.uniqueBaseOn_restrict | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I : Set α},
I ⊆ E → ∀ (R : Set α), (Matroid.uniqueBaseOn I E).restrict R = Matroid.uniqueBaseOn (I ∩ R) R | null | true |
FirstOrder.Language.Term.realize_var | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} (v : α → M) (k : α),
FirstOrder.Language.Term.realize v (FirstOrder.Language.var k) = v k | null | true |
GromovHausdorff.instInhabitedGHSpace._proof_2 | Mathlib.Topology.MetricSpace.GromovHausdorff | {0}.Nonempty | null | false |
Substring.Raw.ValidFor.dropWhile | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (p : Char → Bool) {s : Substring.Raw},
Substring.Raw.ValidFor l m r s →
Substring.Raw.ValidFor (l ++ List.takeWhile p m) (List.dropWhile p m) r (s.dropWhile p) | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialObject.II.0.SimplexCategory.II.last_mem_finset._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialObject.II | ∀ {n m : ℕ} (f : Fin (n + 1) →o Fin (m + 1)) (x : Fin (m + 2)) (i : Fin (n + 2)),
(i ∈ SimplexCategory.II.finset f x) =
(i = Fin.last (n + 1) ∨ ∃ (h : i ≠ Fin.last (n + 1)), x ≤ (f (i.castPred h)).castSucc) | null | false |
Stream'.Seq1.bind_assoc | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.Seq1 α) (f : α → Stream'.Seq1 β) (g : β → Stream'.Seq1 γ),
(s.bind f).bind g = s.bind fun x => (f x).bind g | null | true |
Mathlib.Tactic.ClickSuggestions.GrwLemma.casesOn | Mathlib.Tactic.ClickSuggestions.GRewrite | {motive : Mathlib.Tactic.ClickSuggestions.GrwLemma → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.GrwLemma) →
((name : Mathlib.Tactic.ClickSuggestions.Premise) →
(symm : Bool) → (relName : Lean.Name) → motive { name := name, symm := symm, relName := relName }) →
motive t | null | false |
Std.Time.Month.instInhabitedOrdinal | Std.Time.Date.Unit.Month | Inhabited Std.Time.Month.Ordinal | null | true |
Nat.le_three_of_sqrt_eq_one | Mathlib.Data.Nat.Sqrt | ∀ {n : ℕ}, n.sqrt = 1 → n ≤ 3 | null | true |
CategoryTheory.GrothendieckTopology.plusMap_toPlus | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTheory.Functo... | `(P ⟶ P⁺)⁺ = P⁺ ⟶ P⁺⁺` | true |
Derivation.couple._proof_10 | Mathlib.RingTheory.Derivation.Lie | ∀ (A : Type u_1) [inst : CommRing A], SMulCommClass A A A | null | false |
ZMod.eq_one_or_isUnit_sub_one | Mathlib.FieldTheory.Finite.Basic | ∀ {n p k : ℕ} [Fact (Nat.Prime p)], n = p ^ k → ∀ (a : ZMod n), (orderOf a).Coprime n → a = 1 ∨ IsUnit (a - 1) | null | true |
_private.Mathlib.Order.ModularLattice.0.Set.Iic.isCompl_inf_inf_of_isCompl_of_le._simp_1_1 | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | null | false |
NumberField.IsCMField.starRing._proof_2 | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (x x_1 : K),
(NumberField.IsCMField.complexConj K) (x + x_1) =
(NumberField.IsCMField.complexConj K) x + (NumberField.IsCMField.complexConj K) x_1 | null | false |
Lean.Elab.Term.TacticMVarKind.term.sizeOf_spec | Lean.Elab.Term.TermElabM | sizeOf Lean.Elab.Term.TacticMVarKind.term = 1 | null | true |
MeasurableSpace.DynkinSystem.ext | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_3} {d₁ d₂ : MeasurableSpace.DynkinSystem α}, (∀ (s : Set α), d₁.Has s ↔ d₂.Has s) → d₁ = d₂ | null | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.SmoothApprox.0.ContinuousMap.dense_setOf_contDiff._simp_1_2 | Mathlib.Analysis.Calculus.BumpFunction.SmoothApprox | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CategoryTheory.Abelian.PreservesCoimageImageComparison.iso_inv_left | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y)
... | null | true |
CategoryTheory.Idempotents.Karoubi.decompId_i_f | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.Idempotents.Karoubi C),
P.decompId_i.f = P.p | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.VertexCover.0.SimpleGraph.isVertexCover_empty._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u} {G : SimpleGraph V}, (G = ⊥) = ∀ (a b : V), ¬G.Adj a b | null | false |
_private.Mathlib.Analysis.Normed.Field.Dense.0.IsAlgClosed.of_denseRange._simp_1_3 | Mathlib.Analysis.Normed.Field.Dense | ∀ {α : Type u_1} {s : Finset α}, (¬s.Nonempty) = (s = ∅) | null | false |
CategoryTheory.Functor.WellOrderInductionData.Extension.limit._proof_3 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_2} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_1)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} [inst_3 : WellFoundedLT J] (j : J)
(hj : Order.IsSuccLimit j) (e : (i : J) → i < j → d.Extension val₀ i),
(CategoryTheory.C... | null | false |
CategoryTheory.ShortComplex.opcyclesMap'_neg | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
CategoryTheory.ShortComplex.opcyclesMap' (-φ) h₁ h₂ = -CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h... | null | true |
toModuleCatFromModuleCatLinearEquiv._proof_3 | Mathlib.RingTheory.Morita.Matrix | ∀ (R : Type u_3) {ι : Type u_1} [inst : Ring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
(M : ModuleCat (Matrix ι ι R)) (j : ι) (x x_1 : ↑M),
(fun i => ⟨Matrix.single j i 1 • (x + x_1), ⋯⟩) =
(fun i => ⟨Matrix.single j i 1 • x, ⋯⟩) + fun i => ⟨Matrix.single j i 1 • x_1, ⋯⟩ | null | false |
Mathlib.Tactic.Monoidal.Context | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | Type | The context for evaluating expressions. | true |
Partition.mk._flat_ctor | Mathlib.Order.Partition.Basic | {α : Type u_1} →
[inst : CompleteLattice α] → {s : α} → (parts : Set α) → sSupIndep parts → ⊥ ∉ parts → sSup parts = s → Partition s | null | false |
instCStarAlgebraSubtypeMemStarSubalgebraComplexElemental._proof_5 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : CStarAlgebra A], ContinuousStar A | null | false |
MvPolynomial.degrees_neg | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {R : Type u} {σ : Type u_1} [inst : CommRing R] (p : MvPolynomial σ R), (-p).degrees = p.degrees | null | true |
AddSubgroup.mem_normalizer_iff_addConj_image_eq | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {s : Set G} {g : G}, g ∈ AddSubgroup.normalizer s ↔ ⇑(AddAut.addConj g) '' s = s | null | true |
_private.Mathlib.Geometry.Manifold.SmoothEmbedding.0.Manifold.Diffeomorph.isSmoothEmbedding | Mathlib.Geometry.Manifold.SmoothEmbedding | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E₁ : Type u_2} →
[inst_1 : NormedAddCommGroup E₁] →
[inst_2 : NormedSpace 𝕜 E₁] →
{H : Type u_6} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E₁ H} →
{M : Type u_10} →
... | null | true |
Mathlib.Tactic.BicategoryLike.MkMor₂.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkMor₂ m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkMor₂ m) →
((ofExpr : Lean.Expr → m Mathlib.Tactic.BicategoryLike.Mor₂) → motive { ofExpr := ofExpr }) → motive t | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_5 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.ball 0 r) = (‖a‖ < r) | null | false |
ContinuousLinearMap.isometry_iff_adjoint_comp_self | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (u : H →L[𝕜] K), Isometry ⇑u ↔ ContinuousLinearMap.adjoint u ∘... | null | true |
CategoryTheory.RightRigidCategory.noConfusionType | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.RightRigidCategory C →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
[inst'_1 : CategoryTheory.MonoidalCategory C'] ... | null | false |
AlgebraicGeometry.SheafedSpace.mk.injEq | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (toPresheafedSpace : AlgebraicGeometry.PresheafedSpace C)
(IsSheaf : toPresheafedSpace.presheaf.IsSheaf) (toPresheafedSpace_1 : AlgebraicGeometry.PresheafedSpace C)
(IsSheaf_1 : toPresheafedSpace_1.presheaf.IsSheaf),
({ toPresheafedSpace := toPresheafedSpac... | null | true |
Nat.EqResult.false.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | ∀ (p p_1 : Lean.Expr), (Nat.EqResult.false p = Nat.EqResult.false p_1) = (p = p_1) | null | true |
ContDiffMapSupportedIn.fderivLM._proof_10 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) {E : Type u_3} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F], ContinuousConstSMul 𝕜 (E →L[ℝ] F) | null | false |
EStateM.Backtrackable.recOn | Init.Prelude | {δ σ : Type u} →
{motive : EStateM.Backtrackable δ σ → Sort u_1} →
(t : EStateM.Backtrackable δ σ) →
((save : σ → δ) → (restore : σ → δ → σ) → motive { save := save, restore := restore }) → motive t | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.induction_aux._simp_1_10 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {a : α} {b : β}, {a • b} = a • {b} | null | false |
CategoryTheory.Functor.OplaxMonoidal.whiskeringRight._proof_6 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_3} {D : Type u_4} {E : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} E]
[inst_3 : CategoryTheory.MonoidalCategory D] [inst_4 : CategoryTheory.MonoidalCategory E]
(L : CategoryTheory.Functor D E) [i... | null | false |
Std.Iter.allM_map | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β β' : Type w} {m : Type → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad m]
[inst_3 : Std.IteratorLoop α Id m] [LawfulMonad m] [Std.LawfulIteratorLoop α Id m] {it : Std.Iter β} {f : β → β'}
{p : β' → m Bool}, Std.Iter.allM p (Std.Iter.map f it) = Std.Iter.allM (fun x => p (f... | null | true |
OrderDual.instIsLeftCancelAdd | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Add α] [IsLeftCancelAdd α], IsLeftCancelAdd αᵒᵈ | null | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.mem_erase._simp_1_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, (a ∈ m) = (m.contains a = true) | null | false |
Int.add | Init.Data.Int.Basic | ℤ → ℤ → ℤ | Addition of integers, usually accessed via the `+` operator.
This function is overridden by the compiler with an efficient implementation. This definition is
the logical model.
Examples:
* `(7 : Int) + (6 : Int) = 13`
* `(6 : Int) + (-6 : Int) = 0`
| true |
CategoryTheory.GrothendieckTopology.Cover.instInhabited | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → {J : CategoryTheory.GrothendieckTopology C} → Inhabited (J.Cover X) | null | true |
PiTensorProduct.map._proof_1 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_2} {R : Type u_1} [inst : CommSemiring R] {t : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (t i)]
[inst_2 : (i : ι) → Module R (t i)], SMulCommClass R R (PiTensorProduct R fun i => t i) | null | false |
Std.Do.SPred.entails_3._simp_1 | Std.Do.SPred.DerivedLaws | ∀ {σ₁ σ₂ σ₃ : Type u_1} {P Q : Std.Do.SPred [σ₁, σ₂, σ₃]},
(P ⊢ₛ Q) = ∀ (s₁ : σ₁) (s₂ : σ₂) (s₃ : σ₃), (P s₁ s₂ s₃).down → (Q s₁ s₂ s₃).down | null | false |
Finset.trop_inf | Mathlib.Algebra.Tropical.BigOperators | ∀ {R : Type u_1} {S : Type u_2} [inst : LinearOrder R] [inst_1 : OrderTop R] (s : Finset S) (f : S → R),
Tropical.trop (s.inf f) = ∑ i ∈ s, Tropical.trop (f i) | null | true |
CategoryTheory.Limits.Bicone.IsBilimit.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {B : CategoryTheory.Limits.Bicone F}
[inst_2 : SizeOf J] [inst_3 : SizeOf C] (isLimit : CategoryTheory.Limits.IsLimit B.toCone)
(isColimit : CategoryTheory.Limits.IsColimit B.t... | null | true |
List.forall₂_reverse_iff | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β},
List.Forall₂ R l₁.reverse l₂.reverse ↔ List.Forall₂ R l₁ l₂ | null | true |
Lean.Elab.Tactic.TacticParsedSnapshot.below | Lean.Elab.Term.TermElabM | {motive_1 : Lean.Elab.Tactic.TacticParsedSnapshot → Sort u} →
{motive_2 : Option (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot) → Sort u} →
{motive_3 : Array (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot) → Sort u} →
{motive_4 : Lean.Language.SnapshotTask Lean.Elab.Ta... | null | false |
ProofWidgets.Html._sizeOf_inst | ProofWidgets.Data.Html | SizeOf ProofWidgets.Html | null | false |
ENat.iSup_add_iSup_of_monotone | Mathlib.Data.ENat.Lattice | ∀ {ι : Type u_4} [inst : Preorder ι] [IsDirectedOrder ι] {f g : ι → ℕ∞},
Monotone f → Monotone g → iSup f + iSup g = ⨆ a, f a + g a | null | true |
Aesop.Frontend.Parser.«feature(_)» | Aesop.Frontend.RuleExpr | Lean.ParserDescr | null | true |
CategoryTheory.EffectiveEpiStruct.noConfusionType | Mathlib.CategoryTheory.EffectiveEpi.Basic | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
{f : Y ⟶ X} →
CategoryTheory.EffectiveEpiStruct f →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
{X' Y' : C'} → {f' : Y' ⟶ X'} → CategoryTh... | null | false |
QuadraticAlgebra.instFinite | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} (a b : R) [inst : Semiring R], Module.Finite R (QuadraticAlgebra R a b) | null | true |
_private.Mathlib.Analysis.Complex.Conformal.0.isConformalMap_complex_linear._simp_1_4 | Mathlib.Analysis.Complex.Conformal | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
ULift.up_iSup | Mathlib.Order.CompleteLattice.Lemmas | ∀ {α : Type u_1} {ι : Sort u_4} [inst : SupSet α] (f : ι → α), { down := ⨆ i, f i } = ⨆ i, { down := f i } | null | true |
Std.ExtTreeSet.get!_min! | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α],
t ≠ ∅ → t.get! t.min! = t.min! | null | true |
Subgroup.subgroupOf_inj._simp_2 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {H₁ H₂ K : Subgroup G}, (H₁.subgroupOf K = H₂.subgroupOf K) = (H₁ ⊓ K = H₂ ⊓ K) | null | false |
LinearIsometry.coe_toSpanSingleton | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] {v : E} (hv : ‖v‖ = 1),
(LinearIsometry.toSpanSingleton 𝕜 E hv).toLinearMap = LinearMap.toSpanSingleton 𝕜 E v | null | true |
HasDerivWithinAt.mono | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s t : Set 𝕜},
HasDerivWithinAt f f' t x → s ⊆ t → HasDerivWithinAt f f' s x | null | true |
Polygon.mk.sizeOf_spec | Mathlib.Geometry.Polygon.Basic | ∀ {P : Type u_1} {n : ℕ} [inst : SizeOf P] (vertices : Fin n → P), sizeOf { vertices := vertices } = 1 | null | true |
MeasureTheory.tendsto_limUnder_of_hasDerivAt_of_integrableOn_Ioi | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {E : Type u_1} {f f' : ℝ → E} {a : ℝ} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E],
(∀ x ∈ Set.Ioi a, HasDerivAt f (f' x) x) →
MeasureTheory.IntegrableOn f' (Set.Ioi a) MeasureTheory.volume →
Filter.Tendsto f Filter.atTop (nhds (Filter.atTop.limUnder f)) | If the derivative of a function defined on the real line is integrable close to `+∞`, then
the function has a limit at `+∞`. | true |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.instNoMinOrderElemIoc.match_1 | Mathlib.Order.Interval.Set.Basic | ∀ (α : Type u_1) [inst : Preorder α] {x y : α} (motive : ↑(Set.Ioc x y) → Prop) (x_1 : ↑(Set.Ioc x y)),
(∀ (a : α) (ha : a ∈ Set.Ioc x y), motive ⟨a, ha⟩) → motive x_1 | null | false |
List.Perm.pairwise_iff | Init.Data.List.Perm | ∀ {α : Type u_1} {R : α → α → Prop},
(∀ {x y : α}, R x y → R y x) → ∀ {l₁ l₂ : List α}, l₁.Perm l₂ → (List.Pairwise R l₁ ↔ List.Pairwise R l₂) | null | true |
sigmaFinsuppEquivDFinsupp | Mathlib.Data.Finsupp.ToDFinsupp | {ι : Type u_1} → {η : ι → Type u_4} → {N : Type u_5} → [inst : Zero N] → ((i : ι) × η i →₀ N) ≃ Π₀ (i : ι), η i →₀ N | `Finsupp.split` is an equivalence between `(Σ i, η i) →₀ N` and `Π₀ i, (η i →₀ N)`. | true |
LinearPMap.ctorIdx | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
{inst : Ring R} →
{inst_1 : Ring S} →
{σ : R →+* S} →
{E : Type u_3} →
{inst_2 : AddCommGroup E} →
{inst_3 : Module R E} →
{F : Type u_4} → {inst_4 : AddCommGroup F} → {inst_5 : Module S F} → (E →ₛₗ.[σ] F) → ℕ | null | false |
Option.get_of_eq_some | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {a : α} {o : Option α} (h : o.isSome = true), o = some a → o.get h = a | null | true |
Set.Ioo.pos | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] (x : ↑(Set.Ioo 0 1)), 0 < ↑x | null | true |
Lean.Meta.Sym.Arith.State.rec | Lean.Meta.Sym.Arith.Types | {motive : Lean.Meta.Sym.Arith.State → Sort u} →
((exp : ℕ) →
(rings : Array Lean.Meta.Sym.Arith.CommRing) →
(semirings : Array Lean.Meta.Sym.Arith.CommSemiring) →
(ncRings : Array Lean.Meta.Sym.Arith.Ring) →
(ncSemirings : Array Lean.Meta.Sym.Arith.Semiring) →
(typeCl... | null | false |
IsFractionRing.algHom_commutes | Mathlib.RingTheory.Localization.FractionRing | ∀ {A : Type u_4} [inst : CommRing A] {B : Type u_6} [inst_1 : CommRing B] [inst_2 : Algebra A B] {K₁ : Type u_8}
{K₂ : Type u_9} [inst_3 : Field K₁] [inst_4 : Field K₂] [inst_5 : Algebra A K₁] [inst_6 : Algebra A K₂]
[IsFractionRing A K₁] {L₁ : Type u_10} {L₂ : Type u_11} [inst_8 : Field L₁] [inst_9 : Field L₂]
[... | null | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.M2.branch | Lean.Meta.Tactic.FunInd | {α : Type} → Lean.Tactic.FunInd.M2✝ α → Lean.Tactic.FunInd.M2✝ α | null | true |
OrderIso.smulRight_symm_apply | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : GroupWithZero α] [inst_1 : Preorder α] [inst_2 : Preorder β]
[inst_3 : MulAction α β] [inst_4 : PosSMulMono α β] [inst_5 : PosSMulReflectLE α β] {a : α} (ha : 0 < a) (b : β),
(RelIso.symm (OrderIso.smulRight ha)) b = a⁻¹ • b | null | true |
_private.Mathlib.RingTheory.Ideal.GoingUp.0.Ideal.isMaximal_of_isIntegral_of_isMaximal_comap.match_1_1 | Mathlib.RingTheory.Ideal.GoingUp | ∀ {S : Type u_1} [inst : CommRing S] (I x : Ideal S) (motive : (I ≤ x ∧ ∃ x_1 ∈ x, x_1 ∉ I) → Prop)
(x_1 : I ≤ x ∧ ∃ x_1 ∈ x, x_1 ∉ I),
(∀ (I_le_J : I ≤ x) (x_2 : S) (hxJ : x_2 ∈ x) (hxI : x_2 ∉ I), motive ⋯) → motive x_1 | null | false |
LinearEquiv.multilinearMapCongrLeft._proof_3 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
MultilinearMap.freeFinsuppEquiv._proof_7 | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {ι' : Type u_1} {R : Type u_2} [inst : CommSemiring R], LinearMap.CompatibleSMul (Π₀ (x : ι'), R) (ι' →₀ R) R R | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal.0.Polynomial.Chebyshev.negOnePow_mul_negOnePow_mul_cancel | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ {α β : ℝ} {i : ℕ}, (-1) ^ i * α * ((-1) ^ i * β) = α * β | null | true |
Lean.Elab.Term.mkNoImplicitLambdaAnnotation | Lean.Elab.Term.TermElabM | Lean.Expr → Lean.Expr | null | true |
MeasureTheory.piContent_eq_measure_pi | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {mX : (i : ι) → MeasurableSpace (X i)} (μ : (i : ι) → MeasureTheory.Measure (X i))
[hμ : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)] [inst : Fintype ι] {s : Set ((i : ι) → X i)},
MeasurableSet s → (MeasureTheory.piContent μ) s = (MeasureTheory.Measure.pi μ) s | null | true |
ProofWidgets.Penrose.DiagramState._sizeOf_inst | ProofWidgets.Component.PenroseDiagram | SizeOf ProofWidgets.Penrose.DiagramState | null | false |
Matrix.transpose_eq_natCast | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : AddMonoidWithOne α] {M : Matrix n n α} {d : ℕ},
M.transpose = ↑d ↔ M = ↑d | null | true |
Lean.Elab.Do.ContInfo.toContInfoRef | Lean.Elab.Do.Basic | Lean.Elab.Do.ContInfo → Lean.Elab.Do.ContInfoRef | null | true |
left_neg_eq_right_neg | Mathlib.Algebra.Group.Defs | ∀ {M : Type u_2} [inst : AddMonoid M] {a b c : M}, b + a = 0 → a + c = 0 → b = c | null | true |
Mathlib.Tactic.Ring.of_eq | Mathlib.Tactic.Ring.Basic | ∀ {α : Sort u_2} {a b c : α}, a = c → b = c → a = b | null | true |
Batteries.UnionFind.recOn | Batteries.Data.UnionFind.Basic | {motive : Batteries.UnionFind → Sort u} →
(t : Batteries.UnionFind) →
((arr : Array Batteries.UFNode) →
(parentD_lt : ∀ {i : ℕ}, i < arr.size → Batteries.UnionFind.parentD arr i < arr.size) →
(rankD_lt :
∀ {i : ℕ},
Batteries.UnionFind.parentD arr i ≠ i →
... | null | false |
derivationOfSectionOfKerSqZero_apply_coe | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra R S] (f : P →ₐ[R] S) (hf' : RingHom.ker f ^ 2 = ⊥) (g : S →ₐ[R] P)
(hg : f.comp g = AlgHom.id R S) (x : P), ↑((derivationOfSectionOfKerSqZero f hf' g hg) x) = x - g... | null | true |
Finset.coe_zero | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Zero α], ↑0 = 0 | null | true |
«term_≃⋆+*_» | Mathlib.Algebra.Star.StarRingHom | Lean.TrailingParserDescr | A *⋆-ring* equivalence is an equivalence preserving addition, multiplication, and the star
operation, which allows for considering both unital and non-unital equivalences with a single
structure. | true |
_private.Mathlib.Tactic.SimpRw.0.Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1.match_1 | Mathlib.Tactic.SimpRw | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) → ((x : Lean.Syntax) → motive (some x)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.RingTheory.Smooth.IntegralClosure.0.exists_derivative_mul_eq_and_isIntegral_coeff._simp_1_8 | Mathlib.RingTheory.Smooth.IntegralClosure | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.