name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Real.sin_arctan_lt_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, Real.sin (Real.arctan x) < 0 ↔ x < 0 | null | true |
ModuleCon.instAddCommMagmaQuotient | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} →
(M : Type u_3) →
[inst : SMul S M] → [inst_1 : AddCommMagma M] → (c : ModuleCon S M) → AddCommMagma (ModuleCon.Quotient M c) | null | true |
_private.Lean.Server.CodeActions.Attr.0.Lean.CodeAction.mkHoleCodeAction.unsafe_impl_2 | Lean.Server.CodeActions.Attr | Lean.Name → Lean.Environment → Lean.Options → ExceptT String Id Lean.CodeAction.HoleCodeAction | null | true |
SSet.N.eq_iff | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} {x y : X.N}, x = y ↔ x.subcomplex = y.subcomplex | null | true |
Aesop.NormalizationState.isNormal | Aesop.Tree.Data | Aesop.NormalizationState → Bool | null | true |
List.diff.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : List α → List α → Sort u_2) →
(x x_1 : List α) →
((l : List α) → motive l []) → ((l₁ : List α) → (a : α) → (l₂ : List α) → motive l₁ (a :: l₂)) → motive x x_1 | null | false |
_private.Lean.Meta.Sym.SymM.0.Lean.Meta.Sym.SymExtension.mk.inj | Lean.Meta.Sym.SymM | ∀ {σ : Type} {id : ℕ} {mkInitial : IO σ} {id_1 : ℕ} {mkInitial_1 : IO σ},
{ id := id, mkInitial := mkInitial } = { id := id_1, mkInitial := mkInitial_1 } → id = id_1 ∧ mkInitial = mkInitial_1 | null | true |
String.Slice.posGT_le_iff | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : String.Pos.Raw} {h : p < s.rawEndPos} {q : s.Pos}, s.posGT p h ≤ q ↔ p < q.offset | null | true |
UniformSpace.replaceTopology_eq | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_2} [i : TopologicalSpace α] (u : UniformSpace α) (h : i = u.toTopologicalSpace), u.replaceTopology h = u | null | true |
Equiv.Perm.cycleOf_apply_apply_self | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} (f : Equiv.Perm α) [inst : DecidableRel f.SameCycle] (x : α), (f.cycleOf x) (f x) = f (f x) | null | true |
Zero.ctorIdx | Init.Prelude | {α : Type u} → Zero α → ℕ | null | false |
Matrix.toLpLinAlgEquiv_symm_apply | Mathlib.Analysis.Normed.Lp.Matrix | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R] (p : ENNReal)
(a : Module.End R (WithLp p (n → R))), (Matrix.toLpLinAlgEquiv p).symm a = (Matrix.toLpLin p p).symm a | null | true |
Cardinal.lt_one_iff | Mathlib.SetTheory.Cardinal.Basic | ∀ {c : Cardinal.{u_1}}, c < 1 ↔ c = 0 | null | true |
instContinuousMulULift | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M], ContinuousMul (ULift.{u, u_3} M) | null | true |
Lean.Elab.TerminationBy.synthetic | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.TerminationBy → Bool | If `synthetic := true`, then this `termination_by` clause was
generated by `GuessLex`, and `vars` refers to *all* parameters
of the function, not just the “extra parameters”.
Cf. Lean.Elab.WF.unpackUnary
| true |
SetLike.GradeZero.instMonoid._aux_4 | Mathlib.Algebra.GradedMonoid | {ι : Type u_3} →
{R : Type u_1} →
{S : Type u_2} →
[inst : SetLike S R] →
[inst_1 : Monoid R] → [inst_2 : AddMonoid ι] → {A : ι → S} → [SetLike.GradedMonoid A] → ↥(A 0) | null | false |
WithZero.mapAddHom_injective | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} [inst : Add α] [inst_1 : Add β] {f : α →ₙ+ β},
Function.Injective ⇑f → Function.Injective ⇑(WithZero.mapAddHom f) | null | true |
_private.Mathlib.Data.Nat.Fib.Zeckendorf.0.Nat.zeckendorf_sum_fib._simp_1_15 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
BoundedContinuousFunction.coe_nsmulRec._f | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : AddMonoid β]
[inst_3 : BoundedAdd β] [inst_4 : ContinuousAdd β] (f : BoundedContinuousFunction α β) (x : ℕ) (f_1 : Nat.below x),
⇑(nsmulRec x f) = x • ⇑f | null | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedActionActionOfMonoidalFunctorToEndofunctorMopIso | Mathlib.CategoryTheory.Monoidal.Action.End | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)ᴹᵒᵖ) →
[inst_3 : F.Monoidal] → CategoryTh... | If the (left) action of `C` on `D` comes from a monoidal functor
`C ⥤ (D ⥤ D)ᴹᵒᵖ`, then `curriedActionMop C D` is naturally isomorphic to that
functor. | true |
Mathlib.Tactic.BicategoryLike.Mor₂.comp.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ (e : Lean.Expr) (isoLift? : Option Mathlib.Tactic.BicategoryLike.IsoLift) (f g h : Mathlib.Tactic.BicategoryLike.Mor₁)
(η θ : Mathlib.Tactic.BicategoryLike.Mor₂),
sizeOf (Mathlib.Tactic.BicategoryLike.Mor₂.comp e isoLift? f g h η θ) =
1 + sizeOf e + sizeOf isoLift? + sizeOf f + sizeOf g + sizeOf h + sizeOf η ... | null | true |
_private.Lean.Meta.Sym.InstantiateS.0.Lean.Meta.Sym.instantiateRevRangeS._proof_1 | Lean.Meta.Sym.InstantiateS | ∀ (beginIdx endIdx : ℕ) (subst : Array Lean.Expr),
¬beginIdx > endIdx →
¬endIdx > subst.size →
∀ (offset idx : ℕ),
idx ≥ beginIdx + offset →
idx < offset + (endIdx - beginIdx) → endIdx - beginIdx - (idx - offset) - 1 < subst.size | null | false |
Manifold.«_aux_Mathlib_Geometry_Manifold_ContMDiffMap___macroRules_Manifold_termC^_⟮_,_;_⟯_1» | Mathlib.Geometry.Manifold.ContMDiffMap | Lean.Macro | null | false |
GradedMonoid.GSMul.rec | Mathlib.Algebra.GradedMulAction | {ιA : Type u_1} →
{ιM : Type u_3} →
{A : ιA → Type u_4} →
{M : ιM → Type u_5} →
[inst : VAdd ιA ιM] →
{motive : GradedMonoid.GSMul A M → Sort u} →
((smul : {i : ιA} → {j : ιM} → A i → M j → M (i +ᵥ j)) → motive { smul := smul }) →
(t : GradedMonoid.GSMul A M) → mo... | null | false |
NormedRing.inverse_add_norm | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R] (x : Rˣ),
(fun t => Ring.inverse (↑x + t)) =O[nhds 0] fun _t => 1 | The function `fun t ↦ inverse (x + t)` is O(1) as `t → 0`. | true |
Std.Time.TimeZone.TZif.TZifV2._sizeOf_inst | Std.Time.Zoned.Database.TzIf | SizeOf Std.Time.TimeZone.TZif.TZifV2 | null | false |
PresheafOfModules.evaluationJointlyReflectsLimits | Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
{J : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] →
(F : CategoryTheory.Functor J (PresheafOfModules R)) →
[∀ (X : Cᵒᵖ),
Small.{v, max u₂ v}
... | A cone in the category `PresheafOfModules R` is limit if it is so after the application
of the functors `evaluation R X` for all `X`. | true |
nonempty_subtype | Mathlib.Logic.Nonempty | ∀ {α : Sort u_3} {p : α → Prop}, Nonempty (Subtype p) ↔ ∃ a, p a | null | true |
CategoryTheory.Over.pullback.congr_simp | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f f_1 : X ⟶ Y) (e_f : f = f_1)
[inst_1 : CategoryTheory.Limits.HasPullbacksAlong f],
CategoryTheory.Over.pullback f = CategoryTheory.Over.pullback f_1 | null | true |
SSet.stdSimplex.instFunLikeObjOppositeSimplexCategoryMkOpFinHAddNatOfNat | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | (n i : ℕ) → FunLike ((SSet.stdSimplex.obj { len := n }).obj (Opposite.op { len := i })) (Fin (i + 1)) (Fin (n + 1)) | If `x : Δ[n] _⦋d⦌` and `i : Fin (d + 1)`, we may evaluate `x i : Fin (n + 1)`. | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.localization_away_comap_range._simp_1_3 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | null | false |
Submodule.equivMapOfInjective._proof_4 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_1} {M₂ : Type u_2} [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₂}
(f : M →ₛₗ[σ₁₂] M₂) (i : Function.Injective ⇑f) (p : Submodule R M),
Function.RightInvers... | null | false |
Mathlib.PrintSorries.State.mk.inj | Mathlib.Util.PrintSorries | ∀ {visited : Lean.NameSet} {sorries : Std.HashSet Lean.Expr} {sorryMsgs : Array Lean.MessageData}
{visited_1 : Lean.NameSet} {sorries_1 : Std.HashSet Lean.Expr} {sorryMsgs_1 : Array Lean.MessageData},
{ visited := visited, sorries := sorries, sorryMsgs := sorryMsgs } =
{ visited := visited_1, sorries := sorri... | null | true |
NonUnitalStarSubalgebra.toNonUnitalSubring_injective | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A] [inst_3 : Star A],
Function.Injective NonUnitalStarSubalgebra.toNonUnitalSubring | null | true |
Lean.ErrorExplanation.Metadata.removedVersion? | Lean.ErrorExplanation | Lean.ErrorExplanation.Metadata → Option String | null | true |
NumberField.nrRealPlaces_eq_zero_iff | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ {K : Type u_2} [inst : Field K] [inst_1 : NumberField K],
NumberField.InfinitePlace.nrRealPlaces K = 0 ↔ NumberField.IsTotallyComplex K | null | true |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go.eq_2 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (le : α → α → Bool) (a a_1 : List α),
(a = [] → False) → List.MergeSort.Internal.mergeTR.go✝ le a [] a_1 = a_1.reverseAux a | null | true |
HasCompactMulSupport.comp_homeomorph | Mathlib.Topology.Algebra.Support | ∀ {X : Type u_9} {Y : Type u_10} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {M : Type u_11}
[inst_2 : One M] {f : Y → M}, HasCompactMulSupport f → ∀ (φ : X ≃ₜ Y), HasCompactMulSupport (f ∘ ⇑φ) | null | true |
CategoryTheory.ObjectProperty.nonempty_sup_left | Mathlib.CategoryTheory.ObjectProperty.CompleteLattice | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P Q : CategoryTheory.ObjectProperty C) [P.Nonempty],
(P ⊔ Q).Nonempty | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabPanic._regBuiltin.Lean.Elab.Term.elabPanic_1 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
CategoryTheory.Limits.MultispanShape._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | CategoryTheory.Limits.MultispanShape → ℕ | null | false |
CategoryTheory.sheafificationNatIso | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type u_1) →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[inst_2 : CategoryTheory.HasWeakSheafify J D] →
CategoryTheory.Functor.id (CategoryTheory.Sheaf J D) ≅
... | The natural isomorphism `𝟭 (Sheaf J D) ≅ sheafToPresheaf J D ⋙ presheafToSheaf J D`. | true |
differentiableOn_intCast | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {s : Set E} [inst_7 : IntCast F] (z : ℤ), DifferentiableOn 𝕜 (↑z) s | null | true |
RelIso.sumLexComplRight_symm_apply | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {x : α} [inst : IsTrans α r] [inst_1 : Std.Trichotomous r] [inst_2 : DecidableRel r]
(a : { x_1 // ¬r x x_1 } ⊕ Subtype (r x)), (RelIso.sumLexComplRight r x) a = (Equiv.sumCompl (r x)) a.swap | null | true |
CategoryTheory.instIsAddModHomNegOfHom | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {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.MonoidalLeftAction C D]
(A : C) [inst_4 : CategoryTheory.AddMonObj A] {M N : D} [inst_5 : CategoryTheory.AddM... | null | true |
CategoryTheory.ShortComplex.RightHomologyMapData.comp_φQ | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {φ' : S₂ ⟶ S₃} {h₁ : S₁.RightHomologyData}
{h₂ : S₂.RightHomologyData} {h₃ : S₃.RightHomologyData} (ψ : CategoryTheory.ShortComplex.RightHomolog... | null | true |
WithSeminorms.hasBasis_ball | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {p : SeminormFamily 𝕜 E ι},
WithSeminorms p → ∀ {x : E}, (nhds x).HasBasis (fun sr => 0 < sr.2) fun sr => (sr.1.sup p).ball x sr.2 | null | true |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.ctorElim | Std.Tactic.BVDecide.LRAT.Internal.Assignment | {motive : Std.Tactic.BVDecide.LRAT.Internal.Assignment → Sort u} →
(ctorIdx : ℕ) →
(t : Std.Tactic.BVDecide.LRAT.Internal.Assignment) →
ctorIdx = t.ctorIdx → Std.Tactic.BVDecide.LRAT.Internal.Assignment.ctorElimType ctorIdx → motive t | null | false |
String.valid_toSubstring | Batteries.Data.String.Lemmas | ∀ (s : String), s.toRawSubstring.Valid | null | true |
OrderIso.setIsotypicComponents_apply | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsSemisimpleModule R M] (s : Set ↑(isotypicComponents R M)),
OrderIso.setIsotypicComponents s = ⨆ c ∈ s, ⟨↑c, ⋯⟩ | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.addAuxRecs.match_1 | Lean.Elab.MutualInductive | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((const : Lean.ConstantInfo) → motive (some const)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.getParamInfo | Lean.Elab.App | Lean.Elab.Term.ElabAppArgs.M Lean.BinderInfo | Returns the current parameter's binder info.
Only valid if `fTypeIsForall` has returned `true`.
| true |
List.sortedLE_ofFn_iff | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} {f : Fin n → α}, (List.ofFn f).SortedLE ↔ Monotone f | The list `List.ofFn f` is sorted with respect to `(· ≤ ·)` if and only if `f` is monotone. | true |
Rel.edgeDensity.congr_simp | Mathlib.Combinatorics.SimpleGraph.Density | ∀ {α : Type u_4} {β : Type u_5} (r r_1 : α → β → Prop),
r = r_1 →
∀ {inst : (a : α) → DecidablePred (r a)} [inst_1 : (a : α) → DecidablePred (r_1 a)] (s s_1 : Finset α),
s = s_1 → ∀ (t t_1 : Finset β), t = t_1 → Rel.edgeDensity r s t = Rel.edgeDensity r_1 s_1 t_1 | null | true |
CategoryTheory.CostructuredArrow.toOverCompYoneda._proof_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
(T : CategoryTheory.Over A) {X Y : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.CostructuredArrow.toOver CategoryTheory.... | null | false |
Lean.IR.LogEntry | Lean.Compiler.IR.CompilerM | Type | null | true |
PSigma.Lex.recOn | Init.WF | ∀ {α : Sort u} {β : α → Sort v} {r : α → α → Prop} {s : (a : α) → β a → β a → Prop}
{motive : (a a_1 : PSigma β) → PSigma.Lex r s a a_1 → Prop} {a a_1 : PSigma β} (t : PSigma.Lex r s a a_1),
(∀ {a₁ : α} (b₁ : β a₁) {a₂ : α} (b₂ : β a₂) (a : r a₁ a₂), motive ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⋯) →
(∀ (a : α) {b₁ b₂ : β a} (a_2 :... | null | false |
finsum_eq_if | Mathlib.Algebra.BigOperators.Finprod | ∀ {M : Type u_2} [inst : AddCommMonoid M] {p : Prop} [inst_1 : Decidable p] {x : M}, ∑ᶠ (_ : p), x = if p then x else 0 | null | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.instBEqPoly.beq.match_1.splitter | Init.Grind.Ring.CommSolver | (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) →
(x x_1 : Lean.Grind.CommRing.Poly) →
((a b : ℤ) → motive (Lean.Grind.CommRing.Poly.num a) (Lean.Grind.CommRing.Poly.num b)) →
((a : ℤ) →
(a_1 : Lean.Grind.CommRing.Mon) →
(a_2 : Lean.Grind.CommRing.Poly) →
... | null | true |
_private.Lean.Meta.Tactic.Grind.Attr.0.Lean.Meta.Grind.Extension.addFunCCAttr | Lean.Meta.Tactic.Grind.Attr | Lean.Meta.Grind.Extension → Lean.Name → Lean.AttributeKind → Lean.CoreM Unit | null | true |
exists_or_eq_imp | Init.PropLemmas | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, (q a ∨ a = a') ∧ p a) ↔ (∃ a, q a ∧ p a) ∨ p a' | null | true |
_private.Mathlib.Tactic.Linter.MinImports.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.MinImports.2382540021._hygCtx._hyg.2 | Mathlib.Tactic.Linter.MinImports | IO (IO.Ref Mathlib.Linter.ImportState✝) | null | false |
Nat.recDiagAux_succ_succ | Batteries.Data.Nat.Lemmas | ∀ {motive : ℕ → ℕ → Sort u_1} (zero_left : (n : ℕ) → motive 0 n) (zero_right : (m : ℕ) → motive m 0)
(succ_succ : (m n : ℕ) → motive m n → motive (m + 1) (n + 1)) (m n : ℕ),
Nat.recDiagAux zero_left zero_right succ_succ (m + 1) (n + 1) =
succ_succ m n (Nat.recDiagAux zero_left zero_right succ_succ m n) | null | true |
CategoryTheory.Equivalence.changeFunctor._proof_2 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (e : C ≌ D) {G : CategoryTheory.Functor C D} (iso : e.functor ≅ G)
(X : C),
CategoryTheory.CategoryStruct.comp
(G.map ((e.unitIso ≪≫ CategoryTheory.Functor.isoWhiskerRight iso e.inve... | null | false |
CategoryTheory.PreZeroHypercover.hom_inv_h₀._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S}
(e : E ≅ F) (i : E.I₀), E.X i = E.X (e.inv.s₀ (e.hom.s₀ i)) | null | false |
Differentiable.continuous | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} [ContinuousAdd E] [ContinuousSMul 𝕜 E] [ContinuousAdd F]
[C... | null | true |
Int64.sub_mul | Init.Data.SInt.Lemmas | ∀ {a b c : Int64}, (a - b) * c = a * c - b * c | null | true |
OrderHom.gfp_le | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, (∀ b ≤ f b, b ≤ a) → OrderHom.gfp f ≤ a | null | true |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic.0.Algebra.finite_iff_isIntegral_and_finiteType.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(motive : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A → Prop)
(x : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A),
(∀ (h : Algebra.IsIntegral R A) (right : Algebra.FiniteType R A), motive ⋯) → motive x | null | false |
_private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field._proof_11 | Mathlib.RingTheory.LittleWedderburn | ∀ {D : Type u_1} [inst : DivisionRing D] {R : Subring D} [inst_1 : Fintype D] [inst_2 : DecidableEq D]
[inst_3 : DecidablePred fun x => x ∈ R] (q : ℚ≥0) (a : ↥R), DivisionRing.nnqsmul q a = ↑q * a | null | false |
_private.Mathlib.Topology.QuasiSeparated.0.QuasiSeparatedSpace.isCompact_sInter_of_nonempty._proof_1_8 | Mathlib.Topology.QuasiSeparated | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set (Set α)},
(∀ t ∈ s, IsCompact t) → ∀ t_1 ∈ {t | t ∈ s ∧ IsOpen t}, IsCompact t_1 | null | false |
Lean.Compiler.LCNF.instInhabitedLetDecl | Lean.Compiler.LCNF.Basic | {a : Lean.Compiler.LCNF.Purity} → Inhabited (Lean.Compiler.LCNF.LetDecl a) | null | true |
_private.Mathlib.CategoryTheory.Limits.Opposites.0.CategoryTheory.Limits.limitOpIsoOpColimit_hom_comp_ι._simp_1_1 | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.hom g = f) = (g = CategoryTheory.CategoryStruct.comp α.inv f) | null | false |
LipschitzWith.compLp | Mathlib.MeasureTheory.Function.LpSpace.Basic | {α : Type u_1} →
{E : Type u_4} →
{F : Type u_5} →
{m : MeasurableSpace α} →
{p : ENNReal} →
{μ : MeasureTheory.Measure α} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup F] →
{g : E → F} →
{c : NNReal} → LipschitzW... | When `g` is a Lipschitz function sending `0` to `0` and `f` is in `Lp`, then `g ∘ f` is well
defined as an element of `Lp`. | true |
FormalMultilinearSeries.leftInv._proof_30 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], SMulCommClass 𝕜 𝕜 E | null | false |
Lean.Parser.Tactic.mcasesPatAlts | Std.Tactic.Do.Syntax | Lean.ParserDescr | null | true |
Nucleus.mem_toSublocale | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {n : Nucleus X} {x : X}, x ∈ n.toSublocale ↔ ∃ y, n y = x | null | true |
_private.Init.Data.Array.Lemmas.0.Array.range.eq_1 | Init.Data.Array.Lemmas | ∀ (n : ℕ), Array.range n = Array.ofFn fun i => ↑i | null | true |
CategoryTheory.LaxFunctor.mk.noConfusion | Mathlib.CategoryTheory.Bicategory.Functor.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{P : Sort u} →
{toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C} →
{mapId :
(a : B) →
CategoryTheory.CategoryStruct.id (toPrelaxF... | null | false |
ULift.div | Mathlib.Algebra.Group.ULift | {α : Type u} → [Div α] → Div (ULift.{u_1, u} α) | null | true |
List.merge_of_le | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool} {xs ys : List α},
(∀ (a b : α), a ∈ xs → b ∈ ys → le a b = true) → xs.merge ys le = xs ++ ys | null | true |
Std.TreeMap.Raw.Equiv.getEntryLT?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {k : α},
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getEntryLT? k = t₂.getEntryLT? k | null | true |
LinearIsometryEquiv.symm_conjStarAlgEquiv | 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] (e : H ≃ₗᵢ[𝕜] K), e.conjStarAlgEquiv.symm = e.symm.conjStarAlg... | null | true |
CategoryTheory.Functor.prod._proof_2 | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{u_7, u_1} A] {B : Type u_5}
[inst_1 : CategoryTheory.Category.{u_3, u_5} B] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_8, u_2} C]
{D : Type u_6} [inst_3 : CategoryTheory.Category.{u_4, u_6} D] (F : CategoryTheory.Functor A B)
(G : CategoryTheory.Functor C... | null | false |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map₂_comp | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
self.map₂ (CategoryTheory.CategoryStruct.comp η θ) = CategoryTheory.CategoryStruct.comp (self.map₂ η)... | null | true |
Lean.Parser.Tactic.quot | Lean.Parser.Term | Lean.Parser.Parser | null | true |
MeasureTheory.lintegral_lintegral_symm | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] ⦃f : α → β → ENNReal⦄,
AEMeasurable (Function.uncurry f) (μ.prod ν) →
∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (... | The reversed version of **Tonelli's Theorem** (symmetric version). In this version `f` is in
curried form, which makes it easier for the elaborator to figure out `f` automatically. | true |
String.toInt?_toSlice | Std.Data.String.ToInt | ∀ {s : String}, s.toSlice.toInt? = s.toInt? | null | true |
CompactlySupportedContinuousMap._sizeOf_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_5} →
{β : Type u_6} →
{inst : TopologicalSpace α} →
{inst_1 : Zero β} →
{inst_2 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → CompactlySupportedContinuousMap α β → ℕ | null | false |
Mathlib.Tactic.BicategoryCoherence.LiftHom.recOn | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{motive : Mathlib.Tactic.BicategoryCoherence.LiftHom f → Sort u_1} →
(t : Mathlib.Tactic.BicategoryCoherence.LiftHom f) →
((lift : CategoryTheory.FreeBicategory.of.obj a ⟶ CategoryTheory.FreeBicateg... | null | false |
ContinuousMultilinearMap.currySumEquiv._proof_10 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G' : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G']
[inst_2 : NormedSpace 𝕜 G'], SMulCommClass 𝕜 𝕜 G' | null | false |
StarMemClass.rec | Mathlib.Algebra.Star.Basic | {S : Type u_1} →
{R : Type u_2} →
[inst : Star R] →
[inst_1 : SetLike S R] →
{motive : StarMemClass S R → Sort u} →
((star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s) → motive ⋯) → (t : StarMemClass S R) → motive t | null | false |
Std.IterM.stepSize | Std.Data.Iterators.Combinators.Monadic.StepSize | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] → [Std.IteratorAccess α m] → [Monad m] → Std.IterM m β → ℕ → Std.IterM m β | Produces an iterator that emits one value of `it`, then drops `n - 1` elements, then emits another
value, and so on. In other words, it emits every `n`-th value of `it`, starting with the first one.
If `n = 0`, the iterator behaves like for `n = 1`: It emits all values of `it`.
**Marble diagram:**
```
it ... | true |
Std.TreeSet.Raw.toList_roc | Std.Data.TreeSet.Raw.Slice | ∀ {α : Type u} (cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw.toList_roc._auto_1) [Std.TransCmp cmp]
{t : Std.TreeSet.Raw α cmp},
t.WF →
∀ {lowerBound upperBound : α},
Std.Slice.toList (Std.Roc.Sliceable.mkSlice t lowerBound<...=upperBound) =
List.filter (fun e => decide ((cmp e lowerBound).i... | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._proof_1_6 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (y : BitVec w), ¬2 ^ w - 1 - y.toNat < 2 ^ w → False | null | false |
contMDiffOn_zero_iff | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : 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 : NormedAddComm... | zero-smoothness on a set is equivalent to continuity on this set. | true |
LibraryNote.foundational_algebra_order_theory | Mathlib.Data.Nat.Init | Batteries.Util.LibraryNote | Batteries has a home-baked development of the algebraic and order-theoretic theory of `ℕ` and `ℤ`
which, in particular, is not typeclass-mediated. This is useful to set up the algebra and finiteness
libraries in mathlib (naturals and integers show up as indices/offsets in lists, cardinality in
finsets, powers in groups... | true |
Fintype | Mathlib.Data.Fintype.Defs | Type u_4 → Type u_4 | `Fintype α` means that `α` is finite, i.e. there are only
finitely many distinct elements of type `α`. The evidence of this
is a finset `elems` (a list up to permutation without duplicates),
together with a proof that everything of type `α` is in the list. | true |
ContMDiffVAdd.mk._flat_ctor | Mathlib.Geometry.Manifold.Algebra.SMul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {H' : Type u_4}
[inst_4 : TopologicalSpace H'] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : Normed... | null | false |
Subalgebra.val._proof_5 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (x : R), ↑((algebraMap R ↥S) x) = ↑((algebraMap R ↥S) x) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.