name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
not_fermatLastTheoremFor_two | Mathlib.NumberTheory.FLT.Basic | ¬FermatLastTheoremFor 2 | null | true |
FreeLieAlgebra.liftAux_map_mul | Mathlib.Algebra.Lie.Free | ∀ (R : Type u) {X : Type v} [inst : CommRing R] {L : Type w} [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (f : X → L)
(a b : FreeNonUnitalNonAssocAlgebra R X),
(FreeLieAlgebra.liftAux R f) (a * b) = ⁅(FreeLieAlgebra.liftAux R f) a, (FreeLieAlgebra.liftAux R f) b⁆ | null | true |
IsDedekindDomain.HeightOneSpectrum.adicCompletion.instField._proof_17 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_1) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R),
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
TypeVec.toSubtype._f | Mathlib.Data.TypeVec | (x : ℕ) →
(x_1 : Fin2 x) →
Fin2.below (motive := fun x x_2 =>
(x_3 : TypeVec.{u} x) →
(x_4 : x_3.Arrow (TypeVec.repeat x Prop)) →
{ x_5 // TypeVec.ofRepeat (x_4 x_2 x_5) } → TypeVec.Subtype_ x_4 x_2)
x_1 →
(x_2 : TypeVec.{u} x) →
(x_3 : x_2.Arrow (TypeVec.repeat... | null | false |
selfAdjointPart_apply_coe | Mathlib.Algebra.Star.Module | ∀ (R : Type u_1) {A : Type u_2} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
[inst_7 : Invertible 2] (x : A), ↑((selfAdjointPart R) x) = ⅟2 • (x + star x) | null | true |
Set.uIoo_subset_Ioo | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
a₁ ∈ Set.Icc a₂ b₂ → b₁ ∈ Set.Icc a₂ b₂ → Set.uIoo a₁ b₁ ⊆ Set.Ioo a₂ b₂ | null | true |
AddSubgroup.unop_injective | Mathlib.Algebra.Group.Subgroup.MulOpposite | ∀ {G : Type u_1} [inst : AddGroup G], Function.Injective AddSubgroup.unop | null | true |
_private.Mathlib.Topology.Algebra.Valued.ValuedField.0.Valued.valuedCompletion_surjective_iff._simp_1_1 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {a : Prop}, (a → False) = ¬a | null | false |
_private.Lean.Level.0.Lean.Level.geq.go._sparseCasesOn_2 | Lean.Level | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a a_1 : Lean.Level) → motive (a.imax a_1)) →
((a : Lean.Level) → motive a.succ) → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t | null | false |
List.flatten_nil | Init.Data.List.Basic | ∀ {α : Type u}, [].flatten = [] | null | true |
CategoryTheory.Endofunctor.Adjunction.Coalgebra.toAlgebraOf_obj_a | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (adj : F ⊣ G)
(V : CategoryTheory.Endofunctor.Coalgebra G),
((CategoryTheory.Endofunctor.Adjunction.Coalgebra.toAlgebraOf adj).obj V).a = V.V | null | true |
Submodule.mul_iSup | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : Semiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {ι : Sort uι} (t : Submodule R A) (s : ι → Submodule R A), t * ⨆ i, s i = ⨆ i, t * s i | null | true |
Finset.univ_val_map_subtype_restrict | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] (f : α → β) (p : α → Prop) [inst_1 : DecidablePred p]
[inst_2 : Fintype { a // p a }],
Multiset.map (Subtype.restrict p f) Finset.univ.val = Multiset.map f (Finset.filter p Finset.univ).val | null | true |
Nat.orderEmbeddingOfSet_range | Mathlib.Order.OrderIsoNat | ∀ (s : Set ℕ) [inst : Infinite ↑s] [inst_1 : DecidablePred fun x => x ∈ s], Set.range ⇑(Nat.orderEmbeddingOfSet s) = s | null | true |
Filter.HasBasis.forall_mem_mem | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_3} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s → ∀ {x : α}, (∀ t ∈ l, x ∈ t) ↔ ∀ (i : ι), p i → x ∈ s i | null | true |
HasCompactMulSupport.uniformContinuous_of_continuous | Mathlib.Topology.UniformSpace.HeineCantor | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} [inst_2 : One β],
HasCompactMulSupport f → Continuous f → UniformContinuous f | null | true |
PresheafOfModules.sections.eval | Mathlib.Algebra.Category.ModuleCat.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} → {M : PresheafOfModules R} → M.sections → (X : Cᵒᵖ) → ↑(M.obj X) | Given a presheaf of modules `M`, `s : M.sections` and `X : Cᵒᵖ`, this is the induced
element in `M.obj X`. | true |
Lean.OptionDecl.mk.injEq | Lean.Data.Options | ∀ (name : Lean.Name) (declName : autoParam Lean.Name Lean.OptionDecl.declName._autoParam) (defValue : Lean.DataValue)
(descr : String) (deprecation? : Option Lean.OptionDeprecation) (name_1 : Lean.Name)
(declName_1 : autoParam Lean.Name Lean.OptionDecl.declName._autoParam) (defValue_1 : Lean.DataValue)
(descr_1 :... | null | true |
Cardinal.zero_lt_lift_iff | Mathlib.SetTheory.Cardinal.Order | ∀ {a : Cardinal.{u}}, 0 < Cardinal.lift.{v, u} a ↔ 0 < a | null | true |
Lean.Lsp.SymbolKind.boolean | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolKind | null | true |
Cube.insertAt_boundary | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} [inst : DecidableEq N] (i : N) {t₀ : ↑unitInterval} {t : { j // j ≠ i } → ↑unitInterval},
(t₀ = 0 ∨ t₀ = 1) ∨ t ∈ Cube.boundary { j // j ≠ i } → (Cube.insertAt i) (t₀, t) ∈ Cube.boundary N | null | true |
CategoryTheory.Limits.Cofork.π.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : Y ⟶ X} (t : CategoryTheory.Limits.Cofork f g),
t.π = t.ι.app CategoryTheory.Limits.WalkingParallelPair.one | null | true |
Std.Iterators.Types.DropWhile.recOn | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} →
{motive : Std.Iterators.Types.DropWhile α m β P → Sort u} →
(t : Std.Iterators.Types.DropWhile α m β P) →
((dropping : Bool) → (inner : Std.IterM m β) → motive ... | null | false |
_private.Mathlib.Algebra.Order.Group.DenselyOrdered.0.exists_mul_left_lt | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LT α] [DenselyOrdered α] [MulRightStrictMono α] {a b c : α},
a * b < c → ∃ a' > a, a' * b < c | null | true |
CategoryTheory.Limits.CategoricalPullback.comp_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
{X Y Z : CategoryTheory.Limits.CategoricalPullback F G} (f : X.Hom Y... | null | true |
CategoryTheory.MorphismProperty.IsStableUnderBaseChangeAgainst.isStableUnderBaseChangeAlong | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P P' : CategoryTheory.MorphismProperty C}
[self : P.IsStableUnderBaseChangeAgainst P'] ⦃X Y : C⦄ (f : X ⟶ Y), P' f → P.IsStableUnderBaseChangeAlong f | null | true |
TensorProduct.Algebra.module._proof_7 | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type u_4} {A : Type u_2} {B : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsSca... | null | false |
Lean.Compiler.LCNF.instInhabitedFunDecl.default_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.FunDecl pu | null | true |
CategoryTheory.Bicategory.InducedBicategory.forget._proof_9 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c : CategoryTheory.Bicategory.InducedBicategory C F} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c),
(CategoryTheory.Bicategory.whiskerRight η g).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheo... | null | false |
ModuleCat.smul._proof_10 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] (M : ModuleCat R) (r s : R),
{ asHom := AddCommGrpCat.ofHom { toFun := fun m => (r + s) • m, map_zero' := ⋯, map_add' := ⋯ } } =
{ asHom := AddCommGrpCat.ofHom { toFun := fun m => r • m, map_zero' := ⋯, map_add' := ⋯ } } +
{ asHom := AddCommGrpCat.ofHom { toFun := fun m => s... | null | false |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.exists_eq | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u} [inst : CategoryTheory.Category.{u, u} I] {S X : AlgebraicGeometry.Scheme}
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} {t : D ⟶ (CategoryTheory.Functor.const I).obj S} {f : X ⟶ S}
[inst_1 : ∀ (i : I), CompactSpace ↥(D.obj i)] [AlgebraicGeometry.LocallyOfFiniteType f]
[inst_3 : CategoryT... | null | true |
SemiRingCat.forget₂AddCommMonPreservesLimitsAux | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J SemiRingCat) →
[inst_1 : Small.{u, max u v} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] →
CategoryTheory.Limits.IsLimit
((CategoryTheory.forget₂ SemiRingCat AddCommMonCat).mapCone (SemiRing... | Auxiliary lemma to prove the cone induced by `limitCone` is a limit cone.
| true |
QuadraticForm.toMatrix._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N],
SMulCommClass R R (N →ₗ[R] R) | null | false |
Finset.mulAction._proof_1 | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] [inst_1 : Monoid α] [inst_2 : MulAction α β] (s : Finset β),
Finset.image (fun b => 1 • b) s = s | null | false |
ContinuousWithinAt.congr_of_eventuallyEq | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → β} {s : Set α}
{x : α}, ContinuousWithinAt f s x → g =ᶠ[nhdsWithin x s] f → g x = f x → ContinuousWithinAt g s x | null | true |
Std.TreeMap.Raw.le_maxKeyD_of_contains | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxKeyD fallback)).isLE = true | null | true |
CategoryTheory.SpectralSequence.Hom.noConfusion | Mathlib.Algebra.Homology.SpectralSequence.Basic | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{u_3, u_1} C} →
{inst_1 : CategoryTheory.Abelian C} →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{E E' : CategoryTheory.SpectralSequence C c r₀} →
{t : E.Hom E'} →
... | null | false |
PadicInt.mahlerSeries._proof_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | null | false |
AddOreLocalization.instAddMonoid | Mathlib.GroupTheory.OreLocalization.Basic | {R : Type u_1} →
[inst : AddMonoid R] →
{S : AddSubmonoid R} → [inst_1 : AddOreLocalization.AddOreSet S] → AddMonoid (AddOreLocalization S R) | null | true |
Std.DTreeMap.Raw.getKey_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} (h' : k ∈ t), t.getKey k h' = k | null | true |
Lean.Widget.instAppendInteractiveGoals | Lean.Widget.InteractiveGoal | Append Lean.Widget.InteractiveGoals | null | true |
Std.Internal.List.contains_insertList_iff | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) = true ↔
Std.Internal.List.containsKey k l = true ∨ Std.Internal.List.containsKey k toInsert = true | null | true |
instInhabitedTensorAlgebra | Mathlib.LinearAlgebra.TensorAlgebra.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
(M : Type u_2) → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Inhabited (TensorAlgebra R M) | null | true |
_private.Mathlib.Data.TypeVec.0.TypeVec.toSubtype'.match_1.eq_1 | Mathlib.Data.TypeVec | ∀
(motive :
(n : ℕ) →
(α : TypeVec.{u_1} n) →
(p : (α.prod α).Arrow (TypeVec.repeat n Prop)) →
(x : Fin2 n) → { x_1 // TypeVec.ofRepeat (p x (TypeVec.prod.mk x x_1.1 x_1.2)) } → Sort u_2)
(n : ℕ) (α : TypeVec.{u_1} (n + 1)) (p : (α.prod α).Arrow (TypeVec.repeat (n + 1) Prop)) (i : Fin2 n... | null | true |
List.eraseIdx_eq_take_drop_succ | Init.Data.List.Erase | ∀ {α : Type u_1} (l : List α) (i : ℕ), l.eraseIdx i = List.take i l ++ List.drop (i + 1) l | null | true |
AntitoneOn._to_dual_cast_1 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β) (s : Set α),
AntitoneOn f s = ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → a ≤ b → f b ≤ f a | null | false |
UniformContinuousConstSMul.mk | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : SMul M X],
(∀ (c : M), UniformContinuous fun x => c • x) → UniformContinuousConstSMul M X | null | true |
_private.Lean.Elab.Tactic.SolveByElim.0.Lean.Elab.Tactic.SolveByElim.elabConfig.evalConfigItem | Lean.Elab.Tactic.SolveByElim | Lean.Elab.ConfigEval.EvalConfigItem Lean.Meta.SolveByElim.SolveByElimConfig | null | true |
Char.ofUInt8.eq_1 | Std.Http.Data.URI.Encoding | ∀ (n : UInt8), Char.ofUInt8 n = { val := n.toUInt32, valid := ⋯ } | null | true |
CategoryTheory.MonoidalOpposite.tensorIso | Mathlib.CategoryTheory.Monoidal.Opposite | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.MonoidalCategory.tensor Cᴹᵒᵖ ≅
((CategoryTheory.unmopFunctor C).prod (CategoryTheory.unmopFunctor C)).comp
((CategoryTheory.Prod.swap C C).comp
((Category... | The identification `mop X ⊗ mop Y = mop (Y ⊗ X)` as a natural isomorphism. | true |
Lean.mkBRecOn | Lean.Meta.Constructions.BRecOn | Lean.Name → Lean.MetaM Unit | null | true |
lp.holderₗ._proof_1 | Mathlib.Analysis.Normed.Lp.lpHolder | ∀ {ι : Type u_1} {E : ι → Type u_2} [inst : (i : ι) → NormedAddCommGroup (E i)],
AddSubmonoidClass (AddSubgroup (PreLp E)) (PreLp E) | null | false |
Lean.Grind.instCommRingUSize._proof_3 | Init.GrindInstances.Ring.UInt | ∀ (i : ℤ) (a : USize), -i • a = -(i • a) | null | false |
_private.Mathlib.Tactic.Attr.Register.0.initFn._@.Mathlib.Tactic.Attr.Register.612238087._hygCtx._hyg.28 | Mathlib.Tactic.Attr.Register | IO Lean.Meta.Simp.SimprocExtension | null | false |
Lean.Parser.Command.docs_to_verso.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
Submodule.ker_subtype | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), p.subtype.ker = ⊥ | null | true |
OrderEmbedding.locallyFiniteOrder | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → [LocallyFiniteOrder β] → α ↪o β → LocallyFiniteOrder α | Given an order embedding `α ↪o β`, pulls back the `LocallyFiniteOrder` on `β` to `α`. | true |
AddSubsemigroup.mem_inf._simp_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M] {p p' : AddSubsemigroup M} {x : M}, (x ∈ p ⊓ p') = (x ∈ p ∧ x ∈ p') | null | false |
Finset.notMem_mono | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → ∀ {a : α}, a ∉ t → a ∉ s | null | true |
Quiver.Path.heq_of_cons_eq_cons | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b c d : V} {p : Quiver.Path a b} {p' : Quiver.Path a c} {e : b ⟶ d} {e' : c ⟶ d},
p.cons e = p'.cons e' → p ≍ p' | null | true |
_private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.evalInv.match_23 | Mathlib.Algebra.Order.Field.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(f : Q(«$α» → «$α»)) →
(_a : Q(Semifield «$α»)) →
(motive : PLift («$f» =Q Inv.inv) → Sort u_1) →
(x : PLift («$f» =Q Inv.inv)) → ((_f_eq : «$f» =Q Inv.inv) → motive { down := _f_eq }) → motive x | null | false |
Aesop.RuleBuilder.cases | Aesop.Builder.Cases | Aesop.RuleBuilder | null | true |
UInt32.ofNatLT_bitVecToNat | Init.Data.UInt.Lemmas | ∀ (n : BitVec 32), UInt32.ofNatLT n.toNat ⋯ = { toBitVec := n } | null | true |
Subarray.foldr | Init.Data.Array.Subarray | {α : Type u} → {β : Type v} → (α → β → β) → β → Subarray α → β | Folds an operation from right to left over the elements in a subarray.
An accumulator of type `β` is constructed by starting with `init` and combining each element of the
subarray with the current accumulator value in turn, moving from the end to the start.
Examples:
* `#["red", "green", "blue"].toSubarray.foldr (·.... | true |
NNReal.holderConjugate_comm | Mathlib.Basic.Real.ConjExponents | ∀ {p q : NNReal}, p.HolderConjugate q ↔ q.HolderConjugate p | null | true |
PartialEquiv.IsImage.restr._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {t : Set β}, Set.RightInvOn (↑e.symm) (↑e) (e.target ∩ t) | null | false |
_private.Mathlib.Topology.Sequences.0.compactSpace_iff_seqCompactSpace._simp_1_1 | Mathlib.Topology.Sequences | ∀ {X : Type u} [inst : TopologicalSpace X], CompactSpace X = IsCompact Set.univ | null | false |
_private.Mathlib.MeasureTheory.Function.LpSpace.Basic.0.MeasureTheory.Lp.norm_LpToLpOfMeasureLeSMulₗ_apply_le._simp_1_1 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] (x : E), ‖x‖ = ‖x‖ₑ.toReal | null | false |
Bimod.AssociatorBimod.hom._proof_1 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorLeft X... | null | false |
CategoryTheory.Limits.coneRightOpOfCoconeEquiv._proof_6 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} J] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_3, u_1} C] {F : CategoryTheory.Functor Jᵒᵖ C}
(X : (CategoryTheory.Limits.Cocone F)ᵒᵖ),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Iso.refl
({ obj := fun c => Opposite.op... | null | false |
CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse_map_hom | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasProduct I.left]
[inst_2 : CategoryTheory.Limits.HasProduct I.right]
{K₁ K₂ :
CategoryTheory.Limits.Fork
(I.fstPiMapOfI... | null | true |
Prod.le_def | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x y : α × β}, x ≤ y ↔ x.1 ≤ y.1 ∧ x.2 ≤ y.2 | null | true |
IsLocalization.Away.sec.congr_simp | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x x_1 : R)
(e_x : x = x_1) [inst_3 : IsLocalization.Away x S] (s s_1 : S),
s = s_1 → IsLocalization.Away.sec x s = IsLocalization.Away.sec x_1 s_1 | null | true |
Homotopy.compRight._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D E : HomologicalComplex V c} {e f : C ⟶ D} (h : Homotopy e f) (g : D ⟶ E) (i j : ι),
¬c.Rel j i → CategoryTheory.CategoryStruct.comp (h.hom i j) (g.f j) = 0 | null | false |
zero_mem_tangentConeAt_iff._simp_1 | 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 : Set E} {x : E}, (0 ∈ tangentConeAt 𝕜 s x) = (x ∈ closure s) | null | false |
CovariantDerivative.affine_combination | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.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} →
... | **Alias** of `CovariantDerivative.affineCombination`.
---
An affine combination of covariant derivatives as a covariant derivative. | true |
Nat.gcd_gcd_self_right_left | Init.Data.Nat.Gcd | ∀ (m n : ℕ), m.gcd (m.gcd n) = m.gcd n | null | true |
Std.DHashMap.Internal.Raw₀.Const.get_eq_of_equiv | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] (h₁ : (↑m₁).WF) (h₂ : (↑m₂).WF) (h : (↑m₁).Equiv ↑m₂) {k : α}
(h' : m₁.contains k = true),
Std.DHashMap.Internal.Raw₀.Const.get m₁ k h' = Std.DHashMa... | null | true |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y : ProfiniteAddGrp.{u_1}} (f : X ⟶ Y), Continuous ⇑(ProfiniteAddGrp.Hom.hom f) | null | false |
EuclideanGeometry.Sphere.IsDiameter.mk._flat_ctor | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → midpoint ℝ p₁ p₂ = s.center → s.IsDiameter p₁ p₂ | null | false |
hnot_hnot_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a : α), ￢￢￢a = ￢a | null | true |
SkewMonoidAlgebra.recOn | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : Zero k] →
{motive : SkewMonoidAlgebra k G → Sort u} →
(t : SkewMonoidAlgebra k G) → ((coeff : G →₀ k) → motive { coeff := coeff }) → motive t | null | false |
Std.DTreeMap.Internal.Impl.Tree.noConfusion | Std.Data.DTreeMap.Internal.Operations | {P : Sort u_1} →
{α : Type u} →
{β : α → Type v} →
{size : ℕ} →
{t : Std.DTreeMap.Internal.Impl.Tree α β size} →
{α' : Type u} →
{β' : α' → Type v} →
{size' : ℕ} →
{t' : Std.DTreeMap.Internal.Impl.Tree α' β' size'} →
α = α' → β ≍ ... | null | false |
Lean.Elab.Deriving.withoutExposeFromCtors | Lean.Elab.Deriving.Util | {α : Type} → Lean.Name → Lean.Elab.Command.CommandElabM α → Lean.Elab.Command.CommandElabM α | Removes any `[expose]` section attributes when running `cont` if `typeName` has private ctors.
| true |
le_mul_inv_iff_mul_le._simp_2 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulRightMono α] {a b c : α}, (c ≤ a * b⁻¹) = (c * b ≤ a) | null | false |
_private.Mathlib.Order.Filter.Basic.0.Filter.not_le._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
FractionalIdeal.extendedHomₐ_injective | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : IsDomain A]
[inst_2 : CommRing B] [inst_3 : IsDomain B] [inst_4 : Algebra A B] [inst_5 : Module.IsTorsionFree A B]
[inst_6 : Field K] [inst_7 : Field L] [inst_8 : Algebra A K] [inst_9 : Algebra B L] [inst_10 : IsFractionRing... | **Alias** of `FractionalIdeal.extendedHom_injective`. | true |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
CategoryTheory.Functor C (CategoryTheory.Comon D) → CategoryTheory.Comon (CategoryTheory.Functor C D) | A functor to the category of comonoid objects can be translated as a comonoid object
in the functor category. | true |
CategoryTheory.GradedObject.Monoidal.ιTensorObj₄.congr_simp | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ X₄ : CategoryTheory.GradedObject I C)
[inst_3 : X₃.HasTensor X₄] [inst_4 : X₂.HasTensor (CategoryTheory.GradedObject.Monoidal.tensorObj X₃ X₄)]
[inst_5 :
X₁... | null | true |
_private.Std.Http.Internal.String.0.Std.Http.Internal.UnquoteState._sizeOf_1 | Std.Http.Internal.String | Std.Http.Internal.UnquoteState✝ → ℕ | null | false |
Lean.Elab.Tactic.TacticParsedSnapshotInner.stx | Lean.Elab.Term.TermElabM | {α : Type} → Lean.Elab.Tactic.TacticParsedSnapshotInner α → Lean.Syntax | Syntax tree of the tactic, stored and compared for incremental reuse. | true |
vadd_left_cancel_iff._simp_1 | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α) {x y : β},
(g +ᵥ x = g +ᵥ y) = (x = y) | null | false |
FinPartOrd.instCoeSortType | Mathlib.Order.Category.FinPartOrd | CoeSort FinPartOrd (Type u_1) | null | true |
List.fixedLengthDigits.congr_simp | Mathlib.Data.Nat.Digits.Lemmas | ∀ {b b_1 : ℕ} (e_b : b = b_1) (hb : 1 < b) (l l_1 : ℕ),
l = l_1 → List.fixedLengthDigits hb l = List.fixedLengthDigits ⋯ l_1 | null | true |
CategoryTheory.Bicategory.postcomposingCat._proof_4 | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] (a b c : B) {X Y Z : b ⟶ c} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.NatTrans.toCatHom₂
((CategoryTheory.Bicategory.postcomposing a b c).map (CategoryTheory.CategoryStruct.comp f g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.NatTrans.toCa... | null | false |
Pi.monotoneCurry | Mathlib.Control.LawfulFix | (α : Type u_1) →
(β : α → Type u_2) →
(γ : (a : α) → β a → Type u_3) →
[inst : (x : α) → (y : β x) → Preorder (γ x y)] →
((x : (a : α) × β a) → γ x.fst x.snd) →o (a : α) → (b : β a) → γ a b | `Sigma.curry` as a monotone function. | true |
Commute.natCast_mul_self | Mathlib.Data.Nat.Cast.Commute | ∀ {α : Type u_1} [inst : Semiring α] (a : α) (n : ℕ), Commute (↑n * a) a | null | true |
MeasureTheory.Measure.regular_of_isAddLeftInvariant | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [BorelSpace G] [SecondCountableTopology G] {μ : MeasureTheory.Measure G}
[MeasureTheory.SigmaFinite μ] [μ.IsAddLeftInvariant] {K : Set G},
IsCompact K → (interior K).Nonempty → μ K ≠ ⊤ → μ.Reg... | To show that an invariant σ-finite measure is regular it is sufficient to show that it is
finite on some compact set with non-empty interior. | true |
ULift.inv.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : Inv α], ULift.inv = { inv := fun f => { down := f.down⁻¹ } } | null | true |
_private.Mathlib.Analysis.Calculus.DifferentialForm.VectorField.0.extDeriv_apply_vectorField_of_pairwise_commute._simp_1_1 | Mathlib.Analysis.Calculus.DifferentialForm.VectorField | ∀ {𝕜 : 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} {x : E}, DifferentiableAt 𝕜 f x = DifferentiableWithinAt 𝕜 f... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.