name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Elab.DocString.0.Lean.Doc.findShadowedNames.match_3 | Lean.Elab.DocString | {α : Type} →
(motive : Lean.Name × α → Sort u_1) →
(x : Lean.Name × α) → ((fullName : Lean.Name) → (snd : α) → motive (fullName, snd)) → motive x | false |
FiberPrebundle.pretrivializationAt | Mathlib.Topology.FiberBundle.Basic | {B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_5} →
[inst : TopologicalSpace B] →
[inst_1 : TopologicalSpace F] →
[inst_2 : (x : B) → TopologicalSpace (E x)] →
FiberPrebundle F E → B → Bundle.Pretrivialization F Bundle.TotalSpace.proj | true |
Aesop.ExtResult._sizeOf_1 | Aesop.Util.Tactic.Ext | Aesop.ExtResult → ℕ | false |
CategoryTheory.regularTopology.EqualizerCondition.bijective_mapToEqualizer_pullback | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.Functor Cᵒᵖ (Type u_4)},
CategoryTheory.regularTopology.EqualizerCondition P →
∀ {X B : C} (π : X ⟶ B) [CategoryTheory.EffectiveEpi π] [inst_2 : CategoryTheory.Limits.HasPullback π π],
Function.Bijective
(CategoryTheo... | true |
UInt64.toUInt16_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a.toUInt16 < b.toUInt16 ↔ a % 65536 < b % 65536 | true |
Nonneg.conditionallyCompleteLinearOrder._proof_10 | Mathlib.Algebra.Order.Nonneg.Lattice | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {a : α} (this : Inhabited ↑(Set.Ici a)),
autoParam (∀ (a_1 b : { x // a ≤ x }), compare a_1 b = compareOfLessAndEq a_1 b)
ConditionallyCompleteLinearOrder.compare_eq_compareOfLessAndEq._autoParam | false |
collinear_empty | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ (k : Type u_1) {V : Type u_2} (P : Type u_3) [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P], Collinear k ∅ | true |
Lean.Lsp.ReferenceParams.context | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceParams → Lean.Lsp.ReferenceContext | true |
CategoryTheory.Abelian.extFunctor_obj | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (n : ℕ) (X : Cᵒᵖ),
(CategoryTheory.Abelian.extFunctor n).obj X = CategoryTheory.Abelian.extFunctorObj (Opposite.unop X) n | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.quasiIso_truncGEMap_iff._proof_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (n : ℤ) (i : ℕ), n ≤ n + ↑i | false |
MeasurableSpace.measurableSet_empty | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_7} (self : MeasurableSpace α), MeasurableSpace.MeasurableSet' self ∅ | true |
ContinuousMultilinearMap.ratio_le_opNorm | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(f : ContinuousMultilinearMap 𝕜 E G) (m... | true |
Lean.Meta.Match.Example.val.noConfusion | Lean.Meta.Match.Basic | {P : Sort u} → {a a' : Lean.Expr} → Lean.Meta.Match.Example.val a = Lean.Meta.Match.Example.val a' → (a = a' → P) → P | false |
Mathlib.Tactic.BicategoryLike.MkEqOfNaturality.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m) →
((mkEqOfNaturality :
Lean.Expr →
Lean.Expr →
Mathlib.Tactic.BicategoryLike.IsoLift →
Mathlib.Tactic.... | false |
Batteries.PairingHeapImp.Heap.NodeWF._sunfold | Batteries.Data.PairingHeap | {α : Type u_1} → (α → α → Bool) → α → Batteries.PairingHeapImp.Heap α → Prop | false |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems | Lean.Elab.Tactic.Do.Attr | Type | true |
Aesop.SimpResult.simplified | Aesop.Search.Expansion.Simp | Lean.MVarId → Lean.Meta.Simp.UsedSimps → Aesop.SimpResult | true |
Real.sInf_nonpos | Mathlib.Data.Real.Archimedean | ∀ {s : Set ℝ}, (∀ x ∈ s, x ≤ 0) → sInf s ≤ 0 | true |
Lean.Meta.initFn._@.Lean.Meta.Tactic.Util.3824588779._hygCtx._hyg.4 | Lean.Meta.Tactic.Util | IO (Lean.Option Bool) | false |
Lean.Lsp.instFromJsonTextDocumentContentChangeEvent | Lean.Data.Lsp.TextSync | Lean.FromJson Lean.Lsp.TextDocumentContentChangeEvent | true |
SchwartzMap.integralCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {D : Type u_1} [inst : NormedAddCommGroup D] (n : ℕ) (x : D), 0 < (1 + ‖x‖) ^ ↑n | false |
Valuation.Integers.one_of_isUnit | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u} {Γ₀ : Type v} [inst : CommRing R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation R Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O R],
v.Integers O → ∀ {x : O}, IsUnit x → v ((algebraMap O R) x) = 1 | true |
_private.Mathlib.Data.Vector3.0.Fin2.add.match_1.eq_1 | Mathlib.Data.Vector3 | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match 0 with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_1 () | true |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map | 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) → {X Y : B} → (X ⟶ Y) → (self.obj X ⟶ self.obj Y) | true |
CategoryTheory.Localization.Preadditive.add | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | {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] →
[CategoryTheory.Preadditive C] →
{L : CategoryTheory.Functor C D} →
(W : CategoryTheory.MorphismProperty C) →
[L.IsLocalization W] →... | true |
SimpleGraph.induceHom_injective | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} {s : Set V} {t : Set W} (φ : G →g G')
(φst : Set.MapsTo (⇑φ) s t), Set.InjOn (⇑φ) s → Function.Injective ⇑(SimpleGraph.induceHom φ φst) | true |
Std.HashMap.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α Unit} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (m.insertManyIfNewUnit l).getKey! k' = k | true |
Lean.StructureResolutionOrderResult.mk.noConfusion | Lean.Structure | {P : Sort u} →
{resolutionOrder : Array Lean.Name} →
{conflicts : Array Lean.StructureResolutionOrderConflict} →
{resolutionOrder' : Array Lean.Name} →
{conflicts' : Array Lean.StructureResolutionOrderConflict} →
{ resolutionOrder := resolutionOrder, conflicts := conflicts } =
... | false |
RootPairing.CorootForm | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | {ι : 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] → RootPairing ι R M N → [Fintype ι] → LinearMap.BilinFor... | true |
Std.TreeSet.Raw.size_insertMany_list_le | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {l : List α}, (t.insertMany l).size ≤ t.size + l.length | true |
CategoryTheory.ThinSkeleton.map₂Functor._proof_2 | Mathlib.CategoryTheory.Skeletal | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_4, u_3} E]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (x : CategoryTheory.ThinSkeleton C)
{X Y Z : CategoryTheory.ThinS... | false |
Vector.append_empty | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n}, xs ++ #v[] = xs | true |
TopCat.binaryCofan._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ (X Y : TopCat), Continuous Sum.inr | false |
Mathlib.Tactic.Bicategory.instMonadMor₂BicategoryM | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Mathlib.Tactic.BicategoryLike.MonadMor₂ Mathlib.Tactic.Bicategory.BicategoryM | true |
mdifferentiableOn_iUnion_iff_of_isOpen | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : 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... | true |
Asymptotics.isEquivalent_iff_tendsto_one | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedField β] {u v : α → β} {l : Filter α},
(∀ᶠ (x : α) in l, v x ≠ 0) → (Asymptotics.IsEquivalent l u v ↔ Filter.Tendsto (u / v) l (nhds 1)) | true |
USize.ofNatTruncate_eq_ofNat | Init.Data.UInt.Lemmas | ∀ n < USize.size, USize.ofNatTruncate n = USize.ofNat n | true |
_private.Mathlib.Data.Set.Pointwise.Support.0.support_comp_inv_smul._simp_1_2 | Mathlib.Data.Set.Pointwise.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, (x ∈ Function.support f) = (f x ≠ 0) | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Equiv.Perm.isoCycle._simp_6 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ ↑l) = (a ∈ l) | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Markov.0.MeasureTheory.ae_lt_top'._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {p : α → Prop}, (∀ᵐ (a : α) ∂μ, p a) = (μ {a | ¬p a} = 0) | false |
UniqueAdd.of_image_filter | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] [inst_2 : DecidableEq H] (f : G →ₙ+ H) {A B : Finset G}
{aG bG : G} {aH bH : H},
f aG = aH →
f bG = bH →
UniqueAdd (Finset.image (⇑f) A) (Finset.image (⇑f) B) aH bH →
UniqueAdd ({a ∈ A | f a = aH}) ({b ∈ B | f b = bH}) aG bG → UniqueA... | true |
OpenPartialHomeomorph.trans' | Mathlib.Topology.OpenPartialHomeomorph.Composition | {X : Type u_1} →
{Y : Type u_3} →
{Z : Type u_5} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
(e : OpenPartialHomeomorph X Y) →
(e' : OpenPartialHomeomorph Y Z) → e.target = e'.source → OpenPartialHomeomorph X Z | true |
IsGroupLikeElem.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.GroupLike | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] {a : A},
CoalgebraStruct.counit a = 1 → CoalgebraStruct.comul a = a ⊗ₜ[R] a → IsGroupLikeElem R a | false |
_private.Mathlib.Topology.Algebra.Order.Field.0.tendsto_const_mul_pow_nhds_iff'._simp_1_1 | Mathlib.Topology.Algebra.Order.Field | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [T1Space X] {l : Filter Y} [l.NeBot] {c d : X},
Filter.Tendsto (fun x => c) l (nhds d) = (c = d) | false |
OrderAddMonoidHom.coe_zero | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : AddZeroClass α]
[inst_3 : AddZeroClass β], ⇑0 = 0 | true |
RingHom.fromOpposite._proof_3 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
(↑(f.toAddMonoidHom.comp MulOpposite.opAddEquiv.symm.toAddMonoidHom)).toFun 0 = 0 | false |
BoxIntegral.Box.mk' | Mathlib.Analysis.BoxIntegral.Box.Basic | {ι : Type u_1} → (ι → ℝ) → (ι → ℝ) → WithBot (BoxIntegral.Box ι) | true |
Nat.divMaxPow_one_left | Mathlib.Data.Nat.MaxPowDiv | ∀ (p : ℕ), Nat.divMaxPow 1 p = 1 | true |
AddAction.instElemOrbit_1 | Mathlib.GroupTheory.GroupAction.Defs | {G : Type u_1} →
{α : Type u_2} →
[inst : AddGroup G] → [inst_1 : AddAction G α] → (x : AddAction.orbitRel.Quotient G α) → AddAction G ↑x.orbit | true |
Qq.Impl.ExprBackSubstResult.quoted.injEq | Qq.Macro | ∀ (e e_1 : Lean.Expr), (Qq.Impl.ExprBackSubstResult.quoted e = Qq.Impl.ExprBackSubstResult.quoted e_1) = (e = e_1) | true |
CategoryTheory.Limits.MulticospanIndex.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : SizeOf C] (left : J.L → C) (right : J.R → C) (fst : (b : J.R) → left (J.fst b) ⟶ right b)
(snd : (b : J.R) → left (J.snd b) ⟶ right b), sizeOf { left := left, right := right, fst := fst, snd := snd } = 1 | true |
SnakeLemma.δ._proof_2 | Mathlib.Algebra.Module.SnakeLemma | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
AddSubgroup.neg_mem' | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_3} [inst : AddGroup G] (self : AddSubgroup G) {x : G}, x ∈ self.carrier → -x ∈ self.carrier | true |
Submonoid.noConfusion | Mathlib.Algebra.Group.Submonoid.Defs | {P : Sort u} →
{M : Type u_3} →
{inst : MulOneClass M} →
{t : Submonoid M} →
{M' : Type u_3} →
{inst' : MulOneClass M'} →
{t' : Submonoid M'} → M = M' → inst ≍ inst' → t ≍ t' → Submonoid.noConfusionType P t t' | false |
CategoryTheory.map_coyonedaEquiv | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {F : CategoryTheory.Functor C (Type v₁)}
(f : CategoryTheory.coyoneda.obj (Opposite.op X) ⟶ F) (g : X ⟶ Y),
F.map g (CategoryTheory.coyonedaEquiv f) = f.app Y g | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_17 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.simplifyResultingUniverse.simp.match_3 | Lean.Elab.MutualInductive | (motive : Lean.Level → Sort u_1) →
(u : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((a : Lean.LMVarId) → motive (Lean.Level.mvar a)) →
((a : Lean.Name) → motive (Lean.Level.param a)) →
((a : Lean.Level) → motive a.succ) →
((a b : Lean.Level) → motive (a.max b)) → ((a b : L... | false |
DirichletCharacter.FactorsThrough.χ₀._proof_2 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ} (h : χ.FactorsThrough d),
∃ χ₀, χ = (DirichletCharacter.changeLevel ⋯) χ₀ | false |
WithBot.pred_coe | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] [inst_2 : (a : α) → Decidable (Order.pred a = a)]
[NoMinOrder α] {a : α}, Order.pred ↑a = ↑(Order.pred a) | true |
ProperCone.relative_hyperplane_separation | Mathlib.Analysis.Convex.Cone.InnerDual | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
[inst_2 : CompleteSpace E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℝ F] [inst_5 : CompleteSpace F]
{C : ProperCone ℝ E} {f : E →L[ℝ] F} {b : F},
b ∈ ProperCone.map f C ↔ ∀ (y : F), (ContinuousLinearM... | true |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ico_image_const_sub_eq_Ico._simp_1_2 | Mathlib.Order.Interval.Finset.Nat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | false |
Nat.card_ulift | Mathlib.SetTheory.Cardinal.Finite | ∀ (α : Type u_3), Nat.card (ULift.{u_4, u_3} α) = Nat.card α | true |
iteratedFDerivWithin._proof_1 | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], IsTopologicalAddGroup F | false |
Lean.TheoremVal.all._default | Lean.Declaration | Lean.Name → List Lean.Name | false |
Aesop.Match.forwardDeps | Aesop.Forward.Match.Types | Aesop.Match → Array Aesop.PremiseIndex | true |
Module.subsingletonEquiv.congr_simp | Mathlib.LinearAlgebra.Basis.Defs | ∀ (R : Type u_4) (M : Type u_5) (ι : Type u_6) [inst : Semiring R] [inst_1 : Subsingleton R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M], Module.subsingletonEquiv R M ι = Module.subsingletonEquiv R M ι | true |
CategoryTheory.Comon.MonOpOpToComon._proof_2 | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : (CategoryTheory.Mon Cᵒᵖ)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f.unop.hom.unop CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp CategoryTheory.ComonObj.comul
(C... | false |
_private.Lean.Elab.Tactic.Config.0.Lean.Elab.Tactic.elabConfig.match_3 | Lean.Elab.Tactic.Config | (motive : Option Lean.Term → Sort u_1) →
(source? : Option Lean.Term) →
((source : Lean.Term) → motive (some source)) → ((x : Option Lean.Term) → motive x) → motive source? | false |
CategoryTheory.WithTerminal.lift._proof_4 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z),
(∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) →
∀ {X Y Z_1 : CategoryTheory.Wi... | false |
CochainComplex.HomComplex.Cochain.diff | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → (K : CochainComplex C ℤ) → CochainComplex.HomComplex.Cochain K K 1 | true |
LinearMap.toContinuousLinearMap._proof_7 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type u_3}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst... | false |
_private.Mathlib.LinearAlgebra.FiniteDimensional.Basic.0.LinearMap.ker_noncommProd_eq_of_supIndep_ker._simp_1_2 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | false |
Lean.Meta.Simp.Methods.toMethodsRef | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Methods → Lean.Meta.Simp.MethodsRef | true |
Polynomial.degree_mul_C_of_isUnit | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} {a : R} [inst : Semiring R], IsUnit a → ∀ (p : Polynomial R), (p * Polynomial.C a).degree = p.degree | true |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_separation_compact_nhds._simp_1_5 | Mathlib.Topology.Separation.Hausdorff | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | false |
_private.Lean.Meta.Tactic.Grind.Order.Proof.0.Lean.Meta.Grind.Order.mkLeLtPrefix | Lean.Meta.Tactic.Grind.Order.Proof | Lean.Name → Lean.Meta.Grind.Order.OrderM Lean.Expr | true |
GenContFract.terminatedAt_iff_s_none | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {α : Type u_1} {g : GenContFract α} {n : ℕ}, g.TerminatedAt n ↔ g.s.get? n = none | true |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1.recOn | Lean.Server.FileWorker.WidgetRequests | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
(t : Lean.Widget.RpcEncodablePacket✝) →
((type exprExplicit doc : Lean.Json) → motive { type := type, exprExplicit := exprExplicit, doc := doc }) → motive t | false |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Decl.isExtern._sparseCasesOn_1 | Lean.Compiler.IR.Basic | {motive : Lean.IR.Decl → Sort u} →
(t : Lean.IR.Decl) →
((f : Lean.IR.FunId) →
(xs : Array Lean.IR.Param) →
(type : Lean.IR.IRType) → (ext : Lean.ExternAttrData) → motive (Lean.IR.Decl.extern f xs type ext)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Group.rank | Mathlib.GroupTheory.Rank | (G : Type u_1) → [inst : Group G] → [h : Group.FG G] → ℕ | true |
Finset.mem_neg_vadd_finset_iff | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : AddGroup α] [inst_2 : AddAction α β] {s : Finset β}
{a : α} {b : β}, b ∈ -a +ᵥ s ↔ a +ᵥ b ∈ s | true |
List.modifyHead_eq_nil_iff._simp_1 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {l : List α}, (List.modifyHead f l = []) = (l = []) | false |
Lean.Parser.registerBuiltinParserAttribute._auto_1 | Lean.Parser.Extension | Lean.Syntax | false |
Complex.VerticalIntegrable._auto_1 | Mathlib.Analysis.MellinTransform | Lean.Syntax | false |
Int.sign_one | Init.Data.Int.Order | Int.sign 1 = 1 | true |
CategoryTheory.Equivalence.instMonoidalInverseRefl._aux_1 | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶
CategoryTheory.Equivalence.refl.inverse.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | false |
DerivingHelpers._aux_Init_LawfulBEqTactics___macroRules_DerivingHelpers_tacticDeriving_ReflEq_tactic_1 | Init.LawfulBEqTactics | Lean.Macro | false |
CategoryTheory.ComposableArrows.Precomp.map_zero_succ_succ._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (j : ℕ), 0 ≤ j + 1 | false |
Lean.Parser.LeadingIdentBehavior.noConfusionType | Lean.Parser.Basic | Sort v✝ → Lean.Parser.LeadingIdentBehavior → Lean.Parser.LeadingIdentBehavior → Sort v✝ | true |
Prefunctor.IsCovering.symmetrify | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V),
φ.IsCovering → φ.symmetrify.IsCovering | true |
IsCompactOperator.hasEigenvalue_iff_mem_spectrum | Mathlib.Analysis.Normed.Operator.FredholmAlternative | ∀ {𝕜 : Type u_1} {X : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup X]
[inst_2 : NormedSpace 𝕜 X] {T : X →L[𝕜] X} {μ : 𝕜} [CompleteSpace X],
IsCompactOperator ⇑T → μ ≠ 0 → (Module.End.HasEigenvalue (↑T) μ ↔ μ ∈ spectrum 𝕜 T) | true |
PowerSeries.«term_%ʷ_» | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | Lean.TrailingParserDescr | true |
Dilation.ratioHom | Mathlib.Topology.MetricSpace.Dilation | {α : Type u_1} → [inst : PseudoEMetricSpace α] → (α →ᵈ α) →* NNReal | true |
irrational_ratCast_add_iff | Mathlib.NumberTheory.Real.Irrational | ∀ {q : ℚ} {x : ℝ}, Irrational (↑q + x) ↔ Irrational x | true |
MeasurableEquiv.shearAddRight | Mathlib.MeasureTheory.Group.Prod | (G : Type u_1) →
[inst : MeasurableSpace G] → [inst_1 : AddGroup G] → [MeasurableAdd₂ G] → [MeasurableNeg G] → G × G ≃ᵐ G × G | true |
lie_abelian_iff_equiv_lie_abelian | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂), IsLieAbelian L₁ ↔ IsLieAbelian L₂ | true |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscrete_accPt._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {S : Set X},
(S ∈ Filter.codiscrete X) = ∀ (x : X), Disjoint (nhdsWithin x {x}ᶜ) (Filter.principal Sᶜ) | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularTopology.0.CategoryTheory.regularTopology.instEffectiveEpiComp.match_1 | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | (motive : Unit → Sort u_1) → (x : Unit) → (Unit → motive PUnit.unit) → motive x | false |
Lean.Grind.CommRing.Poly.NonnegCoeffs.below.casesOn | Init.Grind.Ring.CommSemiringAdapter | ∀ {motive : (a : Lean.Grind.CommRing.Poly) → a.NonnegCoeffs → Prop}
{motive_1 :
{a : Lean.Grind.CommRing.Poly} → (t : a.NonnegCoeffs) → Lean.Grind.CommRing.Poly.NonnegCoeffs.below t → Prop}
{a : Lean.Grind.CommRing.Poly} {t : a.NonnegCoeffs} (t_1 : Lean.Grind.CommRing.Poly.NonnegCoeffs.below t),
(∀ (c : ℤ) (a... | false |
UniqueDiffWithinAt.inter' | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
UniqueDiffWithinAt 𝕜 s x → t ∈ nhdsWithin x s → UniqueDiffWithinAt 𝕜 (s ∩ t) x | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.