name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Polynomial.ofFinsupp_eq_one | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {a : AddMonoidAlgebra R ℕ}, { toFinsupp := a } = 1 ↔ a = 1 | null | true |
AndOp.rec | Init.Prelude | {α : Type u} → {motive : AndOp α → Sort u_1} → ((and : α → α → α) → motive { and := and }) → (t : AndOp α) → motive t | null | false |
toIcoDiv_sub_ofNat_mul | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℕ) [inst_4 : m.AtLeastTwo],
toIcoDiv hp a (b - OfNat.ofNat m * p) = toIcoDiv hp a b - OfNat.ofNat m | null | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts_supportsStmt._simp_1_6 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b | null | false |
MDifferentiableOn.apply_eq_of_isPreconnected_isCompact_isOpen | Mathlib.Geometry.Manifold.Complex | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℂ F] {H : Type u_3} [inst_4 : TopologicalSpace H] {I : ModelWithCorners ℂ E H} [I.Boundaryless]
{M : Type u_4} [inst_6 : TopologicalSpace M] [inst_7 : ChartedSpace H M] [IsM... | If a function `f : M → F` from a complex manifold to a complex normed space is holomorphic on a
(pre)connected compact open set, then it is a constant on this set. | true |
CategoryTheory.Pairwise.Hom.id_single.elim | Mathlib.CategoryTheory.Category.Pairwise | {ι : Type v} →
{motive : (a a_1 : CategoryTheory.Pairwise ι) → a.Hom a_1 → Sort u} →
{a a_1 : CategoryTheory.Pairwise ι} →
(t : a.Hom a_1) →
t.ctorIdx = 0 →
((i : ι) →
motive (CategoryTheory.Pairwise.single i) (CategoryTheory.Pairwise.single i)
(CategoryTheory... | null | false |
Finset.cons._proof_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} (a : α) (s : Finset α), a ∉ s → (a ::ₘ s.val).Nodup | null | false |
RatFunc.InftyValuation.map_add_le_max' | Mathlib.FieldTheory.RatFunc.Valuation | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)] (x y : RatFunc F),
RatFunc.inftyValuationDef F (x + y) ≤ max (RatFunc.inftyValuationDef F x) (RatFunc.inftyValuationDef F y) | null | true |
SimpleGraph.recolorOfEmbedding._proof_2 | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u_1} (G : SimpleGraph V) {α : Type u_2} {β : Type u_3} (f : α ↪ β) (C C' : G.Coloring α),
(SimpleGraph.Embedding.completeGraph f).toHom.comp C = (SimpleGraph.Embedding.completeGraph f).toHom.comp C' →
{ toFun := ⇑C, map_rel' := ⋯ } = { toFun := ⇑C', map_rel' := ⋯ } | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterMapWithPostcondition.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {β β' : Type u_1} {n : Type u_1 → Type u_2} {f : β → Std.Iterators.PostconditionT n (Option β')} (out : β)
(motive : Subtype (f out).Property → Sort u_3) (h' : (f out).Property none)
(h_1 : (h' : (f out).Property none) → motive ⟨none, h'⟩)
(h_2 : (out' : β') → (h' : (f out).Property (some out')) → motive ⟨some ... | null | true |
Mathlib.Tactic.Polynomial.PolynomialExt | Mathlib.Tactic.Polynomial.Core | Type | An extension for `polynomial`. | true |
_private.Mathlib.Tactic.FunProp.Theorems.0.Mathlib.Meta.FunProp.instReprTheoremForm.repr.match_1 | Mathlib.Tactic.FunProp.Theorems | (motive : Mathlib.Meta.FunProp.TheoremForm → Sort u_1) →
(x : Mathlib.Meta.FunProp.TheoremForm) →
(Unit → motive Mathlib.Meta.FunProp.TheoremForm.uncurried) →
(Unit → motive Mathlib.Meta.FunProp.TheoremForm.comp) → motive x | null | false |
Algebra.PreSubmersivePresentation.cotangentComplexAux._proof_4 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_3} {ι : Type u_2} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ), SMulCommClass P.toExtension.Ring S S | null | false |
_private.Mathlib.Topology.Separation.Regular.0.TopologicalSpace.IsTopologicalBasis.exists_closure_subset._simp_1_2 | Mathlib.Topology.Separation.Regular | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
ValuativeRel.RankLeOneStruct.strictMono | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] (self : ValuativeRel.RankLeOneStruct R),
StrictMono ⇑self.emb | null | true |
Lean.Lsp.instFileSourceDidSaveTextDocumentParams | Lean.Server.FileSource | Lean.Lsp.FileSource Lean.Lsp.DidSaveTextDocumentParams | null | true |
NonUnitalStarSubalgebra.toNonUnitalSemiring | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : Module R A] → [inst_3 : Star A] → (S : NonUnitalStarSubalgebra R A) → NonUnitalSemiring ↥S | null | true |
List.length_take | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {i : ℕ} {l : List α}, (List.take i l).length = min i l.length | null | true |
_private.Init.Data.List.Erase.0.List.erase_eq_iff._simp_1_1 | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
Array.isEmpty_replicate | Init.Data.Array.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α}, (Array.replicate n a).isEmpty = decide (n = 0) | null | true |
_private.Lean.Compiler.LCNF.Simp.InlineProj.0.Lean.Compiler.LCNF.Simp.inlineProjInst?.visit.match_12 | Lean.Compiler.LCNF.Simp.InlineProj | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((ctorVal : Lean.ConstructorVal) → motive (some (Lean.ConstantInfo.ctorInfo ctorVal))) →
((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
Lake.ComparatorOp.eq | Lake.Util.Version | Lake.ComparatorOp | null | true |
Std.Time.DayPeriodSymbols.casesOn | Std.Time.Format.DateFormat | {motive : Std.Time.DayPeriodSymbols → Sort u} →
(t : Std.Time.DayPeriodSymbols) →
((am pm noon midnight : String) → motive { am := am, pm := pm, noon := noon, midnight := midnight }) → motive t | null | false |
AdjoinRoot.isAdjoinRootMonic | Mathlib.RingTheory.IsAdjoinRoot | {R : Type u} → [inst : CommRing R] → (f : Polynomial R) → f.Monic → IsAdjoinRootMonic (AdjoinRoot f) f | `AdjoinRoot f` is indeed given by adjoining a root of `f`. If `f` is monic this is more
powerful than `AdjoinRoot.isAdjoinRoot`. | true |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.singleton_le_singleton._simp_1_2 | Mathlib.Combinatorics.Colex | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.zsmul._proof_1 | Init.Grind.Module.Envelope | ∀ {α : Type u_1} [inst : Lean.Grind.NatModule α] (n : ℤ) (h : α × α) (b : α × α),
Lean.Grind.IntModule.OfNatModule.r α h b →
(match h with
| (a, b) =>
if n < 0 then Lean.Grind.IntModule.OfNatModule.Q.mk (n.natAbs • b, n.natAbs • a)
else Lean.Grind.IntModule.OfNatModule.Q.mk (n.natAbs • a, n.... | null | false |
_private.Lean.PrettyPrinter.Delaborator.FieldNotation.0.Lean.PrettyPrinter.Delaborator.generalizedFieldInfo | Lean.PrettyPrinter.Delaborator.FieldNotation | Lean.Name → Array Lean.Expr → Lean.MetaM (Lean.Name × ℕ) | If this constant application could delaborate using generalized field notation with little confusion,
returns the field name and the index for the argument to be used as the object of the field notation.
Otherwise it fails.
| true |
Lean.PrettyPrinter.Parenthesizer.State.ctorIdx | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer.State → ℕ | null | false |
Lean.Compiler.LCNF.StructProjCases.M.run | Lean.Compiler.LCNF.StructProjCases | {α : Type} → Lean.Compiler.LCNF.StructProjCases.M α → Lean.Compiler.LCNF.CompilerM α | null | true |
CategoryTheory.GrothendieckTopology.diagramNatTrans_comp | 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 Q R : CategoryTheory.Fu... | null | true |
Std.Http.Status.insufficientStorage | Std.Http.Data.Status | Std.Http.Status | 507 Insufficient Storage
| true |
Option.get_map._proof_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {o : Option α} {h : (Option.map f o).isSome = true}, o.isSome = true | null | false |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.getElem_succ_leftInvSeq_alternatingWord._proof_1_3 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ (p k : ℕ), k + 1 < 2 * p → k + 1 < 2 * p | null | false |
Path.toHomotopyConst | Mathlib.Topology.Homotopy.Path | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{x₀ x₁ : X} → Path x₀ x₁ → (ContinuousMap.const Y x₀).Homotopy (ContinuousMap.const Y x₁) | A path `Path x₀ x₁` generates a homotopy between constant functions `fun _ ↦ x₀` and
`fun _ ↦ x₁`. | true |
Std.IO.Process.ResourceUsageStats.mk.injEq | Std.Async.Process | ∀ (cpuUserTime cpuSystemTime : Std.Time.Millisecond.Offset)
(peakResidentSetSizeKb sharedMemorySizeKb unsharedDataSizeKb unsharedStackSizeKb minorPageFaults majorPageFaults
swapOperations blockInputOps blockOutputOps messagesSent messagesReceived signalsReceived voluntaryContextSwitches
involuntaryContextSwit... | null | true |
CategoryTheory.Limits.initialIsInitial._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Terminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasInitial C]
(s : CategoryTheory.Limits.Cocone (CategoryTheory.Functor.empty C)) (j : CategoryTheory.Discrete PEmpty.{1}),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.asEmptyCocone (⊥_ C)).ι.app j)
(... | null | false |
TopRep._mkInternal.injEq | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u} {G : Type v} [inst : Ring k] [inst_1 : TopologicalSpace k] [inst_2 : Monoid G] (V : Type w)
[hV1 : AddCommGroup V] [hV2 : Module k V] [hV3 : TopologicalSpace V] [hV4 : IsTopologicalAddGroup V]
[hV5 : ContinuousSMul k V] (ρ : ContRepresentation k G V) (V_1 : Type w) (hV1_1 : AddCommGroup V_1)
(hV2_1... | null | false |
_private.Mathlib.Data.Multiset.Powerset.0.Multiset.disjoint_powersetCard_of_ne._simp_1_1 | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} {s t : Multiset α}, Disjoint s t = ∀ {a : α}, a ∈ s → a ∉ t | null | false |
Prod.instCompleteAtomicBooleanAlgebra._proof_6 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteAtomicBooleanAlgebra α] [inst_1 : CompleteAtomicBooleanAlgebra β]
(a b : α × β), Lattice.inf a b ≤ b | null | false |
Finset.pairwiseDisjoint_filter | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {f : α → Finset β},
(↑s).PairwiseDisjoint f →
∀ (p : β → Prop) [inst : DecidablePred p], (↑s).PairwiseDisjoint fun a => Finset.filter p (f a) | null | true |
Lean.Compiler.LCNF.Param.applyRenaming | Lean.Compiler.LCNF.Renaming | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Param pu → Lean.Compiler.LCNF.Renaming → Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.Param pu) | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.registerSolverExtension.unsafe_1 | Lean.Meta.Tactic.Grind.Types | {σ : Type} → Lean.Meta.Grind.SolverExtension σ → Lean.Meta.Grind.SolverExtension Lean.Meta.Grind.SolverExtensionState | null | true |
Lean.Meta.Canonicalizer.State._sizeOf_1 | Lean.Meta.Canonicalizer | Lean.Meta.Canonicalizer.State → ℕ | null | false |
ProfiniteAddGrp.hom_ext_iff | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {f g : A ⟶ B}, f = g ↔ ProfiniteAddGrp.Hom.hom f = ProfiniteAddGrp.Hom.hom g | null | true |
sq_add_sq_eq_zero | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [NoZeroDivisors R] [ExistsAddOfLE R]
[PosMulMono R] [AddLeftMono R], a ^ 2 + b ^ 2 = 0 ↔ a = 0 ∧ b = 0 | The sum of two squares is zero iff both elements are zero | true |
CategoryTheory.Sieve.ofTwoArrows | Mathlib.CategoryTheory.Sites.Sieves.Basic | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {U V X : C} → (U ⟶ X) → (V ⟶ X) → CategoryTheory.Sieve X | The sieve generated by two morphisms. | true |
TemperedDistribution.instFourierTransform._proof_2 | Mathlib.Analysis.Distribution.TemperedDistribution | SMulCommClass ℝ ℂ ℂ | null | false |
Std.Http.Status.badRequest | Std.Http.Data.Status | Std.Http.Status | 400 Bad Request
| true |
IsSelfInv.div | Mathlib.Algebra.Group.SelfInv | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] {a b : α}, IsSelfInv a → IsSelfInv b → IsSelfInv (a / b) | null | true |
AlgebraicIndependent.map' | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {A' : Type v'} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : CommRing A'] [inst_3 : Algebra R A] [inst_4 : Algebra R A'],
AlgebraicIndependent R x → ∀ {f : A →ₐ[R] A'}, Function.Injective ⇑f → AlgebraicIndependent R (⇑f ∘ x) | null | true |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.counit | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
CategoryTheory.Adjunction.CoreHomEquivUnitCounit F G → (G.comp F ⟶ CategoryTheory.... | The counit of an adjunction | true |
Associates.mk_out | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : MonoidWithZero α] [inst_1 : NormalizationMonoid α] (a : Associates α), Associates.mk a.out = a | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt32.toUSize_sub._simp_1_1 | Init.Data.UInt.Lemmas | ∀ (a : UInt32) (b : USize), (a.toUSize = b % 4294967296) = (a = b.toUInt32) | null | false |
Quiver.Hom.comp_toLoc | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {a b c : C} (f : a ⟶ b) (g : b ⟶ c),
(CategoryTheory.CategoryStruct.comp f g).toLoc = CategoryTheory.CategoryStruct.comp f.toLoc g.toLoc | null | true |
Mathlib.Meta.NormNum.isInt_zpow_neg | Mathlib.Tactic.NormNum.Pow | ∀ {α : Type u_1} [inst : DivisionRing α] {a : α} {b : ℤ} {nb ne : ℕ},
Mathlib.Meta.NormNum.IsInt b (Int.negOfNat nb) →
Mathlib.Meta.NormNum.IsInt (a ^ nb)⁻¹ (Int.negOfNat ne) → Mathlib.Meta.NormNum.IsInt (a ^ b) (Int.negOfNat ne) | null | true |
SupBotHom.dual._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Max α] [inst_1 : Bot α] [inst_2 : Max β] [inst_3 : Bot β],
Function.LeftInverse (fun f => { toSupHom := SupHom.dual.symm f.toInfHom, map_bot' := ⋯ }) fun f =>
{ toInfHom := SupHom.dual f.toSupHom, map_top' := ⋯ } | null | false |
CategoryTheory.Abelian.SpectralObject.isZero_H_obj_of_isIso | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j : ι} (f : i ⟶ j),
CategoryTheory.IsIso f → ∀ (n : ℤ), CategoryTheory.Limits.IsZero ((X.H n).obj (Ca... | null | true |
SSet.ιChainComplex_toNormalizedChainComplex_f_assoc | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (X : SSet) {R : C} {n : ℕ} (x : X.obj (Opposite.op { len := n })) {Z : C}
(h : (X.normalizedChainComplex R).X n ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.ιChainComple... | null | true |
Equiv.starMul._proof_2 | Mathlib.Algebra.Star.TransferInstance | ∀ {R : Type u_2} {S : Type u_1} (e : R ≃ S) [inst : Mul S] (x y : R),
e (e.symm (e.toFun x * e.toFun y)) = e.toFun x * e.toFun y | null | false |
_private.Mathlib.RingTheory.ReesAlgebra.0.reesAlgebra.monomial_mem._simp_1_2 | Mathlib.RingTheory.ReesAlgebra | ∀ {a b : Prop}, (¬a ∨ b) = (a → b) | null | false |
Int.mul_tdiv_self | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.tdiv b = a - a.tmod b | null | true |
Descriptive.Tree.mem_pullSub_self | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} {T : ↥(Descriptive.tree A)} {x : List A}, x ∈ Descriptive.Tree.pullSub T x ↔ [] ∈ T | null | true |
CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._proof_7 | Mathlib.CategoryTheory.Sites.Monoidal | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_4) [inst_1 : CategoryTheory.Category.{u_2, u_4} A] [inst_2 : CategoryTheory.MonoidalCategory A]
[inst_3 : J.W.IsMonoidal] [inst_4 : CategoryTheory.HasWeakSheafify J A],
autoParam
(∀ (X Y Z : ... | null | false |
CategoryTheory.Equivalence.asNatTrans_mkHom | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{e f : C ≌ D} (η : e ⟶ f), CategoryTheory.Equivalence.asNatTrans (CategoryTheory.Equivalence.mkHom η) = η | null | true |
Subgroup.instSetLike | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_1} → [inst : Group G] → SetLike (Subgroup G) G | null | true |
_private.Init.Data.Rat.Lemmas.0.Rat.eq_iff_mul_eq_mul._simp_1_1 | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, (a = b) = (a ≤ b ∧ b ≤ a) | null | false |
FractionalIdeal.dual_involutive | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {K : Type u_2} {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L... | null | true |
Ideal.spanNorm_eq_bot_iff._simp_1 | Mathlib.RingTheory.Ideal.Norm.RelNorm | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {S : Type u_3} [inst_2 : CommRing S] [inst_3 : IsDomain S]
[inst_4 : IsIntegrallyClosed R] [inst_5 : IsIntegrallyClosed S] [inst_6 : Algebra R S] [inst_7 : Module.Finite R S]
[inst_8 : Module.IsTorsionFree R S] {I : Ideal S}, (Ideal.spanNorm R I = ⊥) = (I =... | null | false |
Fin.OrderEmbedding.instInhabitedOrderEmbeddingNat | Mathlib.Order.Fin.Basic | {n : ℕ} → Inhabited (Fin n ↪o ℕ) | null | true |
Std.Http.Body.instForInAsyncStreamChunk | Std.Http.Data.Body.Stream | ForIn Std.Async.Async Std.Http.Body.Stream Std.Http.Chunk | null | true |
SaturatedAddSubmonoid.instCompleteLattice | Mathlib.Algebra.Group.Submonoid.Saturation | (M : Type u_1) → [inst : AddZeroClass M] → CompleteLattice (SaturatedAddSubmonoid M) | null | true |
CategoryTheory.Arrow.leftFunc._proof_1 | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : CategoryTheory.Arrow C),
CategoryTheory.Arrow.Hom.left (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id X.left | null | false |
Std.ExtTreeMap.getKey!_maxKey | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {he : t ≠ ∅}, t.getKey! (t.maxKey he) = t.maxKey he | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceOr.declare_68._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.4244039097._hygCtx._hyg.27 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
_private.Mathlib.Combinatorics.Additive.AP.Three.Behrend.0.Behrend.map_succ._simp_1_3 | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),
∑ i ∈ s, f i * a = (∑ i ∈ s, f i) * a | null | false |
smoothSheafCommRing.ι_evalHom_assoc | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : Topo... | null | true |
CoxeterMatrix.reindexGroupEquiv_symm_apply_simple | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} {B' : Type u_2} (M : CoxeterMatrix B) (e : B ≃ B') (i : B),
(M.reindexGroupEquiv e).symm (M.simple i) = (CoxeterMatrix.reindex e M).simple (e i) | null | true |
LinearMap.exists_eq_smul_id_of_forall_notLinearIndependent | Mathlib.LinearAlgebra.Center | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup V] [inst_3 : Module R V]
[Module.Free R V] {f : V →ₗ[R] V}, (∀ (v : V), ¬LinearIndependent R ![v, f v]) → ∃ a, f = a • 1 | Over a commutative domain, an endomorphism `f` of a free module `V`
such that `f v` and `v` are collinear, for all `v : V`,
consists of homotheties. | true |
_private.Mathlib.SetTheory.Ordinal.FixedPointApproximants.0.OrdinalApprox.lfpApprox_ord_mem_fixedPoint.match_1_1 | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Type u_1} [inst : CompleteLattice α] (f : α →o α) {x : α}
(motive :
(∃ a < (Order.succ (Cardinal.mk α)).ord,
∃ b < (Order.succ (Cardinal.mk α)).ord, a ≠ b ∧ OrdinalApprox.lfpApprox f x a = OrdinalApprox.lfpApprox f x b) →
Prop)
(x_1 :
∃ a < (Order.succ (Cardinal.mk α)).ord,
∃ b < ... | null | false |
List.length_sublists'._f | Mathlib.Data.List.Sublists | ∀ {α : Type u} (x : List α) (f : List.below x), x.sublists'.length = 2 ^ x.length | null | false |
Finset.one_lt_prod' | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : CommMonoid M] [inst_1 : Preorder M] [IsOrderedCancelMonoid M] {f : ι → M}
{s : Finset ι} [MulLeftStrictMono M], (∀ i ∈ s, 1 ≤ f i) → (∃ i ∈ s, 1 < f i) → 1 < ∏ i ∈ s, f i | null | true |
Prod.instOrderSupSet | Mathlib.Order.CompleteLattice.Basic | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [OrderSupSet α] → [inst_2 : Preorder β] → [OrderSupSet β] → OrderSupSet (α × β) | null | true |
ProbabilityTheory.definition._@.Mathlib.Probability.Kernel.CondDistrib.2261733823._hygCtx._hyg.2 | Mathlib.Probability.Kernel.CondDistrib | {α : Type u_1} →
{β : Type u_2} →
{Ω : Type u_3} →
[inst : MeasurableSpace Ω] →
[StandardBorelSpace Ω] →
[Nonempty Ω] →
{x : MeasurableSpace α} →
[inst_3 : MeasurableSpace β] →
(α → Ω) →
(α → β) →
(μ : MeasureT... | null | false |
AddActionHom.instVAddOfVAddCommClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {X : Type u_4} {Y : Type u_5} {σ : M → N} [inst : VAdd M X]
[inst_1 : VAdd N Y] [inst_2 : VAdd R Y] [inst_3 : VAddCommClass N R Y],
AddActionHom.instVAddOfVAddCommClass = { vadd := fun h f => { toFun := h +ᵥ ⇑f, map_vadd' := ⋯ } } | null | true |
Std.DHashMap.Const.isEmpty_alter_eq_isEmpty_erase | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k : α} {f : Option β → Option β},
(Std.DHashMap.Const.alter m k f).isEmpty = ((m.erase k).isEmpty && (f (Std.DHashMap.Const.get? m k)).isNone) | null | true |
SimpleGraph.edgeSetSumEquiv.match_1 | Mathlib.Combinatorics.SimpleGraph.Sum | {V : Type u_1} →
{W : Type u_2} →
{G : SimpleGraph V} →
{H : SimpleGraph W} →
(motive : (x x_1 : V ⊕ W) → (G ⊕g H).Adj x x_1 → Sort u_3) →
(x x_1 : V ⊕ W) →
(x_2 : (G ⊕g H).Adj x x_1) →
((u v : V) → (h : (G ⊕g H).Adj (Sum.inl u) (Sum.inl v)) → motive (Sum.inl u) (... | null | false |
MeasureTheory.VectorMeasure.dirac_apply_of_mem | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {β : Type u_2} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] [inst_2 : MeasurableSpace β]
{x : β} {v : M} {s : Set β}, MeasurableSet s → x ∈ s → (MeasureTheory.VectorMeasure.dirac x v) s = v | null | true |
IntermediateField.finiteDimensional_adjoin | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {K : Type u} [inst : Field K] {L : Type u_3} [inst_1 : Field L] [inst_2 : Algebra K L] {S : Set L} [Finite ↑S],
(∀ x ∈ S, IsIntegral K x) → FiniteDimensional K ↥(IntermediateField.adjoin K S) | If `L / K` is a field extension, `S` is a finite subset of `L`, such that every element of `S`
is integral (= algebraic) over `K`, then `K(S) / K` is a finite extension.
A direct corollary of `finiteDimensional_iSup_of_finite`. | true |
PiTensorProduct.dualDistribInvOfBasis._proof_2 | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
Mathlib.Meta.FunProp.Result.mk | Mathlib.Tactic.FunProp.Types | Lean.Expr → Mathlib.Meta.FunProp.Result | null | true |
Lean.Compiler.LCNF.Simp.JpCasesInfo.mk.sizeOf_spec | Lean.Compiler.LCNF.Simp.JpCases | ∀ (paramIdx : ℕ) (ctorNames : Lean.NameSet),
sizeOf { paramIdx := paramIdx, ctorNames := ctorNames } = 1 + sizeOf paramIdx + sizeOf ctorNames | null | true |
AlgebraicGeometry.Scheme.Hom.preimage_bot | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y), (TopologicalSpace.Opens.map f.base).obj ⊥ = ⊥ | null | true |
GroupExtension.Equiv.trans._proof_1 | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_3} {G : Type u_5} [inst : Group N] [inst_1 : Group E] [inst_2 : Group G]
{S : GroupExtension N E G} {E' : Type u_4} [inst_3 : Group E'] {S' : GroupExtension N E' G} (equiv : S.Equiv S')
{E'' : Type u_2} [inst_4 : Group E''] {S'' : GroupExtension N E'' G} (equiv' : S'.Equiv S''),
⇑(equ... | null | false |
instIdempotentOpInt16HAnd | Init.Data.SInt.Bitwise | Std.IdempotentOp fun x1 x2 => x1 &&& x2 | null | true |
isMax_iff_eq_top._simp_2 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, IsMax a = (a = ⊤) | null | false |
preNormEDS'._proof_5 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ (n : ℕ), InvImage (fun x1 x2 => x1 < x2) (fun x => x) (n / 2 + 1) n.succ.succ.succ.succ.succ | null | false |
CategoryTheory.CostructuredArrow.costructuredArrowToOverEquivalence.inverse._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor D T) {X : T} (Y : CategoryTheory.Over X)
(Z : CategoryTheory.CostructuredArrow F Y.left),
CategoryTheory.CategoryStruct.comp Z.hom Y.hom =
((CategoryTheory.... | null | false |
CategoryTheory.MorphismProperty.Comma.mapRightComp_hom_app_left | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | null | true |
_private.Lean.Data.JsonRpc.0.Lean.JsonRpc.instBEqResponseError.beq.match_1 | Lean.Data.JsonRpc | {α : Type u_1} →
(motive : Lean.JsonRpc.ResponseError α → Lean.JsonRpc.ResponseError α → Sort u_2) →
(x x_1 : Lean.JsonRpc.ResponseError α) →
((a : Lean.JsonRpc.RequestID) →
(a_1 : Lean.JsonRpc.ErrorCode) →
(a_2 : String) →
(a_3 : Option α) →
(b : Lean.Jso... | null | false |
CategoryTheory.GradedObject.mapTrifunctor_obj | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.